feat: wire the tier through the transport and keep each tier's warning distinct

The transport now hands back the tier it actually sent, and that tier
rides TransportResult into LLMResponse. It is not the requested one:
under EFFORT_FALLBACK=nearest a medium request goes out as low, and
telemetry grouping by the requested tier would file the row under a tier
that never left the process.

Reconciliation judges the same tier instead of the old enable_thinking
bool, and the warning throttle keys on it. Keyed on the bool, every tier
of one model shared a single key, so the second contradiction was
silenced for the lifetime of the transport. The predicate is an identity
check against Effort.NONE on purpose -- the member's value is the
non-empty string "none", so any truthiness test would send every strength
tier down the "asked to disable" branch and invert the alarm.

tests/unit/test_client.py

@@ -312,6 +312,52 @@ class TestEffortFallbackWiring:
         assert captured == []  # 请求根本没发出去
 
 
+class TestAppliedTierReachesTheCaller:
+    """`LLMResponse.applied_effort` 报的是**真正发出去的**那一档(计划 T8-5)。
+
+    对下游是新能力(它终于能知道这次跑在哪档),对遥测是前置条件: 记请求档会让
+    按档分组的压测把整行挂在一个从未发出过的档下,而那种数据错得看不出来。
+    """
+
+    async def test_response_carries_the_mapped_tier(self):
+        """glm-5.3 无 `medium`: 开了 nearest 后实际跑的是 low,响应必须这么说。"""
+        source = _source(provider="zhipu", model="glm-5.3", effort_fallback="nearest")
+        async with _client(sources=[source]) as client:
+            resp = await client.chat(
+                [{"role": "user", "content": "hi"}], reasoning_effort=Effort.MEDIUM
+            )
+        assert resp.applied_effort is Effort.LOW
+
+    async def test_no_statement_leaves_the_field_none(self):
+        async with _client() as client:
+            resp = await client.chat([{"role": "user", "content": "hi"}])
+        assert resp.applied_effort is None
+
+
+class TestUnsupportedTierIsRefusedNotRetried:
+    """档位不可满足 = 请求本身的问题: 报 `RequestRejectedError`,不重试、不伤熔断。
+
+    重试与换源都不会让它变对(设计 §10),而把它计进熔断更糟——一次配置错误会
+    把一个健康的源关掉,拖垮与推理无关的所有调用。
+    """
+
+    async def test_tier_error_never_reaches_the_gateway_or_the_breaker(self):
+        sent = []
+
+        def handler(request):
+            sent.append(request)
+            return _sse()
+
+        # 阈值取 1: 只要这次失败被计进熔断,门当场开路,断言立刻可见
+        gate = InMemoryGate(config=BreakerConfig(1, 60.0, 120.0))
+        source = _source(name="zp", provider="zhipu", model="glm-5.3")
+        async with _client(sources=[source], handler=handler, breaker=gate) as client:
+            with pytest.raises(RequestRejectedError, match="无法关闭推理"):
+                await client.chat([{"role": "user", "content": "hi"}], reasoning_effort=Effort.NONE)
+        assert sent == [], "请求根本不该发出去: 档位不可满足在组装期就已判定"
+        assert (await gate.try_enter("zp", "w")).allowed, "配置错误不得计入熔断失败"
+
+
 class TestRequestTierNormalization:
     """`chat(reasoning_effort=...)` 是公共入口,裸字符串必须在此归一(issue #20)。
 
@@ -515,7 +561,6 @@ class TestModelFingerprint:
         expected = "qwen-max|" + hashlib.sha256(mark.encode("utf-8")).hexdigest()
         assert build_model_fingerprint([_source(extra_body={"temperature": 0})]) == expected
 
-
     def test_declared_tier_fingerprint_is_a_golden(self):
         """配了档位那一侧的指纹字面量也要钉死: 它变了就是该源整段缓存冷启动。
 

tests/unit/test_openai_compat.py

@@ -23,7 +23,7 @@ from polygateway.transports.openai_compat import (
     _iter_sse_deltas,
     _sse_data_payload,
 )
-from polygateway.types import ChatRequest, LLMResponse, SourceConfig, ThinkingObservation
+from polygateway.types import ChatRequest, Effort, LLMResponse, SourceConfig, ThinkingObservation
 
 
 def _source(**overrides):
@@ -629,6 +629,60 @@ class TestThinkingReconciliation:
         hits = [m for m in messages if "MiniMax-M3" in m]
         assert len(hits) == 2, f"两个方向各应告警一次,实得 {len(hits)} 次"
 
+    async def test_each_tier_of_one_model_earns_its_own_warning(self):
+        """同一源同一模型的两个强度档是**两个独立的矛盾**,不得共用一个节流键。
+
+        节流键沿用旧的 `enable_thinking` 三态时,两次请求的键逐字相同(都是
+        `None`——档位根本不经过那个字段),于是 `max` 档的矛盾被 `low` 档那次
+        永久静音。档位化后 low 与 max 各喊一次,重复的 low 仍只喊一次。
+        """
+        transport = _transport_for(self._zero_signal)
+        source = _source(name="zp", provider="zhipu", model="glm-5.3")
+        messages: list[str] = []
+        sink_id = logger.add(messages.append, level="WARNING")
+        try:
+            await _complete(transport, source, reasoning_effort=Effort.LOW)
+            await _complete(transport, source, reasoning_effort=Effort.LOW)
+            await _complete(transport, source, reasoning_effort=Effort.MAX)
+        finally:
+            logger.remove(sink_id)
+        hits = [m for m in messages if "glm-5.3" in m]
+        assert len(hits) == 2, f"low 与 max 应各告警一次,实得 {len(hits)} 次"
+
+    def _zero_signal(self, request):
+        """零推理信号的成功响应 → UNKNOWN,与"要求开启"矛盾(M3 实测形态)。"""
+        return _sse_stream(_chunk(content="ok"), _chunk(usage=_USAGE))
+
+
+class TestAppliedTierLeavesTheTransport:
+    """本次**实际**发出去的档必须随 TransportResult 上浮(设计 §4.1 / 计划 T8-5)。
+
+    不上浮就只能由遥测自己再算一遍请求档,而 `nearest` 映射后两者不同——压测
+    要按档分组的那一列会挂在一个从未真正发出过的档下,且错得看不出来。
+    """
+
+    def _ok(self, request):
+        return _sse_stream(_chunk(content="ok"), _chunk(usage=_USAGE))
+
+    async def test_result_carries_the_mapped_tier_not_the_requested_one(self):
+        """glm-5.3 只有 low/high/max: 请求 `medium`,实际发出的是 `low`。"""
+        transport = _transport_for(self._ok)
+        source = _source(provider="zhipu", model="glm-5.3", effort_fallback="nearest")
+        result = await _complete(transport, source, reasoning_effort=Effort.MEDIUM)
+        assert result.applied_effort is Effort.LOW
+
+    async def test_result_carries_the_tier_that_was_asked_for_when_supported(self):
+        transport = _transport_for(self._ok)
+        source = _source(provider="zhipu", model="glm-5.3")
+        result = await _complete(transport, source, reasoning_effort=Effort.MAX)
+        assert result.applied_effort is Effort.MAX
+
+    async def test_no_statement_stays_none(self):
+        """不表态时库既不注入也不推定模型默认档——"没看见"不许说成"发生了"。"""
+        transport = _transport_for(self._ok)
+        result = await _complete(transport, _source())
+        assert result.applied_effort is None
+
 
 class TestNonStreamFastPath:
     async def test_non_stream_parses_message(self):

tests/unit/test_retry.py

@@ -288,6 +288,33 @@ class TestObservabilityPassthrough:
         resp = await mw(_REQ)
         assert resp.thinking_observation is ThinkingObservation.UNKNOWN
 
+    async def test_applied_tier_reaches_the_response(self):
+        """issue #20: 实际发出的档由 transport 裁定,本层只搬运。
+
+        搬运这一步漏掉,`LLMResponse.applied_effort` 恒为 None,而遥测正是从这个
+        字段取"这一行跑在哪档"——整列会静默地全是 NULL。
+        """
+        result = TransportResult(
+            content="ok",
+            thinking="",
+            prompt_tokens=10,
+            completion_tokens=5,
+            usage_source="measured",
+            ttft_ms=12.0,
+            max_inter_token_ms=3.0,
+            raw={},
+            applied_effort=Effort.HIGH,
+        )
+        mw, *_ = _harness([_src("a")], [result])
+        resp = await mw(_REQ)
+        assert resp.applied_effort is Effort.HIGH
+
+    async def test_unstated_tier_stays_none(self):
+        """不表态的调用不得被填成某个档: 那等于替调用方声称它做过一个选择。"""
+        mw, *_ = _harness([_src("a")], [_ok()])
+        resp = await mw(_REQ)
+        assert resp.applied_effort is None
+
 
 class TestRetryAndFailover:
     async def test_transient_switches_source_then_succeeds(self):

tests/unit/test_thinking.py

@@ -445,10 +445,14 @@ class TestResolveThinking:
 
 
 class TestReconcileThinking:
-    """声明 × 观测对账(设计 §5): 矛盾出文案,不表态出 None。
+    """声明 × 观测对账(设计 §4.3): 矛盾出文案,不表态出 None。
 
     文案本身是被断言对象——判定与日志分离正是为此: 告警内容可直接比对,不必
     去解析日志格式。
+
+    判据自 2026-09-05 起是**档位**而非布尔(设计 §4.3): `Effort.NONE` 走"要求
+    关闭"一支,其余档走"要求开启"一支。档位化不是换个参数名——文案里写的是本次
+    真正发出去的那一档,而 transport 的节流键正按它分离,两者必须同源。
     """
 
     _CAP = ThinkingCapability(
@@ -458,7 +462,7 @@ class TestReconcileThinking:
     def test_off_but_observed_with_a_registered_capability_blames_the_table(self):
         """已登记却实测推理了 = 能力表漂移: 必须附 evidence 与更新指路。"""
         msg = reconcile_thinking(
-            enable_thinking=False,
+            effort=Effort.NONE,
             observation=ThinkingObservation.OBSERVED,
             capability=self._CAP,
             model="MiniMax-M3",
@@ -471,7 +475,7 @@ class TestReconcileThinking:
     def test_off_but_observed_unregistered_never_claims_a_table_entry(self):
         """未登记模型没有"能力表声称"这回事——说它就是撒谎。"""
         msg = reconcile_thinking(
-            enable_thinking=False,
+            effort=Effort.NONE,
             observation=ThinkingObservation.OBSERVED,
             capability=None,
             model="MiniMax-M9",
@@ -483,13 +487,13 @@ class TestReconcileThinking:
 
     def test_registered_and_unregistered_wordings_differ(self):
         registered = reconcile_thinking(
-            enable_thinking=False,
+            effort=Effort.NONE,
             observation=ThinkingObservation.OBSERVED,
             capability=self._CAP,
             model="MiniMax-M3",
         )
         unregistered = reconcile_thinking(
-            enable_thinking=False,
+            effort=Effort.NONE,
             observation=ThinkingObservation.OBSERVED,
             capability=None,
             model="MiniMax-M3",
@@ -500,7 +504,7 @@ class TestReconcileThinking:
     def test_on_but_absent_is_a_contradiction(self, capability):
         """上游明确上报未推理: 这是唯一的正面证伪,与能力表登记与否无关。"""
         msg = reconcile_thinking(
-            enable_thinking=True,
+            effort=Effort.AUTO,
             observation=ThinkingObservation.ABSENT,
             capability=capability,
             model="qwen3.7-plus",
@@ -512,7 +516,7 @@ class TestReconcileThinking:
     def test_on_but_unknown_admits_it_cannot_confirm(self, capability):
         """issue #17 的诚实版本: 明说"我注入了,但我看不见结果"。"""
         msg = reconcile_thinking(
-            enable_thinking=True,
+            effort=Effort.AUTO,
             observation=ThinkingObservation.UNKNOWN,
             capability=capability,
             model="MiniMax-M3",
@@ -529,7 +533,7 @@ class TestReconcileThinking:
         """
         assert (
             reconcile_thinking(
-                enable_thinking=False,
+                effort=Effort.NONE,
                 observation=ThinkingObservation.ABSENT,
                 capability=self._CAP,
                 model="qwen3.7-plus",
@@ -541,7 +545,7 @@ class TestReconcileThinking:
         """UNKNOWN 没有证伪力: 拿它报警等于每次关闭调用都喊(M3 关闭档恒落此档)。"""
         assert (
             reconcile_thinking(
-                enable_thinking=False,
+                effort=Effort.NONE,
                 observation=ThinkingObservation.UNKNOWN,
                 capability=self._CAP,
                 model="MiniMax-M3",
@@ -557,7 +561,7 @@ class TestReconcileThinking:
         """调用方不表态,就无从谈"违背"。"""
         assert (
             reconcile_thinking(
-                enable_thinking=None,
+                effort=None,
                 observation=observation,
                 capability=self._CAP,
                 model="MiniMax-M3",
@@ -568,7 +572,7 @@ class TestReconcileThinking:
     def test_on_and_observed_is_exactly_what_was_asked_for(self):
         assert (
             reconcile_thinking(
-                enable_thinking=True,
+                effort=Effort.AUTO,
                 observation=ThinkingObservation.OBSERVED,
                 capability=self._CAP,
                 model="MiniMax-M3",
@@ -576,6 +580,56 @@ class TestReconcileThinking:
             is None
         )
 
+    @pytest.mark.parametrize("effort", [Effort.LOW, Effort.HIGH, Effort.MAX])
+    def test_a_strength_tier_is_an_on_request_not_an_off_one(self, effort):
+        """强度档必须走"要求开启"一支: 观测到推理正是它要的结果,不得报警。
+
+        判据写成真值性(`if not effort`)会在这里翻车——`Effort.NONE` 的取值是
+        非空串 `"none"`,恒为真;那种写法会把每一个强度档都送进"要求关闭"分支,
+        于是"想了"被当成矛盾,而"没想"反倒沉默,告警方向整个颠倒。
+        """
+        assert (
+            reconcile_thinking(
+                effort=effort,
+                observation=ThinkingObservation.OBSERVED,
+                capability=ThinkingCapability((Effort.LOW, Effort.HIGH, Effort.MAX), "构造"),
+                model="glm-5.3",
+            )
+            is None
+        )
+
+    def test_the_wording_names_the_tier_that_was_asked_for(self):
+        """文案要写出**本次这一档**: 节流键按档分离,文案不分档就看不出是哪一档。"""
+        low = reconcile_thinking(
+            effort=Effort.LOW,
+            observation=ThinkingObservation.ABSENT,
+            capability=None,
+            model="glm-5.3",
+        )
+        max_ = reconcile_thinking(
+            effort=Effort.MAX,
+            observation=ThinkingObservation.ABSENT,
+            capability=None,
+            model="glm-5.3",
+        )
+        assert low is not None and max_ is not None
+        assert "low" in low and "max" in max_
+        assert low != max_
+
+    def test_none_and_observed_is_the_issue_20_contradiction(self):
+        """请求 `none` 却观测到推理 —— issue #20 要恢复的那条报警,判据是**档位相等**。
+
+        与上一条互为对照: 同样是 OBSERVED,`none` 必须喊、强度档必须沉默。把分支
+        条件写反(`is not Effort.NONE`)会让这两条同时红,单有一条则抓不住。
+        """
+        msg = reconcile_thinking(
+            effort=Effort.NONE,
+            observation=ThinkingObservation.OBSERVED,
+            capability=None,
+            model="glm-5.3",
+        )
+        assert msg is not None and "none" in msg
+
 
 class TestEffortVocabulary:
     """八档封闭词汇(设计 §3.1);`auto` 不可省——9 个纯开关型模型无强度档可填。"""