@whyshu/argent-engine 0.0.0-stage → 0.6.1

package/engine/scripts/ml_capacity_probe.py

@@ -0,0 +1,1158 @@
+#!/usr/bin/env python3
+"""仓容（库容）前置探测 —— **纯判据 + 只读探针**（FULL 自动路径成功率修复批，2026-10-10）。
+
+## 它解决什么（用户亲历 + 我方实测）
+
+10-10 客户机 lip 表跑约 30 条 FULL，**约 1/3 失败**；同一天 CLI 手动串行跑 6 票**全部 8/8 成功**。
+逐条对账后，失败**全部**与「**仓容满** / 预约页形态异常」相关：平台原文
+
+    para enviar productos, primero deberás liberar espacio de almacenamiento
+    retirando stock de baja calidad
+
+且列表页显示 `N Envíos para terminar de preparar`。旧路径**不先探测就每次撞墙**：步骤4 预约
+一路试到窗口尽头，把「仓容满」这个**一句话就能判定的前提问题**写成了一个看起来像
+「平台没放号 / 页面形态异常」的业务失败，运营看了也不知道该干什么。
+
+⇒ 本模块给「**进步骤4 之前先只读看一眼仓容**」这条链一份**确定性判据**。
+
+## 分层（⛔ 别把浏览器塞进判据里）
+
+- **纯判据（本文件 99%）**：`capacity_verdict()` 吃「只读证据字典」吐三态结论。
+  **无浏览器、无网络、无宿主依赖**（只有 stdlib）⇒ 可用纯夹具做回归。
+- **只读探针**（`JS_CAPACITY_DUMP` + 编排器的 `Orchestrator._capacity_precheck()`）：
+  导航到店铺列表页（**只读，⛔ 不点任何按钮**）→ `page.evaluate` → 交给本模块判定。
+
+## 三态（**唯一口径**，调用方只认这三个值）
+
+| 值 | 含义 | 调用方该做什么 |
+|---|---|---|
+| `capacity_full` | 页面**逐字**出现平台仓容原文 **∧ 该原文处于「严格阻断形态」** ⇒ 仓容确已满 | **⛔ 不进入步骤4**，直接落 `capacity_full` 类失败（文案见 `capacity_failure_text()`） |
+| `capacity_available` | 页面**确认可读**且**没有任何**仓容原文 ⇒ 仓容可用 | 照常进入步骤4；若本 case 有活跃的仓容类 defer 标记 ⇒ **当日解除**（见 `defer_lift_decision()`） |
+| `unavailable` | 其余**一切**情形（页面取不到 / 超时 / 平台错误页 / 关键区域未渲染 /「Enviar productos」明确不存在 / **命中原文但不是阻断形态（含说明卡）** / 结构证据不足） | **保守**：⛔ **不**判仓容满、⛔ **也**不判仓容正常 —— 照常尝试预约，证据如实留痕 |
+
+⛔ **铁律（有回归钉住）**：`unavailable` **永远不是** `capacity_full`，也**永远不是**
+`capacity_available`。探针抛异常也**永远**是 `unavailable`（见 `capacity_verdict()` 的
+残缺闸门）——"因为探测失败就当作仓容满"会**凭空拦下本来能成的票**（自动路径成功率反而更低），
+"因为探测失败就当作仓容正常"则等于没有这道闸门。
+
+## 判据表（逐条对应实现；**顺序即优先级，先命中先赢**）
+
+| 步 | 条件 | 结论 |
+|---|---|---|
+| 0 | **残缺闸门**：无来源 / 所有来源 `ok=False`（导航失败、超时、evaluate 异常） | `unavailable`（逐源原因进 `evidence`） |
+| 1 | 平台原文命中（文本 / 既有 `capacity_warning` / **命中元素**）**∧ 严格阻断形态成立**（见下节） | `capacity_full`（原文**逐字**进 `quote`） |
+| 1b | 平台原文命中但**阻断形态不成立**（说明/帮助卡、折叠在页面底部、元素不可见、**结构证据不足**） | **`unavailable`**（`judge=quote-not-blocking`）⇒ 照常尝试步骤4，证据（命中文本/元素位置与可见性/阻断横幅有无/按钮状态）全进 `evidence` |
+| 2 | 原文未命中 ∧ 有来源 `ok=True` ∧ **是**平台错误页（`error_page` 非空） | `unavailable`（错误页 ⇒ 读不到仓容真相） |
+| 3 | 原文未命中 ∧ 有来源 `ok=True` ∧ 页面文本非空 ∧ `enviar_present is not False` | `capacity_available` |
+| 4 | 其余（`ok=True` 但文本空 / 明确"Enviar productos 不存在"） | `unavailable` |
+
+### 严格阻断形态（判据要**纯函数化**：`blocking_form()`；2026-10-12 收紧）
+
+**为什么收紧**：旧判据是「整页 `innerText` 前 6000 字**包含**该短语」**或**「任一 `.andes-card`
+含 `liberar espacio`」⇒ **见词就判满**。生产实测（2026-10-12，货件 79294682）：屏幕 OCR 显示
+该页是**正常的 FULL 管理页**（徽标 `84 Envíos para terminar de preparar`、按钮 **`Enviar productos`
+在**、列表有正常行、**没有**任何"库容满"横幅），命中来自 DOM 里**别处**的文本（最可能是页面
+下方的**说明/帮助卡**含同一句话）⇒ 判成 `capacity_full` 把**能跑的票**拦死（代价 = 一天延迟 +
+人工介入；实测同一票手动重跑 **8/8 成功**）。所以：**平台原文只是必要条件，不是充分条件**。
+
+一个来源命中原文时，**同时**满足下列三条才算「阻断形态」（三选一即算，`shape` 进证据）：
+
+1. **可交互/阻断位置**（任一）：
+   - **S1 模态/对话框内**：命中元素在**可见**的 `.andes-modal` / `.andes-dialog` /
+     `[role=dialog|alertdialog]` 内（模态本来就是阻断交互的载体）；
+   - **S2 alert/banner 紧邻主操作按钮上方**：命中元素在 alert/banner 容器内
+     （`.andes-alert`/`.andes-banner`/`.andes-message`/`.andes-notification`/`[role=alert]`），
+     且与「`Enviar productos`」按钮**水平重叠**、纵向间距 ≤ `PRIMARY_ADJACENT_GAP_PX`；
+   - **S3 主操作按钮缺失/禁用**：列表**已渲染**时按钮 `enviar_present is False` 或
+     `enviar_disabled is True`（`selectors.md` 记「库容满时该按钮不显示/禁用」）。
+2. **该元素可见**：非零 rect ∧ 自身 `display != none` ∧ `visibility ∉ {hidden, collapse}` ∧
+   `opacity > 0`（零 rect 同时覆盖"祖先 `display:none`"——那种元素**不该**参与阻断）。
+3. **该元素参与阻断**：在**视口内**（不被折叠到页面底部）∧ **不在说明/帮助卡内**
+   （modal / alert 容器例外）∧ **有几何证据**（缺 viewport/rect ⇒ **不知道**，一律不硬判）。
+
+⛔ **结构证据不足（旧探针形态 / 无 `quote_hits` / 无 viewport）⇒ 一律 `unavailable`**
+（保守照常尝试），⛔ **绝不**因为"文本里有那串字"就判满。这条是 2026-10-12 误报的根治点：
+**宁可漏判（= 照常试一次，成本几秒），不可误拦（= 一天延迟 + 人工）。**
+
+### 三个刻意的设计（改这条 = 改判据）
+
+1. **仓容与"日历形态"是两条链，⛔ 绝不合并**：
+   本模块**只**回答"仓容满不满"；「`div.day` 命中 0 ⇒ 日历没渲染」由
+   `orchestrator.appointment_form_verdict()` 独立判定（那是**页面形态**问题，另有取证与处置）。
+   本模块**不看** `div.day` / `div.hour` 的命中数，也**不产出**任何"无时段/没放号"的说法。
+2. **`N Envíos para terminar de preparar` 是佐证，不是判据**：
+   它单独出现**只说明该店还有待备货的货件**（正常状态也会有），⇒ 只记
+   `corroborated=True` + `prepared_count=N` **留痕**，⛔ **不足以**判 `capacity_full`
+   （把它当判据 = 把正常页判成仓容满，凭空拦住能成的票，比漏判更贵）。反过来，
+   平台原文命中**且阻断形态成立**时**不论**有没有这句横幅都判 `capacity_full`
+   （那时原文是硬证据，漏判 = 继续撞墙）。
+3. **`enviar_present is False` 只在"列表已渲染"时才作数**（`rendered is True`）：
+   `skills/ml-fulfillment-sop/references/selectors.md` 已记「库容满时 `Enviar productos`
+   按钮不显示/禁用」⇒ 按钮**明确不存在/禁用**且列表渲染过，是 S3 阻断形态的一部分。
+   但 `None`（没找到 ≠ 不存在，可能是选择器没命中/页面没渲染完）**不作数** ——
+   否则选择器一漂移，这道闸门就恒 `unavailable`，等于白做。
+4. **命中原文 ≠ 判"仓容正常"**：只在**一个平台原文片段都没有**时才敢判
+   `capacity_available`（那是能**当日解除 defer 护栏**的唯一证据）。命中但非阻断 ⇒
+   `unavailable`（照常尝试步骤4，但**不**提前解除护栏）——两条纪律方向不同，不是矛盾
+   （同 `defer_lift_decision()` 的说明）。
+
+## 与既有 `failureClasses` 的关系（⛔ 不新造第二条真相）
+
+平台原文片段来自**既有**判据，逐条有出处：
+
+- `liberar espacio` —— `scripts/orchestrator.py` 的 `JS_EXTRACT_SHIPMENTS`（步骤1 既有探针的
+  `capacity_warning`）与 `skills/ml-fulfillment-sop/references/selectors.md`（「库容警告容器」行）；
+- `liberar espacio de almacenamiento` / `retirar stock de baja calidad` —— 客户机台账里的
+  **平台原文**（本批的背景证据，逐字）。
+
+⚠️ **2026-10-12 起，"原文片段"只用于「命中识别」与「分类侧」**（失败文案的 `quote`、
+`failureClasses.capacityFull` 的机器标记）——**拦截判据另加"严格阻断形态"这一层**（见上节）。
+生产实测证明：同一句话也会出现在页面的**说明/帮助卡**里，而那时平台**并没有**拒绝发货
+（同一票手动用运维开关重跑 **8/8 成功**）。
+
+`scripts/flow-requirements.json#failureClasses.capacityFull` 是**分类侧**的同一份口径；
+`PLATFORM_QUOTES` 与它**必须一致**（门禁 `scripts/tests/capacity-precheck.test.py` 钉住）。
+
+## CLI（离线，不需要浏览器）
+
+    python3 scripts/ml_capacity_probe.py --fixture full          # 跑内置夹具
+    python3 scripts/ml_capacity_probe.py --evidence-file e.json   # 判一份已抓到的证据
+    python3 scripts/ml_capacity_probe.py --fixture full --json
+
+真机抓取（只读）走编排器：`--mode capacity-probe [--store-name <店>]`。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import re
+import sys
+from typing import Any, Optional
+
+# ══════════════════════════════════════════════════════════════════════════
+# 一、三态常量（**唯一口径**；⛔ 不要在别处再写字符串字面量）
+# ══════════════════════════════════════════════════════════════════════════
+VERDICT_FULL = "capacity_full"
+VERDICT_AVAILABLE = "capacity_available"
+VERDICT_UNAVAILABLE = "unavailable"
+VERDICTS = (VERDICT_FULL, VERDICT_AVAILABLE, VERDICT_UNAVAILABLE)
+
+# ══════════════════════════════════════════════════════════════════════════
+# 二、判据常量（**唯一一份**；⛔ 不许在 JS / 编排器 / 文档里再写第二份）
+# ══════════════════════════════════════════════════════════════════════════
+
+#: 平台仓容原文的**关键片段**（命中任一 ⇒ 仓容满）。出自上面 docstring 的「与既有判据的关系」。
+PLATFORM_QUOTES = (
+    "liberar espacio de almacenamiento",
+    # 平台那句话里动词有两种形态（客户机台账抓到的是**副动词** `retirando`；既有技能文档里
+    # 写的是不定式 `retirar`）⇒ **两种都收**（漏了任一种 = 该形态的页面上闸门失效）。
+    "retirar stock de baja calidad",
+    "retirando stock de baja calidad",
+    "stock de baja calidad",
+    "liberar espacio",
+)
+
+#: 「`N Envíos para terminar de preparar`」——**佐证**判据（存在性 + N），⛔ 单独不足以判仓容满。
+PREPARED_BANNER_RE = re.compile(
+    r"(\d{1,6})\s*env[ií]os?\s+para\s+terminar\s+de\s+preparar", re.IGNORECASE)
+
+#: 平台原文那句自带的**引导语**（回引整句时用它把句首切准；客户机台账里的原文逐字）。
+QUOTE_LEADINS = ("para enviar productos", "primero deberás", "primero deberas")
+
+#: 业务词（用于文案措辞；⛔ 与 `DEFER_TAG` 分开：后者是**标记串**，会被写入表备注并被读回）。
+CAPACITY_TERM = "仓容"
+
+#: 仓容满时**唯一**该做的动作（运营口径）。文案必须逐字含它。
+ACTION_TEXT = "需运营清低质库存腾库容"
+
+#: 「Enviar productos」入口（`selectors.md`：库容满时此按钮不显示/禁用）。
+ENVIAR_LABEL = "Enviar productos"
+
+#: 平台错误页特征（与 `orchestrator.appointment_form_verdict` / failureClasses 同一批词元；
+#: 只用来判"这一页读不出真相"，⛔ **不**用它产出任何业务结论）。
+ERROR_PAGE_MARKERS = (
+    "algo salió mal", "algo salio mal", "estamos trabajando para solucionarlo",
+    "hubo un error accediendo", "error code:",
+)
+
+# ── 严格阻断形态（2026-10-12；判据见模块 docstring，实现见 `blocking_form()`）─────────
+
+#: 「紧邻主操作按钮」的**纵向**容忍度（px）：命中 alert 底边到主按钮顶边的间距上限。
+#: 再远就不算"紧邻"（页面下方的说明/帮助卡正是靠这条被排除）。
+PRIMARY_ADJACENT_GAP_PX = 240
+
+#: 「水平重叠」的容忍度（px）：命中元素与主按钮在横向上允许的错位量。
+PRIMARY_OVERLAP_TOL_PX = 40
+
+#: 单来源最多参与判定的**命中元素**条数（JS 侧也截断；两道闸门，防结构证据爆掉日志）。
+MAX_HITS = 8
+
+#: 阻断形态名（进 `evidence`/`block_shape`；⛔ 判据与文案同源，别在别处再写一份）。
+SHAPE_MODAL = "S1 模态/对话框内"
+SHAPE_ALERT = "S2 alert/banner 紧邻主按钮上方"
+SHAPE_CTA = "S3 主操作按钮缺失/禁用"
+
+#: 「命中原文但非阻断形态」的判据码（`judge`）—— 便于事后按它统计误报。
+JUDGE_QUOTE_NOT_BLOCKING = "quote-not-blocking"
+
+#: 「Enviar productos」按钮状态的可读措辞（进证据串，⛔ 不参与判定）。
+_PRIMARY_UNRENDERED = "列表未渲染（缺失/禁用不构成负信号）"
+_PRIMARY_ABSENT = "**缺失**（列表已渲染）"
+_PRIMARY_DISABLED = "**存在但禁用**"
+_PRIMARY_OK = "存在且可点"
+_PRIMARY_UNKNOWN = "未确认（选择器未命中 ⇒ 不构成负信号）"
+
+#: 失败文案前缀标记：`capacity_full` 类失败的**机器可识别**标记（分类器模式之一，见注册表）。
+CLASS_MARKER = "capacity_full"
+
+#: 表备注 / 台账里的仓容 defer 标记（次日/当日拾取层按它识别）。**同源同文**：写与读都用它。
+DEFER_TAG = "仓容满"
+
+#: `kind` 标记（failures.jsonl 的 `auto_fail_retry`）：与「时段不可用」的 `defer` 分开计数。
+DEFER_KIND = "defer_capacity"
+#: 解除 defer 的审计事件名（写 `failures.jsonl`，⛔ **不写**统一台账 —— 理由见 `defer_lift_decision`）。
+LIFT_EVENT = "defer_lifted"
+
+#: 仓容类**当日**重试上限（超限 ⇒ 转人工；⛔ 不是无限重试）。
+DEFER_MAX_LIFT = 2
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# 三、只读探针 JS（⛔ 只 dump 证据，**不判定**）
+# ══════════════════════════════════════════════════════════════════════════
+# 设计纪律：JS **不**做"仓容满不满"的判断（那会让判据出现第二份、且改判据要改 JS）。
+# 它只把页面**原文**、**命中元素的结构证据**与几个可复算的布尔/计数 dump 出来，
+# 判定一律回落到 `capacity_verdict()`（纯函数）⇒ 判据可离线回归。
+# ⛔ 全程只读：不 click / 不 fill / 不 submit / 不改 URL 状态。
+JS_CAPACITY_DUMP = r"""(function(){
+  var norm = function(s){ return (s || '').replace(/\s+/g, ' ').trim(); };
+  var body = norm((document.body && (document.body.innerText || document.body.textContent)) || '');
+  // 页面文本截断（够判据用即可；⛔ 不整页回传 —— 长文本会让台账/日志爆掉）
+  var text = body.length > 6000 ? body.slice(0, 6000) : body;
+  // 「N Envíos para terminar de preparar」：佐证（存在性 + N）
+  var m = body.match(/(\d{1,6})\s*Env[ií]os?\s+para\s+terminar\s+de\s+preparar/i);
+  // 「Enviar productos」入口：只在**页面确实渲染了列表**时才敢说"按钮不存在"
+  //   （没渲染完 = null，不是 false —— 否则选择器一漂移本闸门就恒 unavailable）
+  var rendered = document.querySelectorAll('table.andes-table tbody tr').length > 0;
+  var enviar = null, enviar_disabled = null, enviar_rect = null;
+  var btns = document.querySelectorAll('a.andes-button, button.andes-button, a, button');
+  for (var i = 0; i < btns.length; i++) {
+    var b = btns[i];
+    if (norm(b.textContent || '') !== 'Enviar productos') continue;
+    enviar = true;
+    // 禁用态（三种写法都认：原生 disabled / aria-disabled / andes 的修饰类）
+    enviar_disabled = !!(b.disabled === true
+      || (b.getAttribute && b.getAttribute('aria-disabled') === 'true')
+      || /andes-button--disabled|andes-button--inactive|is-disabled/.test(String(b.className || '')));
+    var br = b.getBoundingClientRect ? b.getBoundingClientRect() : null;
+    if (br) {
+      enviar_rect = {x: Math.round(br.left), y: Math.round(br.top),
+                     w: Math.round(br.width), h: Math.round(br.height)};
+    }
+    break;
+  }
+  if (enviar === null && rendered) { enviar = false; }
+  // ── 命中平台原文的**元素**结构证据（2026-10-12：判据收紧为"阻断形态"的唯一依据）──────
+  // 为什么必须有它：旧判据是「整页 innerText 前 6000 字**包含**该短语 或 任一 .andes-card 含它」
+  //   ⇒ 页面下方**说明/帮助卡**里的同一句话会把**能跑的票**判成"仓容满"（生产实测误报：
+  //     同一票手动重跑 8/8 成功）。所以本 JS 逐元素测量「可见 / 在视口内 / 在模态或 alert
+  //     容器内 / 在说明卡内」，外加主按钮几何与禁用态 —— **只看证据，不下结论**。
+  var FRAGS = ['liberar espacio de almacenamiento', 'retirar stock de baja calidad',
+               'retirando stock de baja calidad', 'liberar espacio'];
+  var hits = [], total = 0, scanned = 0, scan_truncated = false;
+  var all = document.querySelectorAll('body *');
+  for (var k = 0; k < all.length; k++) {
+    if (scanned++ > 8000) { scan_truncated = true; break; }   // 扫描上界（防超大页面拖慢只读探针）
+    var el = all[k];
+    var own = norm(el.textContent || '').toLowerCase();
+    if (!own) continue;
+    var frag = '';
+    for (var f = 0; f < FRAGS.length; f++) {
+      if (own.indexOf(FRAGS[f]) >= 0) { frag = FRAGS[f]; break; }
+    }
+    if (!frag) continue;
+    // 只记「最内层」命中：子元素也含同句时父元素不再单列（否则一个卡片就把 8 条名额刷满）
+    var inner = false;
+    for (var c = 0; c < el.children.length; c++) {
+      if (norm(el.children[c].textContent || '').toLowerCase().indexOf(frag) >= 0) { inner = true; break; }
+    }
+    if (inner) continue;
+    total++;
+    if (hits.length >= 8) continue;                          // 结构证据截断（⛔ 不是整页 dump）
+    var cs = window.getComputedStyle ? window.getComputedStyle(el) : null;
+    var r = el.getBoundingClientRect ? el.getBoundingClientRect() : null;
+    var modal = el.closest ? el.closest('.andes-modal, .andes-dialog, [role="dialog"], [role="alertdialog"]') : null;
+    var alertBox = el.closest ? el.closest('.andes-alert, .andes-banner, .andes-message, .andes-notification, [role="alert"]') : null;
+    var card = el.closest ? el.closest('.andes-card') : null;
+    hits.push({
+      frag: frag,
+      tag: String(el.tagName || '').toLowerCase(),
+      cls: String((typeof el.className === 'string' ? el.className : '') || '').slice(0, 120),
+      role: String((el.getAttribute && el.getAttribute('role')) || '').slice(0, 40),
+      display: cs ? String(cs.display || '') : '',
+      visibility: cs ? String(cs.visibility || '') : '',
+      opacity: cs ? String(cs.opacity || '') : '',
+      rect: r ? {x: Math.round(r.left), y: Math.round(r.top),
+                 w: Math.round(r.width), h: Math.round(r.height)} : null,
+      in_modal: !!modal, in_alert: !!alertBox, in_card: !!card,
+      chars: (el.textContent || '').length
+    });
+  }
+  // 既有探针的同一判据（`.andes-card` 含 liberar espacio）—— **只作冗余证据**保留：
+  //   ⛔ 它单独**不再**能判"仓容满"（说明卡正是旧判据误报的来源，见 capacity_verdict 判据表）。
+  var warning = null;
+  var cards = document.querySelectorAll('.andes-card');
+  for (var j = 0; j < cards.length; j++) {
+    if (norm(cards[j].textContent || '').toLowerCase().indexOf('liberar espacio') >= 0) {
+      warning = 'capacity_warning'; break;
+    }
+  }
+  return JSON.stringify({
+    page: 'inbounds-list',
+    ok: true,
+    url: String(location.href || ''),
+    text: text,
+    rendered: rendered,
+    enviar_present: enviar,
+    enviar_disabled: enviar_disabled,
+    enviar_rect: enviar_rect,
+    prepared_count: m ? parseInt(m[1], 10) : null,
+    prepared_banner: !!m,
+    capacity_warning: warning,
+    quote_hits: hits,
+    quote_hit_total: total,
+    scan_truncated: scan_truncated,
+    viewport: {w: (window.innerWidth || 0), h: (window.innerHeight || 0)}
+  });
+})();"""
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# 四、纯判据
+# ══════════════════════════════════════════════════════════════════════════
+
+def _norm_rect(raw: Any) -> Optional[dict]:
+    """几何证据归一（`{x,y,w,h}` 全为有限数才认；缺一项 ⇒ `None`）。**从不抛异常**。"""
+    if not isinstance(raw, dict):
+        return None
+    out: dict[str, float] = {}
+    for k in ("x", "y", "w", "h"):
+        try:
+            out[k] = float(raw.get(k))
+        except (TypeError, ValueError):
+            return None
+    return out
+
+
+def _norm_wh(raw: Any) -> Optional[dict]:
+    """**视口**几何归一（`{w,h}`；非正数或缺项 ⇒ `None` = 不知道）。**从不抛异常**。"""
+    if not isinstance(raw, dict):
+        return None
+    try:
+        w, h = float(raw.get("w")), float(raw.get("h"))
+    except (TypeError, ValueError):
+        return None
+    return {"w": w, "h": h} if w > 0 and h > 0 else None
+
+
+def _norm_hit(raw: Any) -> dict:
+    """归一一个**命中元素**的结构证据，并只做**测量学**推导（可见 / 在视口内 / 紧邻主按钮）。
+
+    ⛔ 这里**不**下"是否阻断"的结论 —— 那是 `blocking_form()` 的唯一职责（判据只有一处）。
+    `rect` 全零 ⇒ `visible=False`：这条同时覆盖了"祖先 `display:none`"（那种元素
+    `getBoundingClientRect()` 全零、自身 computed display 却仍是 `block`，只查自身样式会**误判可见**）。
+    """
+    d = raw if isinstance(raw, dict) else {}
+    rect = _norm_rect(d.get("rect"))
+    disp = str(d.get("display") or "").strip().lower()
+    vis = str(d.get("visibility") or "").strip().lower()
+    try:
+        op: Optional[float] = float(d.get("opacity"))
+    except (TypeError, ValueError):
+        op = None
+    visible = bool(rect and rect["w"] > 0 and rect["h"] > 0
+                   and disp != "none" and vis not in ("hidden", "collapse")
+                   and (op is None or op > 0))
+    return {
+        "frag": str(d.get("frag") or "")[:60],
+        "tag": str(d.get("tag") or "")[:24],
+        "cls": str(d.get("cls") or "")[:120],
+        "role": str(d.get("role") or "")[:40],
+        "rect": rect,
+        "display": disp,
+        "visibility": vis,
+        "opacity": op,
+        "visible": visible,
+        "in_modal": bool(d.get("in_modal")),
+        "in_alert": bool(d.get("in_alert")),
+        "in_card": bool(d.get("in_card")),
+        "chars": d.get("chars"),
+    }
+
+
+def _norm_source(src: Any) -> dict:
+    """把任意来源（dict / JSON 字符串 / None）归一成判据要的形状。**从不抛异常**。"""
+    if isinstance(src, str):
+        try:
+            src = json.loads(src)
+        except (ValueError, TypeError):
+            src = {}
+    if not isinstance(src, dict):
+        src = {}
+    page = str(src.get("page") or src.get("url") or "?")[:80]
+    text = src.get("text")
+    text = "" if text is None else str(text)
+    err = src.get("error_page") or ""
+    if not err:
+        low = text.lower()
+        for mk in ERROR_PAGE_MARKERS:
+            if mk in low:
+                err = mk
+                break
+    hits_raw = src.get("quote_hits")
+    if not isinstance(hits_raw, (list, tuple)):
+        hits_raw = []
+    hits = [_norm_hit(h) for h in hits_raw[:MAX_HITS]]
+    try:
+        total = int(src.get("quote_hit_total"))
+    except (TypeError, ValueError):
+        total = len(hits)
+    vp = _norm_wh(src.get("viewport"))
+    out = {
+        "page": page,
+        "ok": bool(src.get("ok")),
+        "url": str(src.get("url") or "")[:300],
+        "text": text,
+        "rendered": src.get("rendered"),
+        "error_page": str(err)[:120],
+        "enviar_present": src.get("enviar_present"),
+        "enviar_disabled": src.get("enviar_disabled"),
+        "enviar_rect": _norm_rect(src.get("enviar_rect")),
+        "prepared_count": src.get("prepared_count"),
+        "prepared_banner": bool(src.get("prepared_banner")),
+        "capacity_warning": bool(src.get("capacity_warning")),
+        "hits": hits,
+        "hits_total": max(total, len(hits)),
+        "hits_truncated": max(total, len(hits)) > len(hits),
+        "viewport": vp,
+        "scan_truncated": bool(src.get("scan_truncated")),
+        "note": str(src.get("note") or "")[:160],
+        # 下面三个由 `_annotate_source()` 填（判定用的推导值；先占位，保证键恒在）
+        "primary_gone": False,
+        "blocking": False,
+        "block_reason": "",
+    }
+    _annotate_source(out)
+    return out
+
+
+def _annotate_source(src: dict) -> None:
+    """就地补**判定用的测量学推导**（可见/视口/紧邻主按钮/参与阻断）。⛔ 不下结论。"""
+    vp = src.get("viewport")
+    btn = src.get("enviar_rect")
+    # 按钮"缺失/禁用"只在**列表已渲染**时才作数（没渲染完 = 不知道，不是负信号）
+    src["primary_gone"] = bool(src.get("rendered")) and (
+        src.get("enviar_present") is False or src.get("enviar_disabled") is True)
+    for h in src.get("hits") or []:
+        r = h.get("rect")
+        h["in_viewport"] = bool(r and vp and r["y"] < vp["h"] and (r["y"] + r["h"]) > 0)
+        h["below_fold"] = bool(r and vp and r["y"] >= vp["h"])
+        ab = False
+        if r and btn:
+            overlap = (r["x"] < btn["x"] + btn["w"] + PRIMARY_OVERLAP_TOL_PX
+                       and r["x"] + r["w"] > btn["x"] - PRIMARY_OVERLAP_TOL_PX)
+            gap = btn["y"] - (r["y"] + r["h"])          # 命中元素底边 → 主按钮顶边
+            ab = bool(overlap and (-PRIMARY_OVERLAP_TOL_PX <= gap <= PRIMARY_ADJACENT_GAP_PX))
+        h["above_primary"] = ab
+        # 「参与阻断的位置」：可见 ∧ 在视口内（不被折叠到页面底部）∧ **不是说明/帮助卡**
+        #   （modal / alert 容器例外 —— 它们本来就是阻断形态的载体）
+        h["participates"] = bool(h["visible"] and h["in_viewport"]
+                                 and (h["in_modal"] or h["in_alert"] or not h["in_card"]))
+        h["blocks"] = False                              # 由 blocking_form() 落值（留痕用）
+        h["shape"] = ""
+
+
+def primary_state(src: dict) -> str:
+    """「`Enviar productos`」按钮状态的可读措辞（进证据串；⛔ 不参与判定）。"""
+    if not src.get("rendered"):
+        return _PRIMARY_UNRENDERED
+    if src.get("enviar_present") is False:
+        return _PRIMARY_ABSENT
+    if src.get("enviar_disabled") is True:
+        return _PRIMARY_DISABLED
+    if src.get("enviar_present") is True:
+        return _PRIMARY_OK
+    return _PRIMARY_UNKNOWN
+
+
+def hit_desc(h: dict) -> str:
+    """一个命中元素的**一行可读描述**（标签/几何/可见性/位置）—— 进证据串，⛔ 不塞整页文本。"""
+    r = h.get("rect") or {}
+    pos = (f"@({int(r.get('x', 0))},{int(r.get('y', 0))} {int(r.get('w', 0))}x{int(r.get('h', 0))})"
+           if r else "@(无几何)")
+    first_cls = (str(h.get("cls") or "").split() or [""])[0]
+    where = [k for k, on in (("modal", h.get("in_modal")), ("alert", h.get("in_alert")),
+                             ("card", h.get("in_card"))) if on]
+    return (f"<{h.get('tag') or '?'}{('.' + first_cls) if first_cls else ''}>"
+            f"{pos} 可见={'是' if h.get('visible') else '否'}"
+            f" 视口内={'是' if h.get('in_viewport') else '否'}"
+            f" 位置={'/'.join(where) or '页面正文'}")
+
+
+def blocking_form(src: dict) -> tuple[bool, str, str]:
+    """**严格阻断形态**判定（纯函数，输入 = `_norm_source()` 归一后的**单来源**）。
+
+    返回 `(是否阻断, 理由串, 形态名)`。三条硬闸门（缺一不可，见模块 docstring）：
+
+    1. **位置**（S1 模态内 / S2 alert 紧邻主按钮上方 / S3 主按钮缺失或禁用）；
+    2. **可见**（非零 rect ∧ 非 `display:none` ∧ 非 `visibility:hidden` ∧ `opacity>0`）；
+    3. **参与阻断**（在视口内、不在说明/帮助卡内、有几何证据）。
+
+    ⛔ **结构证据不足**（旧探针形态没有 `quote_hits` / 没有 viewport）**一律不阻断** ——
+    这正是 2026-10-12 误报的根治点：「文本里出现那串字」**永远**不足以判仓容满。
+    """
+    if not src.get("ok"):
+        return False, "来源不可用（页面未取到）", ""
+    if not src.get("hits"):
+        why = ("命中平台原文片段，但**没有任何命中元素的结构证据**"
+               "（旧探针 / 说明卡片 / 命中在文本截断之外）⇒ 无法区分「平台拒绝」与「说明文案」")
+        if src.get("capacity_warning") or quote_hit(src.get("text") or ""):
+            return False, why, ""
+        return False, "页面未命中任何平台原文片段", ""
+    if not src.get("viewport"):
+        return False, "命中元素有结构证据但**缺视口几何**（无法判「是否折叠在页面底部」）⇒ 不硬判", ""
+    for h in src.get("hits") or []:
+        if not h.get("participates"):
+            continue
+        if h.get("in_modal"):
+            h["blocks"], h["shape"] = True, SHAPE_MODAL
+            return True, SHAPE_MODAL, SHAPE_MODAL
+        if h.get("in_alert") and h.get("above_primary"):
+            h["blocks"], h["shape"] = True, SHAPE_ALERT
+            return True, SHAPE_ALERT, SHAPE_ALERT
+        if src.get("primary_gone"):
+            h["blocks"], h["shape"] = True, SHAPE_CTA
+            return True, SHAPE_CTA, SHAPE_CTA
+    return False, _why_not_blocking(src), ""
+
+
+def _why_not_blocking(src: dict) -> str:
+    """「命中了原文但**不构成阻断**」的可读理由（逐条覆盖三类否定原因 + 按钮状态）。"""
+    hits = src.get("hits") or []
+    invisible = sum(1 for h in hits if not h.get("visible"))
+    below = sum(1 for h in hits if h.get("visible") and not h.get("in_viewport"))
+    cards = sum(1 for h in hits if h.get("participates") is False and h.get("in_card")
+                and not h.get("in_alert") and not h.get("in_modal"))
+    why = (f"命中元素 {len(hits)} 个，但**均不在阻断位置**"
+           f"（不可见 {invisible} 个 / 折叠在页面底部或视口外 {below} 个 / "
+           f"位于说明·帮助卡内 {cards} 个）")
+    if src.get("rendered") and src.get("enviar_present") is True \
+            and src.get("enviar_disabled") is not True:
+        why += "，且「Enviar productos」按钮**在且可点**（平台并未阻止进入发货流程）"
+    return why
+
+
+def _sources_of(ev: Any) -> list:
+    """取来源清单：支持 `{"sources":[…]}` 与**单来源扁平形**（夹具友好）。"""
+    if not isinstance(ev, dict):
+        return []
+    raw = ev.get("sources")
+    if raw is None:
+        return [_norm_source(ev)] if ev else []
+    if isinstance(raw, dict):
+        raw = [raw]
+    if not isinstance(raw, (list, tuple)):
+        return []
+    return [_norm_source(s) for s in raw]
+
+
+def quote_hit(text: str) -> str:
+    """返回文本里命中的**平台原文片段**（最长的那个，便于逐字回引）；没命中返回空串。"""
+    low = str(text or "").lower()
+    hits = [q for q in PLATFORM_QUOTES if q in low]
+    if not hits:
+        return ""
+    return max(hits, key=len)
+
+
+def extract_quote(text: str) -> str:
+    """从页面文本里切出**平台原文整句**（给运营看的话，越完整越好）。
+
+    ⛔ 只做「按句子边界切一段含命中的原文」，**不做翻译/改写**（解读正是历史事故的根因）。
+    切不到就回落到命中的片段本身。
+    """
+    s = re.sub(r"\s+", " ", str(text or "")).strip()
+    if not s:
+        return ""
+    low = s.lower()
+    pos, frag = -1, ""
+    for q in PLATFORM_QUOTES:
+        i = low.find(q)
+        if i >= 0 and (pos < 0 or i < pos):
+            pos, frag = i, q
+    if pos < 0:
+        return ""
+    # 往左找到句首（`.!?` / 列表分隔符 `｜` / 串首，最多回看 160 字符）
+    start = 0
+    for i in range(pos - 1, max(-1, pos - 160), -1):
+        if s[i] in ".!?｜|":
+            start = i + 1
+            break
+    # 平台那句话自带引导语（`Para enviar productos, primero deberás …`）⇒ 有就更准地切
+    # （取**最早**那条引导语：`Para enviar productos` 在 `primero deberás` 之前，取最早才不会丢头）
+    leads = [low.rfind(lead, max(0, pos - 160), pos) for lead in QUOTE_LEADINS]
+    leads = [j for j in leads if j >= 0]
+    if leads:
+        start = max(start, min(leads))
+    # 往右找到句末（最多前看 260 字符）
+    m = re.search(r"[.!?]", s[pos + len(frag):pos + len(frag) + 260])
+    end = (pos + len(frag) + m.end()) if m else min(len(s), pos + len(frag) + 160)
+    out = s[start:end].strip(" ｜|,;")
+    return out or frag
+
+
+def capacity_verdict(ev: Any = None) -> dict:
+    """由**只读页面证据**判定仓容三态 —— 失败文案的唯一措辞来源。
+
+    证据（`ev`）形状（也接受 `{"sources": [ … ]}` 多来源）：
+
+        `page` / `ok` / `text` / `rendered` / `error_page`
+        `enviar_present`（True/False/None） / `enviar_disabled` / `enviar_rect`
+        `prepared_count` / `prepared_banner` / `capacity_warning`（既有步骤1探针的同一判据）
+        `quote_hits`（**命中元素的结构证据**：可见性/视口/模态·alert·说明卡/几何）
+        `viewport`（`{w,h}`，视口坐标；用来判"是否折叠在页面底部"）
+
+    返回 `{code, conclusion, evidence, text, action, quote, corroborated, prepared_count,
+           hit, where, blocking, block_shape, block_reason, sources}`；
+    `text` = 可直接写进失败文案的整句（只有 `capacity_full` 才有动作段）。
+
+    判据（**顺序即优先级**，逐条见模块 docstring 的判据表）：
+    残缺 ⇒ 原文∧**阻断形态** ⇒ 原文但非阻断(⇒unavailable) ⇒ 错误页 ⇒ 可读 ⇒ 其余。
+    """
+    sources = _sources_of(ev)
+    ok_sources = [s for s in sources if s["ok"]]
+
+    # ── ⓪ 残缺闸门：一条可用来源都没有 ⇒ 证据不足（⛔ 既不是满、也不是正常）──────
+    if not ok_sources:
+        why = "；".join(
+            f"{s['page']}=" + (s["note"] or "未取到") for s in sources) or "没有任何来源"
+        return _verdict(VERDICT_UNAVAILABLE,
+                        "仓容前置探测**不可用**（页面取不到/超时）⇒ 证据不足，"
+                        "按保守口径**照常尝试预约**（⛔ 不判仓容满、⛔ 也不判仓容正常）",
+                        f"可用来源=0/{len(sources) or 0}｜{why}", sources,
+                        note="unavailable")
+
+    # ── ① 平台原文命中 **∧ 严格阻断形态** ⇒ 仓容满（⛔ 见词就判满 = 2026-10-12 误报根因）──
+    # 逐来源先"识别命中"（文本 / 既有 capacity_warning / **命中元素**，三通道任一），
+    # 再问 `blocking_form()`：**只有严格阻断形态**才判满；命中但非阻断 ⇒ 落 ①b（保守降级）。
+    quote, hit_src = "", ""
+    hit_frag, hit_where, hit_text = "", "", ""
+    block_shape, block_reason = "", ""
+    first_hit = ""                      # 第一个命中来源的片段（①b 的判据：**命中**就够，不必阻断）
+    blocked_src: Optional[dict] = None
+    for s in ok_sources:
+        frag = quote_hit(s["text"])
+        if not frag and s["capacity_warning"]:
+            frag = "liberar espacio"        # 既有探针（`.andes-card` 命中）的同一片段
+        if not frag and s["hits"]:
+            frag = s["hits"][0]["frag"] or "liberar espacio"   # 文本被截断但元素命中（新探针更全）
+        if not frag:
+            s["blocking"], s["block_reason"] = False, "未命中平台原文片段"
+            continue
+        ok_block, why, shape = blocking_form(s)
+        s["blocking"], s["block_reason"] = ok_block, why
+        if not first_hit:                   # 第一个命中来源：留痕基线（文本/元素/位置/按钮状态）
+            first_hit = frag
+            hit_src, hit_frag, hit_text = s["page"], frag, s["text"]
+            hit_where = "；".join(hit_desc(h) for h in (s["hits"] or [])[:3]) or "（无元素几何证据）"
+            block_reason = why
+        if ok_block:                        # 严格阻断形态：改引**阻断来源**的原文（逐字回引）
+            blocked_src, block_shape = s, shape
+            quote = extract_quote(s["text"]) or frag
+            hit_src, hit_frag, hit_text = s["page"], frag, s["text"]
+            hit_where = "；".join(hit_desc(h) for h in (s["hits"] or [])[:3]) or "（无元素几何证据）"
+            block_reason = why
+            break
+    if blocked_src is not None:
+        prepared = next((s["prepared_count"] for s in ok_sources
+                         if s["prepared_count"] is not None), None)
+        banner = any(s["prepared_banner"] for s in ok_sources)
+        ev_line = (f"页面={hit_src}｜平台原文命中={hit_frag or quote_hit(quote) or 'liberar espacio'}"
+                   f"｜**阻断形态成立**={block_shape}"
+                   + (f"（{block_reason}）" if block_reason and block_reason != block_shape else "")
+                   + f"｜命中元素：{hit_where}"
+                   f"｜「{ENVIAR_LABEL}」={primary_state(blocked_src)}"
+                   + (f"｜佐证：{prepared} Envíos para terminar de preparar"
+                      if banner else "｜佐证：未出现「N Envíos para terminar de preparar」")
+                   + ("｜既有探针 capacity_warning=命中"
+                      if any(s["capacity_warning"] for s in ok_sources) else ""))
+        return _verdict(VERDICT_FULL,
+                        f"{CAPACITY_TERM}满：平台**已明确拒绝**继续发货（{CAPACITY_TERM}已满）"
+                        f"⇒ **不进入步骤4**（再试也只会撞同一面墙）",
+                        ev_line, sources, quote=quote,
+                        corroborated=banner, prepared_count=prepared, note="platform-quote",
+                        hit=hit_frag, where=hit_where, blocking=True,
+                        block_shape=block_shape, block_reason=block_reason)
+
+    # ── ①b 命中平台原文但**不是**阻断形态 ⇒ 保守降级（**照常尝试步骤4**）────────────
+    # 2026-10-12 现场：命中来自页面别处的说明/帮助卡，平台**并没有**拒绝发货
+    #   ⇒ ⛔ 不判满；也⛔ 不判"正常"（命中原文就不敢说库容正常、不提前解除 defer 护栏）。
+    if first_hit:
+        prepared = next((s["prepared_count"] for s in ok_sources
+                         if s["prepared_count"] is not None), None)
+        banner = any(s["prepared_banner"] for s in ok_sources)
+        _hit_src = next((s for s in ok_sources if s["block_reason"] != "未命中平台原文片段"), {})
+        ev_line = (f"页面={hit_src}｜命中平台原文={hit_frag}"
+                   f"｜**阻断形态=未成立**（{block_reason}）"
+                   f"｜命中元素：{hit_where}"
+                   f"｜命中上下文=（{_excerpt(hit_text, hit_frag)}）"
+                   f"｜「{ENVIAR_LABEL}」={primary_state(_hit_src)}"
+                   f"｜命中总数={sum(s['hits_total'] for s in ok_sources)}"
+                   + (f"｜佐证：{prepared} Envíos para terminar de preparar" if banner else ""))
+        return _verdict(VERDICT_UNAVAILABLE,
+                        f"{CAPACITY_TERM}前置探测**不可用**：页面命中平台{CAPACITY_TERM}原文，但"
+                        f"**不是阻断形态**（说明卡/折叠在页面底部/结构证据不足）"
+                        f"⇒ 证据不足，按保守口径**照常尝试预约**（⛔ 不判{CAPACITY_TERM}满）",
+                        ev_line, sources, quote="",
+                        corroborated=banner, prepared_count=prepared,
+                        note=JUDGE_QUOTE_NOT_BLOCKING,
+                        hit=hit_frag, where=hit_where, blocking=False,
+                        block_shape="", block_reason=block_reason)
+
+    # ── ② 平台错误页 ⇒ 读不出仓容真相（保守）────────────────────────────────
+    healthy = [s for s in ok_sources if not s["error_page"] and s["text"].strip()]
+    if not healthy:
+        errs = "；".join(f"{s['page']}=" + (s["error_page"] or "页面文本为空")
+                         for s in ok_sources)
+        return _verdict(VERDICT_UNAVAILABLE,
+                        "仓容前置探测**不可用**（平台错误页/页面未渲染）⇒ 证据不足，"
+                        "按保守口径**照常尝试预约**（⛔ 不判仓容满、⛔ 也不判仓容正常）",
+                        f"可用来源={len(ok_sources)} 但均不可判定｜{errs}", sources,
+                        note="error-page-or-empty")
+
+    # ── ③ 可读且无原文 ⇒ 仓容可用（唯一能让"仓容类 defer"当日解除的证据）──────
+    blocked = [s for s in healthy if s["enviar_present"] is False]
+    if len(blocked) == len(healthy):
+        return _verdict(VERDICT_UNAVAILABLE,
+                        "仓容前置探测**不可用**：页面可读但"
+                        f"「{ENVIAR_LABEL}」入口**明确不存在**（`selectors.md` 记库容满时该按钮"
+                        "不显示 ⇒ 无法据此判「仓容正常」）⇒ 证据不足，照常尝试预约",
+                        f"可读来源={len(healthy)}｜「{ENVIAR_LABEL}」均不存在", sources,
+                        note="enviar-absent")
+    best = next((s for s in healthy if s["enviar_present"] is True), healthy[0])
+    prepared = next((s["prepared_count"] for s in healthy
+                     if s["prepared_count"] is not None), None)
+    banner = any(s["prepared_banner"] for s in healthy)
+    ev_line = (f"页面={best['page']} 可读且形态正常｜平台仓容原文命中=0"
+               f"｜「{ENVIAR_LABEL}」入口="
+               + ("在" if best["enviar_present"] is True else "未确认（不构成负信号）")
+               + (f"｜佐证：{prepared} Envíos para terminar de preparar"
+                  if banner else ""))
+    return _verdict(VERDICT_AVAILABLE,
+                    f"{CAPACITY_TERM}前置探测：**{CAPACITY_TERM}可用**（页面可读、无平台{CAPACITY_TERM}原文）"
+                    f"⇒ 允许进入步骤4；若本票有活跃的{DEFER_TAG}类 defer 标记 ⇒ **当日解除**",
+                    ev_line, sources,
+                    corroborated=banner, prepared_count=prepared, note="no-quote")
+
+
+def _excerpt(text: str, frag: str, width: int = 60) -> str:
+    """命中片段周围的**短上下文**（≤ ~140 字符）—— 给事后判误报用，⛔ 绝不回整页文本。"""
+    s = re.sub(r"\s+", " ", str(text or "")).strip()
+    if not s or not frag:
+        return ""
+    i = s.lower().find(str(frag).lower())
+    if i < 0:
+        return s[:width]
+    return s[max(0, i - width):i + len(frag) + width][:140]
+
+
+def _verdict(code: str, conclusion: str, evidence: str, sources: list, *,
+             quote: str = "", corroborated: bool = False,
+             prepared_count: Optional[int] = None, note: str = "",
+             hit: str = "", where: str = "", blocking: bool = False,
+             block_shape: str = "", block_reason: str = "") -> dict:
+    """装配结论（**唯一**出口，保证每个结论都带计数与证据来源）。
+
+    `hit`/`where`/`blocking`/`block_shape`/`block_reason` = **误报事后判定**要的留痕
+    （命中文本 / 命中元素位置与可见性 / 阻断横幅有无 / 主按钮状态在 `evidence` 里），
+    ⛔ 都**不含整页文本**（`quote` 只放平台原文整句，且**只有 `capacity_full` 才有**）。
+    """
+    assert code in VERDICTS, f"未知裁决码 {code}"
+    diag = f"{conclusion}｜证据：{evidence}"
+    if quote:
+        diag += f"｜平台原文：{quote}"
+    return {
+        "code": code,
+        "conclusion": conclusion,
+        "evidence": evidence,
+        "brief": _brief(conclusion),
+        # `text`：仓容满 ⇒ 可**直接**写进表备注/台账/卡片的**唯一**失败文案（`capacity_failure_text` 产出）；
+        # 其余两态 ⇒ 只是诊断串（⛔ 不写表 —— 它们不是失败）。
+        "text": (capacity_failure_text({"conclusion": conclusion, "evidence": evidence,
+                                        "quote": quote, "code": code})
+                 if code == VERDICT_FULL else diag),
+        "action": ACTION_TEXT if code == VERDICT_FULL else "",
+        "quote": quote,
+        "corroborated": bool(corroborated),
+        "prepared_count": prepared_count,
+        "judge": note,
+        # ── 阻断形态留痕（2026-10-12）──────────────────────────────────────────
+        # ⛔ 恒存在（哪怕为空串）：调用方/报表不用"键在不在"来猜结论是怎么来的。
+        "hit": hit,                       # 命中的平台原文片段（⛔ 不是整页文本）
+        "where": where,                   # 命中元素的位置/可见性摘要
+        "blocking": bool(blocking),       # 是否**严格阻断形态**（只有它为真才可能 full）
+        "block_shape": block_shape,       # S1/S2/S3
+        "block_reason": block_reason,
+        "sources": [{"page": s["page"], "ok": s["ok"], "rendered": s["rendered"],
+                     "error_page": s["error_page"], "enviar_present": s["enviar_present"],
+                     "enviar_disabled": s["enviar_disabled"],
+                     "primary_gone": bool(s.get("primary_gone")),
+                     "prepared_count": s["prepared_count"],
+                     "quote_hit": quote_hit(s["text"]) or ("liberar espacio" if s["capacity_warning"] else ""),
+                     "capacity_warning": s["capacity_warning"],
+                     "blocking": bool(s.get("blocking")),
+                     "block_reason": str(s.get("block_reason") or "")[:200],
+                     "hits_total": s.get("hits_total"),
+                     "hits": [{"frag": h.get("frag"), "tag": h.get("tag"), "cls": h.get("cls")[:60],
+                               "role": h.get("role"), "rect": h.get("rect"),
+                               "visible": h.get("visible"), "in_viewport": h.get("in_viewport"),
+                               "below_fold": h.get("below_fold"),
+                               "in_modal": h.get("in_modal"), "in_alert": h.get("in_alert"),
+                               "in_card": h.get("in_card"),
+                               "above_primary": h.get("above_primary"),
+                               "participates": h.get("participates"),
+                               "blocks": h.get("blocks"), "shape": h.get("shape"),
+                               "chars": h.get("chars")} for h in (s.get("hits") or [])],
+                     "viewport": s.get("viewport"),
+                     "chars": len(s["text"]), "note": s["note"]} for s in sources],
+    }
+
+
+def _brief(conclusion: str) -> str:
+    """一句话摘要（卡片/日志用）——取结论里第一段（`｜`/`⇒` 之前）。"""
+    return re.split(r"[｜|⇒]", str(conclusion or ""))[0].strip()[:120]
+
+
+def capacity_failure_text(verdict: Optional[dict] = None, extra: str = "") -> str:
+    """把判定结果拼成**唯一**的失败文案（表备注 / 台账 / 卡片共用同一串）。
+
+    形状：`步骤4仓容前置探测：<结论>｜证据：<证据>｜唯一动作：<动作>`（仓容满时才有动作段）。
+    **必须**含平台原文（`quote` 逐字）与唯一动作（`ACTION_TEXT`）—— 两条都有回归钉住。
+    """
+    v = verdict or {}
+    body = (f"步骤4仓容前置探测：{v.get('conclusion') or DEFER_TAG}"
+            f"｜证据：{v.get('evidence') or '（无）'}")
+    q = str(v.get("quote") or "").strip()
+    if q:
+        body += f"｜平台原文：{q}"
+    if v.get("code") == VERDICT_FULL:
+        # 机器可识别标记：三处证据（表备注 / 台账 `failed.reason` / 卡片 reason）都能被
+        # 程序分类（`analyze-full-day.py` 的桶与 `failureClasses.capacityFull` 都认它）。
+        body += f"｜分类：{CLASS_MARKER}｜唯一动作：{ACTION_TEXT}"
+    tail = str(extra or "").strip("｜ ")
+    return f"{body}｜{tail}" if tail else body
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# 四·五、运维开关（**纯函数**；2026-10-12 现场"疑似误报"）
+# ══════════════════════════════════════════════════════════════════════════
+
+#: 环境变量名（唯一字面量；orchestrator 从这里 import，⛔ 不写第二份）
+PRECHECK_SWITCH_ENV = "ARGENT_CAPACITY_PRECHECK"
+
+#: 显式关闭的取值（大小写/空白不敏感）；⛔ 其余值（含空/未设）一律**不关**
+_SWITCH_OFF_VALUES = ("0", "off", "false", "no")
+
+
+def precheck_switch_off(raw: Any = None) -> bool:
+    """运维开关是否**显式关闭**拦截（纯函数，判据唯一、可离线回归）。
+
+    ⚠️ 只认 `0/off/false/no`；`""`/未设/其它值 ⇒ `False`（**默认仍拦**，⛔ 不因笔误放行）。
+    """
+    return str(raw if raw is not None else "").strip().lower() in _SWITCH_OFF_VALUES
+
+
+def apply_precheck_switch(verdict: Optional[dict], raw: Any = None) -> dict:
+    """按运维开关**降级**结论 —— 仅当 `code == capacity_full` ∧ 开关显式关 ⇒ 改判 `unavailable`。
+
+    语义（重要，⛔ 别误读为"放行"）：`unavailable` 是本模块既有的**保守路径** ——
+    「证据不足 ⇒ 照常尝试步骤4」，即**把拦截权交回步骤4 自身**（平台若真满，步骤4 仍会失败，
+    并留下截图/失败文案）。原判证据**一个字都不丢**，落在 `bypassed` 字段（含 code/evidence/
+    quote/action/佐证计数），调用方照常打印。
+
+    · `available` / `unavailable` ⇒ **原样返回**（幂等，开关对它们无意义）；
+    · 开关未设/非关闭值 ⇒ **原样返回**（默认行为不变，回归钉住）；
+    · `verdict` 为空/非 dict ⇒ 返回 `{}`（⛔ 不上抛）。
+    """
+    v = dict(verdict) if isinstance(verdict, dict) else {}
+    if not v or v.get("code") != VERDICT_FULL or not precheck_switch_off(raw):
+        return v
+    v["bypassed"] = {
+        "by": PRECHECK_SWITCH_ENV,
+        "from_code": v.get("code"),
+        "evidence": v.get("evidence") or "",
+        "quote": v.get("quote") or "",
+        "action": v.get("action") or "",
+        "prepared_count": v.get("prepared_count"),
+    }
+    v["code"] = VERDICT_UNAVAILABLE
+    v["conclusion"] = (f"仓容前置探测原判 {VERDICT_FULL}，但**运维开关 {PRECHECK_SWITCH_ENV}=off 已关闭拦截**"
+                       f"⇒ 按「证据不足」保守路径**照常尝试步骤4**（原判证据见 bypassed）")
+    v["text"] = (f"{v['conclusion']}｜原判证据：{v['bypassed']['evidence'] or '（无）'}"
+                 + (f"｜原判平台原文：{v['bypassed']['quote']}" if v["bypassed"]["quote"] else ""))
+    return v
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# 五、defer 解除（**纯函数**；⛔ 只对仓容这一条链开放）
+# ══════════════════════════════════════════════════════════════════════════
+
+def defer_lift_decision(verdict: Optional[dict] = None, *,
+                        prior_kind: str = "", prior_marks: int = 0,
+                        max_lift: int = DEFER_MAX_LIFT) -> dict:
+    """判定本票的**仓容类 defer** 是否可在**当日**解除 —— 判据唯一、可离线回归。
+
+    ⇔ `lift=True` 的**全部**条件（缺一不可）：
+
+    1. 本次预检结论 = `capacity_available`（**有证据**说仓容可用）；
+    2. 本票**确实**有活跃的仓容类 defer 标记（`prior_kind == DEFER_KIND`）；
+    3. 已解除次数 `prior_marks < max_lift`（**上限**，防打转）。
+
+    ⛔ 明确**不**解除的两种情形（回归钉住）：
+      · 预检 `capacity_full` ⇒ 继续 defer（本来就不该试）；
+      · 预检 `unavailable` ⇒ **保守不解除** —— 注意这与"步骤4 照常尝试"看似矛盾，其实分属两件事：
+        「要不要进步骤4」在无证据时按**业务保守**（照常试，免得探测故障拦住能成的票）；
+        「要不要提前解除护栏」在无证据时按**防打转保守**（不解除，免得无证据地当日反复撞墙）。
+        两者都在 `docs/本机接班运行清单.md` §8.72 写明。
+      · `prior_kind` 是 `defer`（时段不可用）⇒ **一律不解除**：那条链**只**走"次日重试"。
+
+    ⛔ 审计写 `failures.jsonl`（`event=defer_lifted`），**不**写统一台账：统一台账的事件类型是
+    分诊的判据（`flow_triage` 的"有效末条事件"规则），新增一个事件类型会让票落到
+    "分诊未归类 ⇒ needs_human"兜底桶 —— 那是**改语义**，不是留审计。
+    """
+    v = verdict or {}
+    code = str(v.get("code") or "")
+    out = {"lift": False, "reason": "", "audit": {}}
+    if code != VERDICT_AVAILABLE:
+        out["reason"] = (f"预检结论={code or '（无）'} ⇒ 不解除"
+                         + ("（仓容仍满）" if code == VERDICT_FULL
+                            else "（证据不足 ⇒ 防打转保守：不解除护栏）" if code == VERDICT_UNAVAILABLE
+                            else ""))
+        return out
+    if prior_kind != DEFER_KIND:
+        out["reason"] = f"本票没有活跃的仓容类 defer 标记（prior_kind={prior_kind or '（无）'}）⇒ 无需解除"
+        return out
+    if prior_marks >= max_lift:
+        out["reason"] = f"已解除 {prior_marks}/{max_lift} 次（达上限）⇒ 转人工，不再当日重试"
+        return out
+    out["lift"] = True
+    out["reason"] = f"仓容预检=可用且解除次数 {prior_marks}/{max_lift} 未达上限 ⇒ 当日解除 defer"
+    out["audit"] = {
+        "by": "orchestrator:capacity-precheck",
+        "basis": code,
+        "evidence": str(v.get("evidence") or "")[:300],
+        "prior_marks": prior_marks,
+        "max_lift": max_lift,
+    }
+    return out
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# 六、夹具（纯离线；⛔ 不含任何真实生产页面原文/账号/店铺名）
+# ══════════════════════════════════════════════════════════════════════════
+_FIXTURE_FULL_TEXT = (
+    "Envios Full ｜ 12 Envíos para terminar de preparar "
+    "Para enviar productos, primero deberás liberar espacio de almacenamiento "
+    "retirando stock de baja calidad. Ver más"
+)
+
+#: 视口几何（夹具统一用 1440×800；「视口内/折叠在页面底部」两个判据都靠它）。
+_FIXTURE_VIEWPORT = {"w": 1440, "h": 800}
+
+#: 主按钮几何（夹具）：在页面右上方，可点。
+_FIXTURE_ENVIAR_RECT = {"x": 1180, "y": 300, "w": 180, "h": 36}
+
+#: 2026-10-12 生产实测页面的**结构**（脱敏：无店铺名/账号/货件号；只保留判据要的那几句）。
+#: 屏幕 OCR 实测：这是**正常的 FULL 管理页** —— 徽标 `84 Envíos para terminar de preparar`、
+#: 提示 `Completa las tareas pendientes para enviar tu stock`、按钮 **`Enviar productos` 在**、
+#: 列表有正常行、**没有**任何"库容满"横幅；而 `liberar espacio …` 出现在页面**下方说明卡**里。
+_FIXTURE_HELP_CARD_TEXT = (
+    "Envios Full ｜ 84 Envíos para terminar de preparar "
+    "Completa las tareas pendientes para enviar tu stock "
+    "Enviar productos ｜ Estado ｜ Acciones "
+    "En preparación 84 ｜ En tránsito 0 ｜ Recibidos 12 "
+    "Si necesitas más espacio, puedes liberar espacio de almacenamiento "
+    "retirando stock de baja calidad."
+)
+
+
+def _hit_help_card(y: int = 980, *, visible: bool = True) -> dict:
+    """「说明/帮助卡里的那句话」这个命中元素（2026-10-12 误报的来源形态）。"""
+    return {
+        "frag": "liberar espacio de almacenamiento", "tag": "p",
+        "cls": "andes-card__body andes-text-secondary", "role": "",
+        "display": "block" if visible else "none",
+        "visibility": "visible", "opacity": "1",
+        "rect": ({"x": 120, "y": y, "w": 1200, "h": 60} if visible
+                 else {"x": 0, "y": 0, "w": 0, "h": 0}),
+        "in_modal": False, "in_alert": False, "in_card": True, "chars": 240,
+    }
+
+
+FIXTURES: dict[str, dict] = {
+    # ① 仓容满（**严格阻断形态 S2**：alert 紧邻主按钮正上方 + 平台原文 + 佐证横幅）⇒ capacity_full
+    "full": {"sources": [{
+        "page": "inbounds-list", "ok": True, "text": _FIXTURE_FULL_TEXT,
+        "rendered": True, "enviar_present": True, "enviar_disabled": False,
+        "enviar_rect": dict(_FIXTURE_ENVIAR_RECT),
+        "prepared_count": 12, "prepared_banner": True, "capacity_warning": "capacity_warning",
+        "viewport": dict(_FIXTURE_VIEWPORT),
+        "quote_hits": [{
+            "frag": "liberar espacio de almacenamiento", "tag": "div",
+            "cls": "andes-alert andes-alert--error andes-alert--banner", "role": "alert",
+            "display": "block", "visibility": "visible", "opacity": "1",
+            # 底边 284，主按钮顶边 300 ⇒ 纵向间距 16px（"紧邻"）；横向与按钮重叠
+            "rect": {"x": 1180, "y": 236, "w": 180, "h": 48},
+            "in_modal": False, "in_alert": True, "in_card": False, "chars": 120,
+        }],
+    }]},
+    # ①b 仓容满（**严格阻断形态 S3**：列表已渲染 ∧ 主按钮缺失 ⇒ 命中元素参与阻断）⇒ capacity_full
+    "cta-gone": {"sources": [{
+        "page": "inbounds-list", "ok": True, "text": _FIXTURE_FULL_TEXT,
+        "rendered": True, "enviar_present": False, "enviar_disabled": None,
+        "enviar_rect": None,
+        "prepared_count": 12, "prepared_banner": True, "capacity_warning": "capacity_warning",
+        "viewport": dict(_FIXTURE_VIEWPORT),
+        "quote_hits": [{
+            "frag": "liberar espacio de almacenamiento", "tag": "p", "cls": "andes-text",
+            "role": "", "display": "block", "visibility": "visible", "opacity": "1",
+            "rect": {"x": 120, "y": 180, "w": 900, "h": 40},
+            "in_modal": False, "in_alert": False, "in_card": False, "chars": 90,
+        }],
+    }]},
+    # ★ 今（2026-10-12）FALSE-POSITIVE 夹具：页面含 `liberar espacio`（说明卡）**但**
+    #   按钮在且可点、**没有**阻断横幅 ⇒ ⛔ 绝不 capacity_full（保守 unavailable ⇒ 照常尝试步骤4）
+    "help-card": {"sources": [{
+        "page": "inbounds-list", "ok": True, "text": _FIXTURE_HELP_CARD_TEXT,
+        "rendered": True, "enviar_present": True, "enviar_disabled": False,
+        "enviar_rect": dict(_FIXTURE_ENVIAR_RECT),
+        "prepared_count": 84, "prepared_banner": True, "capacity_warning": "capacity_warning",
+        "viewport": dict(_FIXTURE_VIEWPORT),
+        # 说明卡在**视口下方**（y=980 ≥ 800）⇒ 折叠在页面底部 + 说明卡，两重都不参与阻断
+        "quote_hits": [_hit_help_card(980)],
+    }]},
+    # ★ 同一形态的**更严**变体：说明卡就在视口内（y=520）⇒ 仍**不**判满（帮助卡不参与阻断）
+    "help-card-visible": {"sources": [{
+        "page": "inbounds-list", "ok": True, "text": _FIXTURE_HELP_CARD_TEXT,
+        "rendered": True, "enviar_present": True, "enviar_disabled": False,
+        "enviar_rect": dict(_FIXTURE_ENVIAR_RECT),
+        "prepared_count": 84, "prepared_banner": True, "capacity_warning": "capacity_warning",
+        "viewport": dict(_FIXTURE_VIEWPORT),
+        "quote_hits": [_hit_help_card(520)],
+    }]},
+    # ★ 命中元素**不可见**（`display:none` 的模板/折叠块）⇒ 不参与阻断 ⇒ 不判满
+    "hidden-note": {"sources": [{
+        "page": "inbounds-list", "ok": True, "text": _FIXTURE_HELP_CARD_TEXT,
+        "rendered": True, "enviar_present": True, "enviar_disabled": False,
+        "enviar_rect": dict(_FIXTURE_ENVIAR_RECT),
+        "prepared_count": 84, "prepared_banner": True, "capacity_warning": "capacity_warning",
+        "viewport": dict(_FIXTURE_VIEWPORT),
+        "quote_hits": [_hit_help_card(300, visible=False)],
+    }]},
+    # ★ **旧判据会判满**的那个形态（文本命中 + 既有 capacity_warning + 按钮缺失，但**没有**
+    #   任何结构证据）：现在一律 unavailable（⛔ 见词不再判满；"无法区分 ⇒ 保守照常尝试"）
+    "legacy-no-structure": {"sources": [{
+        "page": "inbounds-list", "ok": True, "text": _FIXTURE_HELP_CARD_TEXT,
+        "rendered": True, "enviar_present": False,
+        "prepared_count": 84, "prepared_banner": True, "capacity_warning": "capacity_warning",
+    }]},
+    # ② 正常页（负样本）⇒ capacity_available
+    "normal": {"sources": [{
+        "page": "inbounds-list", "ok": True,
+        "text": "Envios Full ｜ 3 Envíos para terminar de preparar "
+                "Enviar productos ｜ Estado ｜ Acciones",
+        "rendered": True, "enviar_present": True,
+        "prepared_count": 3, "prepared_banner": True, "capacity_warning": None,
+    }]},
+    # ②b 佐证横幅在、但**没有**平台原文 ⇒ 仍是可用（⛔ 横幅单独不足以判满）
+    "banner-only": {"sources": [{
+        "page": "inbounds-list", "ok": True,
+        "text": "Envios Full ｜ 9 Envíos para terminar de preparar (anda-card)",
+        "rendered": True, "enviar_present": True, "prepared_count": 9,
+        "prepared_banner": True, "capacity_warning": None,
+    }]},
+    # ③ 探测不可用：取不到页面
+    "unavailable": {"sources": [{
+        "page": "inbounds-list", "ok": False, "note": "Timeout 30000ms exceeded",
+        "text": "", "rendered": None, "enviar_present": None,
+    }]},
+    # ③b 探测不可用：平台错误页
+    "error-page": {"sources": [{
+        "page": "inbounds-list", "ok": True,
+        "text": "Algo salió mal Estamos trabajando para solucionarlo. Ir a Gestión de envíos Full",
+        "rendered": False, "enviar_present": None,
+    }]},
+    # ③c 探测不可用：可读但入口明确不存在（`selectors.md`：库容满时该按钮不显示）
+    "enviar-absent": {"sources": [{
+        "page": "inbounds-list", "ok": True,
+        "text": "Envios Full ｜ Estado ｜ Acciones",
+        "rendered": True, "enviar_present": False,
+    }]},
+}
+
+
+def load_fixture(name: str) -> dict:
+    """取内置夹具。⛔ 未知名字**响亮失败**，不静默退化成空证据（那会判成 unavailable 掩盖笔误）。"""
+    if name not in FIXTURES:
+        raise KeyError(f"未知夹具：{name}（可用：{', '.join(sorted(FIXTURES))}）")
+    return json.loads(json.dumps(FIXTURES[name]))     # 深拷贝，防夹具被调用方改坏
+
+
+def fixture_names() -> list:
+    return sorted(FIXTURES)
+
+
+def _main(argv: Optional[list[str]] = None) -> int:
+    p = argparse.ArgumentParser(
+        prog="ml_capacity_probe.py",
+        description="仓容（库容）前置探测：纯判据（离线；真机抓取用 orchestrator --mode capacity-probe）")
+    src = p.add_mutually_exclusive_group(required=True)
+    src.add_argument("--evidence-file", help="只读证据 JSON 文件（`-` = 从 stdin 读）")
+    src.add_argument("--fixture", choices=fixture_names(), help="跑内置夹具")
+    p.add_argument("--json", action="store_true", help="输出完整 JSON（默认：中文摘要 + 结论）")
+    a = p.parse_args(argv)
+
+    if a.fixture:
+        try:
+            ev: Any = load_fixture(a.fixture)
+        except KeyError as exc:
+            print(f"⛔ {exc}", file=sys.stderr)
+            return 2
+    elif a.evidence_file == "-":
+        ev = sys.stdin.read()
+    else:
+        try:
+            ev = pathlib.Path(a.evidence_file).read_text(encoding="utf-8")
+        except OSError as exc:
+            print(f"⛔ 读不到证据文件：{exc}", file=sys.stderr)
+            return 2
+
+    v = capacity_verdict(ev)
+    if a.json:
+        print(json.dumps(v, ensure_ascii=False, indent=2))
+        return 0
+    icon = {VERDICT_FULL: "⛔", VERDICT_AVAILABLE: "✅", VERDICT_UNAVAILABLE: "❔"}[v["code"]]
+    print(f"{icon} {v['code']}：{v['conclusion']}")
+    print(f"   证据：{v['evidence']}")
+    if v["quote"]:
+        print(f"   平台原文：{v['quote']}")
+    if v["action"]:
+        print(f"   唯一动作：{v['action']}")
+    print(f"   失败文案：{v['text']}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(_main())