@whyshu/argent-engine 0.0.0-stage → 0.6.0

package/engine/scripts/ml_hub_status.py

@@ -0,0 +1,1556 @@
+#!/usr/bin/env python3
+"""hub-v2 货件真实状态：**只读探针 + 纯解析器**（需求 1 的判据层）。
+
+## 为什么需要它（用户口径，2026-10-09）
+
+> 「创建货件号之后，完全可以根据 `<平台域名>/shipping/inbounds/<货件号>/hub-v2` 页面中各状态来判断
+> 该货件号状态，例如**产品标签和箱唛是否下载完成、预约是否被取消**，这是最真实的状态查询方式。」
+
+现场实证（同一天）：`79096447` 在 hub-v2 上是「预约已取消 + 其余 4 项已完成」，而 lip 表里是
+`FULL状态=失败` / `当前步骤=失败：…` —— 表与真相**相反**，只有人工改表才能对齐。
+⇒ 本模块把「hub-v2 页面的逐项状态」变成结构化判据，供编排器在
+① 收口识别 ② 步骤1 前置校验 ③ 失败现场诊断 三处使用。
+
+## 分层（⛔ 别把浏览器塞进解析器）
+
+- **纯解析器**（本文件 99%）：`parse_hub_dump()` 吃「DOM dump 字典/JSON 字符串」吐结构化结论。
+  **无浏览器依赖、无网络、无宿主依赖**（只有 stdlib）⇒ 可用纯夹具做回归。
+- **只读探针**（`JS_HUB_DUMP` + 编排器 `--mode hub-status` / `Orchestrator.hub_status()`）：
+  导航到 hub-v2（**只读，⛔ 不点任何写按钮**）→ `page.evaluate(JS_HUB_DUMP)` → 交给本解析器。
+
+## 派生规则（**确定性**，逐条对应实现）
+
+| 派生结论 | 判据（按序，先命中先赢） |
+|---|---|
+| 逐项 `done` | 见 `_item_done()`：`aria-checked` / `aria-label` / class 词元 / 勾选图标 / 文本标记；正负信号都有才敢下结论，否则 `null`（**保守**） |
+| `appointment_cancelled` | 见 `_APPOINTMENT_RULES`（下表）：**残缺 ⇒ `null`** ⇒ **反证优先 ⇒ `false`** ⇒ 明确取消文案 ⇒ `true` ⇒ **真机校准组合**（环节已结束 ∧ 取消入口已消失）⇒ `true` ⇒ 其余 `null` |
+| `labels_downloaded` | 「产品标签」项的 `done`；`done=null` 时若页面文本含 `etiquetas descargadas` 之类正标记 ⇒ `true`；否则 `null`（**不猜 false**） |
+| `box_labels_downloaded` | 同上，「箱唛」项 |
+| `all_items_done` | 已知项**全部** `done is True` ∧ 无未知项 ⇒ `true`；任一项 `null/false` ⇒ `false` |
+| `operationally_complete` | **`appointment_cancelled is True` ∧ `labels_downloaded is True` ∧ `box_labels_downloaded is True`**（严格要求 `True`，`null` 一律不算）⇒ 识别为**运营手动完成** |
+
+### 步骤7「进不了箱数页」的只读归因（2026-10-12 批，`step7_block_verdict()`）
+
+同一模块里再加一条**独立的**判据链（**不动**上面的 hub 完成度判据）：步骤7 连续失败于
+「未见 `Agrupa tu stock`」时，**先只读读页面**再下结论 —— 判据顺序即优先级：
+
+| 序 | `kind` | 判据（先命中先赢） |
+|---|---|---|
+| ① | `size-block` | units 页量到 `size-dimensions-tag`，且 `size_tag_allowed(tag) is False`（∉ 中小件允许集，如 `EXTRAGRANDE`）⇒ 商品**超大件**、本货件空间**只收中小件** ⇒ **运营侧**（改包装尺寸或改渠道）；⛔ 脚本无解 |
+| ② | `precondition` | hub 有 `done is False` 的项，**或**正文含「Debes completar las tareas anteriores」⇒ 列出**未完成项原文** + 需运营在门户完成 |
+| ③ | `unattributed` | 都不是 ⇒ **逐字保留旧文案** + 补一句证据（`Agrupa tu stock` 缺失 / 当时 URL / 自愈轮数）供 ml-dev 排查门户改版 |
+
+⚠️ 三态**共用** `err_type="business"` ⇒ **探测结果绝不改变失败码/阻断性**；探测失败（无 DOM、
+导航失败、解析失败）一律落在③（⛔ 不上抛、⛔ 不判成"业务阻塞"）。
+
+⚠️ **判别力**：①的判据是**商品自己的尺寸标签**，⛔ 不是"页面上有空间限制文案" ——
+「Pequeños y medianos — Este espacio incluye…」描述的是**空间**，它在**任何一个**中小件货件的
+units 页上都会出现 ⇒ 单凭它会把正常票判成尺寸阻塞。空间文案只作**佐证留痕**。
+
+## 分支：units 页只读探针（`JS_UNITS_DUMP` + `parse_units_dump()`）
+
+`JS_UNITS_DUMP` **零判定词、零写操作**（只有 `querySelector` + 读属性）：把
+`[data-testid="size-dimensions-tag"]` / `[data-testid="volume-pill"]` 的**原文**、
+正文摘要、以及库存输入框（`aria-label="Stock a enviar"`）的 **disabled 渲染态**如实取回。
+`parse_units_dump()` 只登记事实 + 两个归一化事实（`size_tag_allowed` / `space_restricted`），
+**不下结论** —— 下结论的唯一入口是 `step7_block_verdict()`。
+
+### `appointment_cancelled` 的四步判据（**2026-10-09 真机校准**，见 `_APPOINTMENT_RULES`）
+
+真机样本 `79096447`（运营已手动完成：列表页 `Reserva cancelada`、预约已取消、标签+箱唛已下载）**证伪了
+旧判据**：那一页**通篇没有** `Reserva` / `cancelad` / `Cancelar` 任何字样（整份 dump 命中 0 次），
+旧规则 ①③ 永不命中；而 `Cancelar reserva` 按钮也**已消失**，于是旧规则落到 ④ ⇒ `null` ⇒
+`operationally_complete=false` ⇒ **把已完成的货件判成没完成**。
+
+| 步 | 条件 | 结论 |
+|---|---|---|
+| 0 | 探针无效 / **预约区域缺失**（无预约项）/ 预约卡**没渲染**（该项 `html` 为空）/ 预约项自身就是渲染残缺卡 | `null`（**残缺保守**：缺证据 ≠ 完成） |
+| 1 | hub 上**仍有** `Cancelar reserva`/`Cancelar cita`（按钮或文本），或有改期入口（`Reprogramar` / `Reagendar` / `Cambiar` + `reserva`/`cita`） | `false`（**预约还活着**，优先级最高 ⇒ 反证压过一切正证据） |
+| 2 | 预约项 `done is False`（环节**明确没结束**） | `false`（未结束 ⇒ 谈不上"取消完成"） |
+| 3 | 明确取消文案：`Reserva cancelada`/`cita cancelada`/`cancelaste la reserva`/`sin reserva`（预约项 label、预约项 `html`、正文任一命中） | `true` |
+| 4 | **真机校准组合**：预约项 `done is True`（环节**已结束**）**∧** `cancel_button_present is False`（取消入口**已消失**）**∧** 预约卡根节点可辨 | `true` |
+| 5 | 其余 | `null` |
+
+**为什么必须是"两条同时满足"（而不是只看其一）**：
+
+- **只看"没有取消按钮"会误判**：**从未预约**的货件同样没有 `Cancelar reserva` 按钮（没有预约可取消）
+  ⇒ 必须有"环节**已结束**"这一条把"尚未开始"排除掉。
+- **只看"环节已结束"会误判**：**预约成功**的货件该环节同样是"已结束"的（`done=True`），
+  这种货件页面上**仍留着 `Cancelar reserva`** ⇒ 第 1 步的按钮反证会先赢，判 `false`。
+- ⇒ 两条合取才唯一指向"结束的方式是**取消**"。真机证据另有一条**旁证**：五项里**只有预约卡**
+  的内层 `andes-card` **不带** `andes-card--completed`（其余四项都带）⇒ 预约环节处在
+  **另一种终态**（不是常规完成态），与"已取消"一致、与"从未开始"不矛盾 —— 但**它不是判据**
+  （真机同样形态无法排除"从未开始"），只作为证据留痕。
+
+**接口（可选组合，⛔ 不是必需）**：`parse_hub_dump(..., list_status="")` 收列表页/表里的粗粒度状态原文。
+优先级：**它永远不会把"判不了"变成"完成"**（⛔ 不做唯一依据）；只在第 4 步做
+①**否决**（列表页说预约仍有效 ⇒ 降级回 `null`）②**佐证留痕**（`signals.list_status_confirms`）。
+本样本**不依赖它**（仅凭 hub 即可判 `true`）。
+
+⚠️ `operationally_complete=True` ⇒ 货件**被视为已完成**（无论表里写什么），但
+**⛔ 绝不是让引擎去改写 `FULL状态`** —— 改写权在运营/用户；引擎只写「识别为运营手动完成（依据 hub-v2 实测）」的备注。
+
+## 容错（平台改版是常态）
+
+- 页面是**西班牙语**、且平台会改版 ⇒ 未知结构**绝不崩**：
+  逐项 dump **页面上真实存在的每一项**（`⛔ 不只挑认识的`），识别不了的记
+  `{"label": <原文>, "done": null, "known": false, "note": "unknown-structure"}`；
+- `parse_hub_dump()` 对畸形入参（非 JSON / 缺字段 / 类型错）一律返回**可用骨架 + `errors` 列表**，从不抛异常；
+- 派生结论遇 `null` 一律**保守**（不当成已完成）。
+
+## CLI（离线，不需要浏览器）
+
+    python3 scripts/ml_hub_status.py --dump-file <dump.json>      # 解析一份已抓到的 dump
+    python3 scripts/ml_hub_status.py --fixture all-done           # 跑内置夹具（回归/演示）
+    python3 scripts/ml_hub_status.py --dump-file - --json         # 从 stdin 读
+
+真机抓取（只读）走编排器：`--mode hub-status --shipment-id <号> [--store-name <店>]`。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import re
+import sys
+from typing import Any, Optional
+
+# ────────────────────────────────────────────────
+# 常量：URL 与词表（**唯一真源**，编排器从这里取，⛔ 不要各写一份）
+# ────────────────────────────────────────────────
+
+# ⚠️ **本模块刻意不内置平台域名**：`scripts/**` 是引擎面，不得出现业务词
+# （门禁 `scripts/vertical-lint.mjs` 的 engine-words 档，词表见 `verticals/_engine-words.json`）。
+# 平台基址由**调用方**注入（编排器传它自己的 `ML_BASE_URL`）⇒ 本模块零业务词。
+HUB_PATH_TEMPLATE = "/shipping/inbounds/{shipment_id}/hub-v2"
+# 商品/尺寸页（步骤7 归因探测的第二个观察点）：**现场证据**（2026-10-12 货件 79301358）——
+# hub 上「Tienes N producto para revisar」右侧【Editar】的 href 就是它。
+UNITS_PATH_TEMPLATE = "/shipping/inbounds/{shipment_id}/units?from=hub"
+
+# 夹具/离线自检用的**中性**基址（不是任何真实平台域名；只用于拼串与回归）
+FIXTURE_BASE_URL = "https://ml-platform.invalid"
+
+
+def hub_url(shipment_id: str, base_url: str) -> str:
+    """hub-v2 页 URL（与 `orchestrator._visit_plan_page_by_click` 的拼法逐字一致）。
+
+    `base_url` **必填**（⛔ 无默认值）：引擎面不内置业务域名，见上面的说明。
+    """
+    return f"{str(base_url).rstrip('/')}{HUB_PATH_TEMPLATE.format(shipment_id=str(shipment_id).strip())}"
+
+
+def units_url(shipment_id: str, base_url: str) -> str:
+    """商品/尺寸页 URL（步骤7 归因探测用；⛔ 只导航，不点任何按钮）。
+
+    与 `hub_url()` 同一口径：`base_url` **必填**（引擎面不内置业务域名）。
+    """
+    return f"{str(base_url).rstrip('/')}{UNITS_PATH_TEMPLATE.format(shipment_id=str(shipment_id).strip())}"
+
+
+# 已知项 key：识别**只为归类**（哪一项是标签/箱唛/预约），⛔ 不作为过滤条件。
+KEY_PREPARE = "prepare"
+KEY_APPOINTMENT = "appointment"
+KEY_PACKAGING = "packaging"
+KEY_LABELS = "labels"
+KEY_BOX_LABELS = "box_labels"
+
+# 归类词表（西班牙语；大小写不敏感）。顺序敏感：箱唛先于标签（「etiquetas de tus bultos」两边都沾）。
+_ITEM_CLASSIFIERS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    (KEY_BOX_LABELS, ("bulto", "pallet", "etiquetas de caja", "etiquetas de las cajas",
+                      "etiqueta de caja")),
+    (KEY_APPOINTMENT, ("reserva", "cita", "cuándo vas a enviar", "cuando vas a enviar",
+                       "elige cómo", "elige como")),
+    (KEY_LABELS, ("etiqueta", "label")),
+    (KEY_PACKAGING, ("revisa la preparación", "revisa la preparacion", "empaque",
+                     "reglamentaci", "preparación y reglamentación")),
+    (KEY_PREPARE, ("preparación del envío", "preparacion del envio", "prepara tu envío",
+                   "prepara tu envio", "agregar título", "agregar titulo", "descargar listado")),
+)
+
+# 页面级「预约已取消」词（强信号；**真机上常常缺席**，见模块 docstring）
+_APPT_CANCELLED_RE = re.compile(
+    r"reserva\s+cancelada|cita\s+cancelada|reserva\s+fu[eé]\s+cancelada|"
+    r"cancelaste\s+(?:la\s+)?(?:reserva|cita)|sin\s+(?:reserva|cita)",
+    re.IGNORECASE)
+
+# hub 上仍有此按钮/文本 ⇒ 预约仍有效（步骤8 的判定口径：取消生效后按钮消失）
+_APPT_ALIVE_RE = re.compile(r"cancelar\s+(?:reserva|cita)", re.IGNORECASE)
+# 改期入口同样说明"预约还在"（比按钮弱一档，但仍是**反证**）
+_APPT_ALIVE_WORD_RE = re.compile(
+    r"(?:reprogramar|reagendar|cambiar|modificar|reprogramaci[oó]n)\s+(?:la\s+|tu\s+)?"
+    r"(?:reserva|cita)",
+    re.IGNORECASE)
+
+# 列表页/表里的粗粒度状态说"预约仍有效" ⇒ 只能用来**否决**组合判据（⛔ 不做唯一依据）
+_LIST_ALIVE_RE = re.compile(
+    r"reserva\s+(?:activa|confirmada|vigente|programada)|cita\s+(?:activa|confirmada|vigente)",
+    re.IGNORECASE)
+
+# 渲染残缺卡（某子组件未渲染时平台会渲染它）——**只读证据**：
+# 它**不等于**"预约区域缺失"，判据必须能区分"别处坏了"与"预约区坏了"。
+_ERROR_CARD_RE = re.compile(r"error[-_]?card", re.IGNORECASE)
+_ERROR_TEXT_RE = re.compile(
+    r"algo\s+sali[oó]\s+mal|no\s+pudimos\s+mostrar\s+la\s+informaci[oó]n", re.IGNORECASE)
+
+# 预约卡根节点可辨（真机形态：`<div class="tour__appointment hub--card " data-testid="link-appointment">`）
+_APPT_CARD_ROOT_RE = re.compile(r"data-testid|hub--card", re.IGNORECASE)
+
+# ⛔ 判据**顺序即优先级**（改这条 = 改判据）；`appointment_cancelled` 的唯一实现见
+# `_appointment_cancelled()`。保留表结构只为让"四步判据"可被程序化引用/文档对齐。
+_APPOINTMENT_RULES: tuple[tuple[str, str], ...] = (
+    ("incomplete-page", "null（残缺保守：探针无效/预约区域缺失/预约卡未渲染）"),
+    ("alive-evidence", "false（仍有 Cancelar reserva 按钮或改期入口）"),
+    ("appointment-not-concluded", "false（预约项 done is False）"),
+    ("cancelled-text", "true（明确取消文案）"),
+    ("step-closed-and-no-cancel-affordance", "true（真机校准组合）"),
+    ("no-evidence", "null（判不了）"),
+)
+
+# 逐项正/负信号词（页面文本）
+_DONE_TEXT_RE = re.compile(
+    r"completad[oa]|finalizad[oa]|\blisto\b|\blista\b|descargad[oa]s?\b|"
+    r"ya\s+descargaste|\bhecho\b|\bcompleto\b",
+    re.IGNORECASE)
+_TODO_TEXT_RE = re.compile(
+    r"pendiente|comenzar|continuar|por\s+hacer|sin\s+comenzar|falta|incompleto|"
+    r"descargar\s+etiquetas|a[uú]n\s+no",
+    re.IGNORECASE)
+
+# 独立于逐项结构的「已下载」正标记（页面级兜底）
+_LABELS_DONE_TEXT_RE = re.compile(
+    r"etiquetas\s+descargadas|ya\s+descargaste\s+las\s+etiquetas|descarga\s+completada",
+    re.IGNORECASE)
+_BOX_DONE_TEXT_RE = re.compile(
+    r"bultos?\s+descargad|etiquetas\s+de\s+(?:tus\s+)?bultos\s+descargad|"
+    r"pallets?\s+descargad",
+    re.IGNORECASE)
+
+# class 词元级「完成」/「未完成」（用词元匹配，避免 substring 误命中）
+_DONE_CLASS_RE = re.compile(
+    r"(?:^|[-_])(?:check|checked|complete|completed|done|success|succeeded|finished|ready)(?:$|[-_])",
+    re.IGNORECASE)
+_NOT_DONE_CLASS_RE = re.compile(
+    r"incomplete|unchecked|not[-_]?done|pending|disabled|blocked|todo", re.IGNORECASE)
+
+# aria-label / title 上的完成语
+_ARIA_DONE_RE = re.compile(r"completad|finalizad|checked|\blisto\b|descargad", re.IGNORECASE)
+_ARIA_TODO_RE = re.compile(r"pendiente|sin\s+completar|no\s+completad|incomplet", re.IGNORECASE)
+
+MAX_ITEMS = 60          # 逐项上限（页面异常时不至于吐出几千条）
+MAX_RAW_SNIPPET = 600   # 单项 raw 片段截断
+MAX_BODY_TEXT = 2000    # 正文摘要截断
+
+
+# ────────────────────────────────────────────────
+# 只读 DOM dump（编排器 evaluate 这段 JS；⛔ 只读，不点任何按钮）
+# ────────────────────────────────────────────────
+
+JS_HUB_DUMP = r"""(function(){
+  var norm = function(s){ return (s || '').replace(/\s+/g, ' ').trim(); };
+  var txt  = function(el){ return el ? norm(el.innerText || el.textContent) : ''; };
+  var cls  = function(el){
+    var c = el && el.className;
+    return (typeof c === 'string') ? c : (c && c.baseVal) ? String(c.baseVal) : '';
+  };
+  // 证据扩展（v2，2026-10-09 真机校准）：把 class **按元素分词**存下来。
+  // 旧形态把 40 个后代 class 拼成 400 字符的串 ⇒ ①拼接截断会把命中的词元切掉
+  // ②事后无法回答"解析器记的 done_class=true 究竟从哪个词元来"。
+  // 真机 79096447 就撞上②：预约项记到 done_class=true，但 600 字符 html 里的 class
+  // 一个都不匹配 ⇒ 下一轮无法校准。⛔ 本字段**只扩证据、不改判据**。
+  var doneRe = /(?:^|[-_])(?:check|checked|complete|completed|done|success|succeeded|finished|ready)(?:$|[-_])/i;
+  var todoRe = /incomplete|unchecked|not[-_]?done|pending|disabled|blocked|todo/i;
+  var tokens = function(s){
+    var parts = String(s || '').split(/\s+/);
+    var acc = [];
+    for (var i = 0; i < parts.length; i++) { if (parts[i] && acc.indexOf(parts[i]) < 0) acc.push(parts[i]); }
+    return acc;
+  };
+  var out = {
+    url: location.href || '', title: document.title || '',
+    ready_state: document.readyState || '', h1: '',
+    body_text: '', items: [], cancel_button_present: false,
+    status_words: {}, errors: [], error_cards: [], probe_version: 2
+  };
+  try {
+    // 1) 页头：优先 h1，退化到 h2
+    var h = document.querySelector('h1') || document.querySelector('h2');
+    out.h1 = txt(h).substring(0, 200);
+
+    // 2) 正文摘要（只读）
+    var main = document.querySelector('main') || document.querySelector('#root-app')
+            || document.querySelector('[role=main]') || document.body;
+    out.body_text = txt(main).substring(0, 2000);
+
+    // 3) 「取消预约」按钮是否仍在页面上（预约仍有活 ⇒ 未取消）。只读探测，⛔ 不点。
+    var btns = document.querySelectorAll('button, a, [role=button]');
+    for (var b = 0; b < btns.length; b++) {
+      var bt = norm(btns[b].innerText || btns[b].textContent);
+      if (/cancelar\s+(reserva|cita)/i.test(bt)) { out.cancel_button_present = true; break; }
+    }
+
+    // 4) 逐项：宽口径收集"任务卡候选"，逐项如实 dump（不认识也留着）
+    var seen = {};
+    var cands = [];
+    var sels = ['[data-testid]', 'li', 'section', 'article', '[role=listitem]',
+                '[class*="task"]', '[class*="Task"]', '[class*="step"]',
+                '[class*="Step"]', '[class*="card"]', '[class*="Card"]',
+                '[class*="action"]', '[class*="Action"]', '[class*="requirement"]',
+                '[class*="Requirement"]', '[class*="checklist"]', '[class*="Checklist"]'];
+    for (var s = 0; s < sels.length; s++) {
+      var nodes;
+      try { nodes = document.querySelectorAll(sels[s]); } catch (e) { continue; }
+      for (var n = 0; n < nodes.length; n++) {
+        var el = nodes[n];
+        if (!el || el === document.body) continue;
+        var t = txt(el);
+        // 任务卡特征：文案短（5..180 字）且**不是**整页容器
+        if (t.length < 5 || t.length > 180) continue;
+        if (el.querySelectorAll('li, section, article').length > 1) continue;
+        cands.push({ el: el, text: t });
+      }
+    }
+    // 去重 + 取「最具体」的那一个（同文案保留最短文本者，即最内层）
+    for (var c = 0; c < cands.length; c++) {
+      var key = cands[c].text;
+      if (!seen[key] || seen[key].text.length > key.length) { seen[key] = cands[c]; }
+    }
+    var keys = Object.keys(seen);
+    for (var k = 0; k < keys.length && out.items.length < 60; k++) {
+      var item = seen[keys[k]];
+      var el2 = item.el;
+      var info = { label: item.text.substring(0, 180), html: '' };
+
+      // aria-checked（Andes 复选框/步骤条）
+      var ac = el2.getAttribute && el2.getAttribute('aria-checked');
+      if (ac === 'true' || ac === 'false') { info.aria_checked = (ac === 'true'); }
+
+      // aria-label / title（本体 + 一层后代）
+      var aria = (el2.getAttribute && (el2.getAttribute('aria-label') || el2.getAttribute('title'))) || '';
+      info.aria_label = norm(aria).substring(0, 160);
+
+      // class（本体 + 后代，限 40 个，防爆）
+      var classes = [cls(el2)];
+      var desc = el2.querySelectorAll('*');
+      for (var d = 0; d < desc.length && d < 40; d++) { classes.push(cls(desc[d])); }
+      info.classes = classes.filter(Boolean).join(' ').substring(0, 400);
+
+      // 勾选图标（Andes check 图标 / svg use#check）
+      var icon = el2.querySelector(
+        'svg[class*="check"], svg[class*="Check"], [class*="check-circle"], ' +
+        '[class*="CheckCircle"], use[href*="check"], use[xlink\\:href*="check"], ' +
+        'img[src*="check"], i[class*="check"]');
+      info.has_check_icon = !!icon;
+
+      // 未完成态按钮（Descargar / Comenzar / Continuar）仍在 ⇒ 该项多半没做完
+      var todoBtn = false;
+      var bs = el2.querySelectorAll('button, a[role=button], [role=button]');
+      for (var q = 0; q < bs.length; q++) {
+        var btxt = norm(bs[q].innerText || bs[q].textContent);
+        var dis = !!bs[q].disabled || bs[q].getAttribute('aria-disabled') === 'true';
+        if (!dis && /^(descargar|comenzar|continuar|elegir|agregar)/i.test(btxt)) { todoBtn = true; break; }
+      }
+      info.has_todo_button = todoBtn;
+
+      // 片段（供回归/排障）
+      try { info.html = (el2.outerHTML || '').substring(0, 600); } catch (e) { info.html = ''; }
+
+      // 证据扩展（v2）：逐元素分词后的 class 词元 + 命中的词元 + 卡状态。
+      // ⛔ 只写进 dump，判据仍走 `classes`（旧字段），行为零变化。
+      try {
+        var els = [el2];
+        for (var e1 = 0; e1 < desc.length; e1++) { els.push(desc[e1]); }
+        var tk = [];
+        for (var e2 = 0; e2 < els.length; e2++) {
+          var one = tokens(cls(els[e2]));
+          for (var t1 = 0; t1 < one.length; t1++) {
+            if (tk.indexOf(one[t1]) < 0) tk.push(one[t1]);
+          }
+        }
+        info.class_tokens = tk.slice(0, 160);
+        info.done_class_hits = tk.filter(function(x){ return doneRe.test(x); }).slice(0, 12);
+        info.todo_class_hits = tk.filter(function(x){ return todoRe.test(x); }).slice(0, 12);
+        // 两个**权威布尔**（与命中词元同源）：离线复核/夹具可以只带它们 ——
+        // 不要求"必须知道是哪个词元命中的"（真机 79096447 就只知道布尔、不知道词元）。
+        info.done_class = (info.done_class_hits.length > 0);
+        info.todo_class = (info.todo_class_hits.length > 0);
+        info.card_completed_class = (tk.indexOf('andes-card--completed') >= 0);
+        info.tag = String(el2.tagName || '').toLowerCase();
+        info.data_testid = norm(el2.getAttribute ? (el2.getAttribute('data-testid') || '') : '');
+      } catch (e) { /* 证据扩展失败不影响主 dump */ }
+      out.items.push(info);
+    }
+
+    // 5) 状态词计数（页面级证据，供排障对账）
+    var vocab = ['Reserva cancelada', 'Cancelar reserva', 'Cancelar cita', 'Reserva',
+                 'Completado', 'Completada', 'Finalizado', 'Pendiente', 'Descargar',
+                 'etiquetas', 'bultos', 'pallets'];
+    for (var v = 0; v < vocab.length; v++) {
+      var w = vocab[v];
+      var m = out.body_text.split(w).length - 1;
+      if (m > 0) { out.status_words[w] = m; }
+    }
+
+    // 6) 渲染残缺卡（只读证据）：某子组件未渲染 ⇒ 平台渲染一个 error-card。
+    //    ⛔ 它**不等于**"预约区域缺失"：真机 79096447 上就同时存在
+    //    「预约卡正常渲染」与「seller-monitor 子组件报错」⇒ 判据必须能区分二者。
+    var ecs = document.querySelectorAll(
+      '[class*="error-card"], [class*="ErrorCard"], [class*="errorCard"]');
+    for (var e3 = 0; e3 < ecs.length && e3 < 5; e3++) {
+      out.error_cards.push({ label: txt(ecs[e3]).substring(0, 160),
+                             classes: cls(ecs[e3]).substring(0, 160) });
+    }
+  } catch (e) {
+    out.errors.push('dump_error: ' + (e && e.message ? e.message : String(e)));
+  }
+  return JSON.stringify(out);
+})();"""
+
+
+# ── units 页（商品/尺寸）只读 dump（2026-10-12 步骤7 归因批）────────────────────────────
+# ⛔ **零判定词**：这段 JS 只**测量**（把页面上的原文/渲染态如实取回），判据一律在
+#   下面的纯函数（`parse_units_dump` / `size_tag_allowed` / `step7_block_verdict`）里。
+# ⛔ **只读**：没有任何 click / fill / 赋值，只有 querySelector + 读属性。
+# 观察点（现场证据 79301358 逐字）：
+#   · `[data-testid="size-dimensions-tag"]` 文案（真机 = `EXTRAGRANDE`）
+#   · `[data-testid="volume-pill"]`        文案（真机 = `11,712 cm 3`）
+#   · 正文摘要（内含「Pequeños y medianos — Este espacio incluye…」/「Revisar dimensiones permitidas」）
+#   · 库存输入框（`aria-label="Stock a enviar"`，真机值 200）的**渲染态**：
+#     平台把它渲染成 disabled（外层 `andes-form-control--disabled` + `data-andes-state="disabled"`）
+JS_UNITS_DUMP = r"""(function(){
+  var norm = function(s){ return (s || '').replace(/\s+/g, ' ').trim(); };
+  var txt  = function(el){ return el ? norm(el.innerText || el.textContent) : ''; };
+  var textOf = function(sel){
+    var el = null;
+    try { el = document.querySelector(sel); } catch (e) { el = null; }
+    return el ? txt(el).substring(0, 200) : '';
+  };
+  var out = {
+    url: location.href || '', title: document.title || '',
+    ready_state: document.readyState || '',
+    size_dimensions_tag: '', volume_pill: '', body_text: '',
+    stock_input_present: false, stock_input_disabled: false,
+    stock_input_aria: '', stock_input_value: '',
+    probe_version: 1, errors: []
+  };
+  try {
+    out.size_dimensions_tag = textOf('[data-testid="size-dimensions-tag"]');
+    out.volume_pill = textOf('[data-testid="volume-pill"]');
+
+    var main = document.querySelector('main') || document.querySelector('#root-app')
+            || document.querySelector('[role=main]') || document.body;
+    out.body_text = (main ? norm(main.innerText || main.textContent) : '').substring(0, 2000);
+
+    // 库存输入框：只**测量**它是否被平台渲染成 disabled（⛔ 不改值、不启用、不聚焦）
+    var inp = document.querySelector('[aria-label="Stock a enviar"]')
+           || document.querySelector('[data-testid^="input-textfield"]')
+           || document.querySelector('input[type="number"]');
+    if (inp) {
+      out.stock_input_present = true;
+      out.stock_input_aria = norm(inp.getAttribute('aria-label') || '');
+      out.stock_input_value = norm(inp.value === undefined ? '' : inp.value).substring(0, 40);
+      var state = inp.getAttribute('data-andes-state') || '';
+      var ctl = (inp.closest ? inp.closest('.andes-form-control') : null);
+      var ccls = (ctl && typeof ctl.className === 'string') ? ctl.className : '';
+      out.stock_input_disabled = (inp.disabled === true) || (state === 'disabled')
+        || (ccls.indexOf('andes-form-control--disabled') >= 0);
+    }
+  } catch (e) {
+    out.errors.push('dump_error: ' + (e && e.message ? e.message : String(e)));
+  }
+  return JSON.stringify(out);
+})();"""
+
+
+# ────────────────────────────────────────────────
+# 纯解析器
+# ────────────────────────────────────────────────
+
+def _as_text(v: Any) -> str:
+    if v is None:
+        return ""
+    if isinstance(v, list):
+        return " ".join(_as_text(x) for x in v)
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    return str(v)
+
+
+def classify_item(label: str) -> Optional[str]:
+    """把一条原文标签归到已知 key；认不出返回 `None`（**不猜**）。"""
+    low = _as_text(label).lower()
+    if not low:
+        return None
+    for key, needles in _ITEM_CLASSIFIERS:
+        for needle in needles:
+            if needle in low:
+                return key
+    return None
+
+
+def _item_done(info: dict) -> tuple[Optional[bool], dict, str]:
+    """单条的完成判定 → `(done, signals, note)`。
+
+    **三态**：`True` / `False` / `None`（判不了 ⇒ None，**保守**，⛔ 不默认成完成）。
+    正信号（完成侧）与负信号（未完成侧）都记进 `signals` 便于回归与排障。
+    """
+    label = _as_text(info.get("label"))
+    classes = _as_text(info.get("classes"))
+    aria = _as_text(info.get("aria_label"))
+    html = _as_text(info.get("html"))
+
+    signals: dict[str, Any] = {}
+
+    ac = info.get("aria_checked", None)
+    if isinstance(ac, bool):
+        signals["aria_checked"] = ac
+
+    if aria:
+        if _ARIA_DONE_RE.search(aria):
+            signals["aria_done_word"] = True
+        if _ARIA_TODO_RE.search(aria):
+            signals["aria_todo_word"] = True
+
+    if classes or isinstance(info.get("done_class_hits"), list) or isinstance(info.get("done_class"), bool):
+        # 证据扩展（v2，真机校准）：探针给了**逐元素分词**的命中词元 / 权威布尔时**以它为准**
+        # （`[]` / `false` 也是权威答案：说明确实没有完成词元 ⇒ 不再回落到拼接串，避免
+        #  400 字符截断把某个词元切出 `$` 边界而**假命中**）。
+        hits = info.get("done_class_hits")
+        flag = info.get("done_class")
+        if isinstance(hits, list):
+            if hits:
+                signals["done_class"] = True
+                signals["done_class_hits"] = [_as_text(x)[:48] for x in hits[:12] if _as_text(x)]
+        elif isinstance(flag, bool):
+            if flag:
+                signals["done_class"] = True
+        elif _DONE_CLASS_RE.search(classes):
+            signals["done_class"] = True
+    if (classes or isinstance(info.get("todo_class_hits"), list)
+            or isinstance(info.get("todo_class"), bool)):
+        todo_hits = info.get("todo_class_hits")
+        todo_flag = info.get("todo_class")
+        if isinstance(todo_hits, list):
+            if todo_hits:
+                signals["todo_class"] = True
+                signals["todo_class_hits"] = [_as_text(x)[:48] for x in todo_hits[:12] if _as_text(x)]
+        elif isinstance(todo_flag, bool):
+            if todo_flag:
+                signals["todo_class"] = True
+        elif _NOT_DONE_CLASS_RE.search(classes):
+            signals["todo_class"] = True
+
+    # 卡状态（**只留痕，⛔ 绝不当负信号**）：真机 79096447 上"预约已取消"的预约卡恰好
+    # **不带** `andes-card--completed`（其余四项都带）⇒ 若把它当"未完成"负信号，会把
+    # 真机样本当场判成未完成（与事实相反）。它是"另一种终态"的证据，不是 done/not-done。
+    if isinstance(info.get("card_completed_class"), bool):
+        signals["card_completed_class"] = info["card_completed_class"]
+    if info.get("data_testid"):
+        signals["data_testid"] = _as_text(info.get("data_testid"))[:48]
+
+    if info.get("has_check_icon"):
+        signals["check_icon"] = True
+    if info.get("has_todo_button"):
+        signals["todo_button"] = True
+
+    if _DONE_TEXT_RE.search(label):
+        signals["done_word"] = True
+    if _TODO_TEXT_RE.search(label):
+        signals["todo_word"] = True
+
+    # 负面 evidence 优先（页面同时出现两套词时，宁可不判）
+    hard_false = [k for k in ("aria_checked", "todo_class", "todo_button", "todo_word",
+                              "aria_todo_word") if signals.get(k) is True and k != "aria_checked"]
+    if signals.get("aria_checked") is False:
+        hard_false.append("aria_checked=false")
+    hard_true = [k for k in ("aria_checked", "done_class", "check_icon", "done_word",
+                             "aria_done_word") if signals.get(k) is True]
+
+    if hard_false and not hard_true:
+        return False, signals, ""
+    if hard_true and not hard_false:
+        return True, signals, ""
+    if hard_true and hard_false:
+        # 自相矛盾（例如 card 容器 class 带 done、内部按钮仍可点）：保守判 False
+        return False, signals, "conflicting-signals（保守判未完成）"
+    note = "unknown-structure（未识别出完成/未完成标记）" if not html else "no-signal"
+    return None, signals, note
+
+
+def _appointment_cancelled(appt_item: dict, *, label: str, html: str, body: str,
+                           cancel_button_present: Optional[bool], probe_ok: bool,
+                           error_card_present: bool, error_item_indices: Optional[set] = None,
+                           list_status: str = "") -> tuple[Optional[bool], str, dict]:
+    """预约环节是否**已取消** ⇒ `(值, 判据名, 附加 signals)`。
+
+    ⛔ **顺序即优先级**（改这条 = 改判据）；四步判据的完整理由与真机证据见模块 docstring。
+    真机校准（2026-10-09，样本 `79096447`：运营已手动完成、预约已取消）：
+    - 旧实现把"页面文本含 `Reserva cancelada`"排在第一位，而**真机那一页通篇没有**
+      `Reserva`/`cancelad`/`Cancelar` 任何字样 ⇒ 旧判据恒不命中，落回 `null`；
+    - 真机**有**的可靠证据是两条：①预约项 `done is True`（环节已结束）
+      ②页面上**再也找不到** `Cancelar reserva`（取消入口已消失）
+      ⇒ 二者合取才唯一指向"结束的方式是取消"（见下面的排除逻辑）。
+    """
+    extra: dict[str, Any] = {}
+
+    # 步 0：残缺闸门 —— 缺证据 ≠ 完成（⛔ 绝不放行）
+    if not probe_ok:
+        return None, "probe-unusable", extra
+    if not appt_item:
+        return None, "appointment-region-missing", extra
+    if not _as_text(html).strip():
+        return None, "appointment-card-not-rendered", extra
+    if not _APPT_CARD_ROOT_RE.search(html):
+        return None, "appointment-card-unrecognized", extra
+    if error_card_present and int(appt_item.get("index", -1)) in (error_item_indices or set()):
+        # 预约项**自身**就是渲染残缺卡 ⇒ 预约区域被破坏
+        return None, "appointment-region-broken", extra
+
+    # 步 1：反证优先（预约还活着）—— ⛔ 按钮/改期入口压过一切正证据
+    if cancel_button_present is True:
+        return False, "cancel-button-present", extra
+    if _APPT_ALIVE_RE.search(f"{label} {html} {body}"):
+        return False, "appointment-alive-text", extra
+    if _APPT_ALIVE_WORD_RE.search(f"{label} {html} {body}"):
+        return False, "appointment-reschedule-affordance", extra
+
+    # 步 2：环节**明确没结束** ⇒ 谈不上"取消完成"
+    if appt_item.get("done") is False:
+        return False, "appointment-item-not-done", extra
+
+    # 步 3：明确取消文案（真机常常没有；有就最硬）
+    if _APPT_CANCELLED_RE.search(f"{label} {html} {body}"):
+        return True, "cancelled-text", extra
+
+    # 步 4：真机校准组合 —— 环节已结束 ∧ 取消入口已消失
+    if appt_item.get("done") is True and cancel_button_present is False:
+        if _LIST_ALIVE_RE.search(_as_text(list_status)):
+            # 组合证据被列表页否决 ⇒ 退回"判不了"（⛔ 不硬判 false：hub 侧证据没被证伪）
+            extra["list_status_vetoes"] = _as_text(list_status)[:80]
+            return None, "step-closed-but-list-status-alive", extra
+        if _APPT_CANCELLED_RE.search(_as_text(list_status)):
+            extra["list_status_confirms"] = _as_text(list_status)[:80]
+        return True, "step-closed-and-no-cancel-affordance", extra
+
+    # 步 5：判不了（例如"从未预约"：环节未结束 ∧ 也没有取消按钮 ⇒ 两条都不满足）
+    return None, "no-evidence", extra
+
+
+def _raw_item_of(info: dict, label: str) -> dict:
+    """逐项**原始证据**投影（进 `state["raw"]["items"]`，供离线复核与下一轮校准）。
+
+    2026-10-09 真机校准的教训：旧投影只留 `label` + `html`（600 字符截断）⇒ 解析器
+    记下 `done_class=true` 之后，**没有人能再回答"它从哪个词元来"**（命中词元落在
+    截断之外）⇒ 判据无法校准。这里把 v2 证据字段一并带上（⛔ 只留证据，不改判据）。
+    """
+    out = {"label": label, "html": _as_text(info.get("html"))[:MAX_RAW_SNIPPET]}
+    for key in ("classes", "aria_label"):
+        v = _as_text(info.get(key))
+        if v:
+            out[key] = v[:MAX_RAW_SNIPPET]
+    for key in ("class_tokens", "done_class_hits", "todo_class_hits"):
+        v = info.get(key)
+        if isinstance(v, list):
+            out[key] = [_as_text(x)[:64] for x in v[:160] if _as_text(x)]
+    for key in ("card_completed_class", "has_check_icon", "has_todo_button", "aria_checked",
+                "done_class", "todo_class"):
+        if isinstance(info.get(key), bool):
+            out[key] = info[key]
+    for key in ("tag", "data_testid"):
+        v = _as_text(info.get(key))
+        if v:
+            out[key] = v[:64]
+    return out
+
+
+def _empty_state(shipment_id: str = "", url: str = "") -> dict:
+
+    return {
+        "shipment_id": str(shipment_id or ""),
+        "url": url or "",
+        "url_inbound": "",
+        "title": "",
+        "h1": "",
+        "ready_state": "",
+        "body_text": "",
+        "status_words": {},
+        "cancel_button_present": None,
+        "list_status": "",
+        "appointment_cancelled_by": "",
+        "items": [],
+        "by_key": {},
+        "unknown_items": [],
+        "appointment_cancelled": None,
+        "labels_downloaded": None,
+        "box_labels_downloaded": None,
+        "all_items_done": False,
+        "operationally_complete": False,
+        "complete_reason": "",
+        "probe_ok": False,
+        "errors": [],
+        "raw": {},
+    }
+
+
+def parse_hub_dump(dump: Any, shipment_id: str = "", list_status: str = "") -> dict:
+    """DOM dump（dict 或 JSON 字符串）→ 结构化 hub 状态。**从不抛异常**（容错是硬要求）。
+
+    `list_status`（可选）：列表页/表里的粗粒度状态原文。**⛔ 永远不是唯一依据** ——
+    它只能在第 4 步**否决**组合判据，或作为佐证留痕（接口与优先级见模块 docstring）。
+    """
+    state = _empty_state(shipment_id=shipment_id)
+    errors: list = state["errors"]
+
+    data: dict
+    if isinstance(dump, str):
+        try:
+            data = json.loads(dump or "{}")
+        except Exception as exc:                                  # noqa: BLE001
+            errors.append(f"dump-not-json: {type(exc).__name__}: {exc}")
+            data = {}
+    elif isinstance(dump, dict):
+        data = dump
+    else:
+        errors.append(f"dump-type-unexpected: {type(dump).__name__}")
+        data = {}
+    if not isinstance(data, dict):
+        errors.append("dump-not-object")
+        data = {}
+    errors.extend([_as_text(e) for e in (data.get("errors") or []) if e])
+
+    url = _as_text(data.get("url"))
+    state["url"] = url
+    state["title"] = _as_text(data.get("title"))[:300]
+    state["h1"] = _as_text(data.get("h1"))[:300]
+    state["ready_state"] = _as_text(data.get("ready_state"))[:32]
+    body = _as_text(data.get("body_text"))[:MAX_BODY_TEXT]
+    state["body_text"] = body
+
+    # 真实 URL 被跳转时以 URL 为准（「真相在 URL」——与 ⑰ 取号缺陷同一口径）
+    m = re.search(r"/inbounds/(\d{6,})/", url)
+    state["url_inbound"] = m.group(1) if m else ""
+    if not state["shipment_id"] and state["url_inbound"]:
+        state["shipment_id"] = state["url_inbound"]
+
+    words = data.get("status_words")
+    if isinstance(words, dict):
+        state["status_words"] = {str(k): v for k, v in words.items() if v}
+
+    cbp = data.get("cancel_button_present")
+    state["cancel_button_present"] = cbp if isinstance(cbp, bool) else None
+
+    # ── 逐项：如实 dump，认不出也留 ──────────────────────────────
+    items: list = []
+    raw_items: list = []
+    error_item_indices: set = set()
+    raw = data.get("items")
+    if not isinstance(raw, list):
+        if raw is not None:
+            errors.append("items-not-list")
+        raw = []
+    for idx, info in enumerate(raw[:MAX_ITEMS]):
+        if not isinstance(info, dict):
+            items.append({"key": None, "label": _as_text(info)[:180], "done": None,
+                          "known": False, "signals": {},
+                          "note": "unknown-structure（条目不是对象）"})
+            continue
+        label = _as_text(info.get("label"))[:180]
+        key = classify_item(label)
+        done, signals, note = _item_done(info)
+        entry = {
+            "key": key,
+            "label": label,
+            "done": done,
+            "known": key is not None,
+            "signals": signals,
+            "note": note,
+            "index": idx,
+        }
+        items.append(entry)
+        if not key:
+            state["unknown_items"].append({"label": label, "done": None,
+                                           "note": note or "unknown-structure"})
+        raw_items.append(_raw_item_of(info, label))
+    state["items"] = items
+
+    # 同类多项时取「最强的那个」：done True 优先，其次 False，再次 None
+    def _rank(e: dict) -> int:
+        return {True: 0, False: 1, None: 2}.get(e.get("done"), 3)
+
+    by_key: dict = {}
+    for e in items:
+        k = e.get("key")
+        if not k:
+            continue
+        cur = by_key.get(k)
+        if cur is None or _rank(e) < _rank(cur):
+            by_key[k] = e
+    state["by_key"] = by_key
+
+    # 探针有效性：**必须在派生结论之前**算出来（残缺闸门要用它）
+    probe_ok = bool(url or items or body)
+    state["probe_ok"] = probe_ok
+    # 渲染残缺证据（v2 字段 + 逐项兜底识别）：⛔ 它**不等于**"预约区域缺失"
+    error_card_present = bool(
+        isinstance(data.get("error_cards"), list) and data.get("error_cards"))
+    for idx, info in enumerate(raw[:MAX_ITEMS]):
+        if not isinstance(info, dict):
+            continue
+        if (_ERROR_CARD_RE.search(_as_text(info.get("classes")))
+                or _ERROR_CARD_RE.search(_as_text(info.get("html")))
+                or _ERROR_TEXT_RE.search(_as_text(info.get("label")))):
+            error_card_present = True
+            error_item_indices.add(idx)
+
+    # ── 派生结论（规则见模块 docstring 的表） ────────────────────
+    appt_item = by_key.get(KEY_APPOINTMENT) or {}
+    appt_text = f"{_as_text(appt_item.get('label'))} {body}"
+    # 逐项 html 只在 `raw` 投影里（parsed entry 不带原始片段）⇒ 按 index 取回
+    _ai = appt_item.get("index")
+    appt_html = (_as_text(raw_items[_ai].get("html"))
+                 if isinstance(_ai, int) and 0 <= _ai < len(raw_items) else "")
+
+    cancelled, cancelled_by, cancelled_extra = _appointment_cancelled(
+        appt_item,
+        label=_as_text(appt_item.get("label")),
+        html=appt_html,
+        body=body,
+        cancel_button_present=state["cancel_button_present"],
+        probe_ok=probe_ok,
+        error_card_present=error_card_present,
+        error_item_indices=error_item_indices,
+        list_status=list_status,
+    )
+    state["appointment_cancelled"] = cancelled
+    state["list_status"] = _as_text(list_status)[:120]
+    state.setdefault("signals", {})["appointment_cancelled_by"] = cancelled_by
+    state["signals"].update(cancelled_extra)
+
+    labels_item = by_key.get(KEY_LABELS) or {}
+    if labels_item.get("done") is True:
+        state["labels_downloaded"] = True
+    elif _LABELS_DONE_TEXT_RE.search(body):
+        state["labels_downloaded"] = True
+    elif labels_item.get("done") is False:
+        state["labels_downloaded"] = False
+    else:
+        state["labels_downloaded"] = None
+
+    box_item = by_key.get(KEY_BOX_LABELS) or {}
+    if box_item.get("done") is True:
+        state["box_labels_downloaded"] = True
+    elif _BOX_DONE_TEXT_RE.search(body):
+        state["box_labels_downloaded"] = True
+    elif box_item.get("done") is False:
+        state["box_labels_downloaded"] = False
+    else:
+        state["box_labels_downloaded"] = None
+
+    known_items = [e for e in items if e.get("known")]
+    state["all_items_done"] = bool(
+        known_items
+        and not state["unknown_items"]
+        and all(e.get("done") is True for e in known_items)
+    )
+
+    state["operationally_complete"] = (
+        state["appointment_cancelled"] is True
+        and state["labels_downloaded"] is True
+        and state["box_labels_downloaded"] is True
+    )
+    if state["operationally_complete"]:
+        state["complete_reason"] = ("预约已取消 ∧ 产品标签已下载 ∧ 箱唛已下载（hub-v2 实测）")
+    else:
+        missing = []
+        if state["appointment_cancelled"] is not True:
+            missing.append(f"预约未确认取消（{_tri(state['appointment_cancelled'])}）")
+        if state["labels_downloaded"] is not True:
+            missing.append(f"产品标签未确认下载（{_tri(state['labels_downloaded'])}）")
+        if state["box_labels_downloaded"] is not True:
+            missing.append(f"箱唛未确认下载（{_tri(state['box_labels_downloaded'])}）")
+        state["complete_reason"] = "未识别为完成：缺 " + "、".join(missing)
+
+    state["probe_ok"] = probe_ok
+    state["raw"] = {
+        "body_text": body,
+        "h1": state["h1"],
+        "matched_url": url,
+        "probe_version": data.get("probe_version") if isinstance(data.get("probe_version"), int) else 1,
+        "error_cards": [{"label": _as_text(c.get("label"))[:160],
+                         "classes": _as_text(c.get("classes"))[:160]}
+                        for c in (data.get("error_cards") or []) if isinstance(c, dict)][:5],
+        "items": raw_items,
+    }
+    if not probe_ok:
+        errors.append("empty-dump（URL/正文/逐项全空 ⇒ 页面可能未加载或探针失效）")
+    return state
+
+
+# ────────────────────────────────────────────────
+# 步骤7「进不了箱数页」的**只读归因**（2026-10-12 生产事故批）
+# ────────────────────────────────────────────────
+#
+# ## 为什么要它（现场，货件 79301358 / SKU HW-MX-162 / 1 店）
+#
+# 步骤7 连续 **5 次**失败，文案一律是「页面未到箱数填写页：2 轮自愈+重导航后仍未见
+# 「Agrupa tu stock」」⇒ 这句话**只说"没看到什么"**，不说"页面到底是什么样" ⇒ 角色据此刻度
+# 升级为「脚本缺陷/门户改版（入口缺失）⇒ 需 ml-dev 修选择器」—— **误导**（ml-dev 无从下手）。
+#
+# **真因**（运营判定 + 门户实读）：商品被判为**超大件**，而该货件空间**只收中小件**：
+#   · units 页 `size-dimensions-tag` = `EXTRAGRANDE`；`volume-pill` = `11,712 cm 3`
+#   · 空间原文「Pequeños y medianos — Este espacio incluye a los productos Pequeños y medianos.
+#     Revisa el tamaño de cada uno junto a su nombre.」
+#   · 库存输入框（`aria-label="Stock a enviar"`，值 200）被平台渲染为 **disabled**
+#   · hub 第 5 项「Prepara bultos y/o pallets…」`done=False`，紧随其后
+#     「Debes completar las tareas anteriores para preparar e identificar.」
+# 运营实测：把该 disabled 输入框强制启用+重输+点 Guardar **无任何效果**（hub 项不变）
+# ⇒ **脚本侧无解**，必须运营改商品（尺寸或渠道）。
+#
+# ## 判据（**顺序即优先级**；⛔ 改这条 = 改判据；唯一实现见 `step7_block_verdict()`）
+#
+# | 序 | 结论 kind | 判据 |
+# |---|---|---|
+# | ① | `size-block` | measures 到尺寸标签，且 `size_tag_allowed(tag) is False`（标签 ∉ 中小件允许集） |
+# | ② | `precondition` | hub 有 `done is False` 的项，**或**正文含「Debes completar las tareas anteriores」 |
+# | ③ | `unattributed` | 都不是 ⇒ 保留旧文案 + 补证据（`Agrupa tu stock` 缺失 / 当时 URL / 自愈轮数） |
+#
+# ⚠️ **判别力：为什么①的判据是"商品自己的尺寸标签"，而不是"页面上有空间限制文案"**
+# （⛔ 别改回去）：空间文案「Pequeños y medianos — Este espacio incluye…」描述的是**空间**
+# （"这个空间收中小件"），它在**任何一个**中小件货件的 units 页上都会出现 ⇒ 单凭它判①会把
+# **正常票**全判成尺寸阻塞（回归 §② 的负样本正是这个形态）。故空间文案 / 「Revisar dimensiones
+# permitidas」只作**佐证留痕**（`signals.space_restricted`），判据仍是商品自己的标签。
+#
+# ⚠️ **探测失败 ⇒ 一律③**（⛔ 绝不上抛、⛔ 绝不改成"业务阻塞"）：归因缺失只能让证据少一句，
+# 不能让失败码/阻断性发生变化（旧文案与失败类型逐字保留）。
+_SIZE_TAG_ALLOWED: tuple[str, ...] = (
+    # 中小件允许集（= 空间文案「Pequeños y medianos」的取值域）；⛔ 刻意不含 grande/extragrande
+    "PEQUENO", "PEQUENA", "PEQUENOS", "PEQUENAS",
+    "MEDIANO", "MEDIANA", "MEDIANOS", "MEDIANAS",
+    "CHICO", "CHICA", "CHICOS", "CHICAS",
+)
+
+# 标签里的连接词/标签词（"Tamaño: pequeño y mediano" 这类写法）——**只用于归一化取词元**，不参与判定
+_SIZE_TAG_STOP: frozenset = frozenset({
+    "Y", "O", "E", "U", "DE", "DEL", "LA", "EL", "LOS", "LAS", "TAMANO", "TAMANOS",
+})
+
+_ACCENTS = str.maketrans({
+    "Á": "A", "É": "E", "Í": "I", "Ó": "O", "Ú": "U", "Ü": "U", "Ñ": "N",
+    "á": "A", "é": "E", "í": "I", "ó": "O", "ú": "U", "ü": "U", "ñ": "N",
+})
+
+# 「这个空间只收中小件」的空间原文（**佐证**，不是判据；见上面的判别力说明）
+# 现场原文：「Pequeños y medianos — Este espacio incluye a los productos Pequeños y medianos.
+#           Revisa el tamaño de cada uno junto a su nombre.」＋链接「Revisar dimensiones permitidas」
+_SIZE_SPACE_RESTRICTED_RE = re.compile(
+    r"peque[nñ]os\s+y\s+medianos[^.]{0,160}\.?|"
+    r"espacio\s+incluye\s+a\s+los\s+productos[^.]{0,160}\.?|"
+    r"revisar?\s+(?:las\s+)?dimensiones\s+permitidas|"
+    r"dimensiones\s+permitidas|"
+    r"c[oó]mo\s+clasifican\s+los\s+productos\s+por\s+tama[nñ]o",
+    re.IGNORECASE)
+
+# hub 上的「待复核商品数」原文（①的证据要素之一）
+_HUB_UNITS_PENDING_RE = re.compile(
+    r"tienes\s+\d+\s+productos?\s+para\s+revisar", re.IGNORECASE)
+
+# hub 上的「前面的任务还没做完」原文（②的判据之一，也是①的证据要素之一）
+_HUB_PRECONDITION_TEXT_RE = re.compile(
+    r"(?:debes\s+)?completar\s+las\s+tareas\s+anteriores[^.]*\.?", re.IGNORECASE)
+
+# 步骤7 旧文案（**③必须逐字保留**⇒ 构造点收敛到这里一处，⛔ 别在编排器里再写一份）
+_STEP7_LEGACY_HEAD = "页面未到箱数填写页：2 轮自愈+重导航后仍未见「Agrupa tu stock」"
+
+
+def normalize_size_tag(tag: Any) -> str:
+    """尺寸标签 → 判据口径（去重音、大写、压缩空白）。⛔ 只做归一化，不做判定。"""
+    return re.sub(r"\s+", " ", _as_text(tag).translate(_ACCENTS)).strip().upper()
+
+
+def size_tag_allowed(tag: Any) -> Optional[bool]:
+    """尺寸标签是否落在**中小件**允许集内 ⇒ `True`/`False`；拿不到标签 ⇒ `None`（判不了）。
+
+    按**词元**匹配（标签可能是「Pequeño y mediano」这类组合写法）；只要出现允许集之外的
+    尺寸词元（如 `EXTRAGRANDE`）就判 `False`。
+    ⛔ 绝不据"没见过的词"猜成允许 —— 本判据的代价不对称：误判成"正常"会把运营挡在门外，
+    误判成"尺寸问题"运营一眼就能核（文案里带 tag 与体积原文）。
+    """
+    tokens = [t for t in re.split(r"[^A-Z0-9]+", normalize_size_tag(tag)) if t]
+    tokens = [t for t in tokens if t not in _SIZE_TAG_STOP]
+    if not tokens:
+        return None
+    return all(t in _SIZE_TAG_ALLOWED for t in tokens)
+
+
+def _empty_units_state(shipment_id: str = "", url: str = "") -> dict:
+    return {
+        "shipment_id": str(shipment_id or ""),
+        "url": url or "",
+        "url_inbound": "",
+        "title": "",
+        "ready_state": "",
+        "body_text": "",
+        "size_dimensions_tag": "",
+        "volume_pill": "",
+        "size_tag_allowed": None,
+        "space_restricted": False,
+        "space_restricted_text": "",
+        "stock_input_present": False,
+        "stock_input_disabled": False,
+        "stock_input_aria": "",
+        "stock_input_value": "",
+        "probe_ok": False,
+        "errors": [],
+    }
+
+
+def parse_units_dump(dump: Any, shipment_id: str = "") -> dict:
+    """units 页 DOM dump（`JS_UNITS_DUMP` 的产物）→ 结构化事实。**从不抛异常**。
+
+    只做**事实登记**（原文/渲染态）与两个**归一化事实**：
+    `size_tag_allowed`（走 `size_tag_allowed()`）与 `space_restricted`（走空间原文正则）。
+    ⛔ 这里**不下结论** —— "该不该判尺寸阻塞"是 `step7_block_verdict()` 的事。
+    """
+    state = _empty_units_state(shipment_id=shipment_id)
+    errors: list = state["errors"]
+
+    data: dict
+    if isinstance(dump, str):
+        try:
+            data = json.loads(dump or "{}")
+        except Exception as exc:                                  # noqa: BLE001
+            errors.append(f"dump-not-json: {type(exc).__name__}: {exc}")
+            data = {}
+    elif isinstance(dump, dict):
+        data = dump
+    else:
+        errors.append(f"dump-type-unexpected: {type(dump).__name__}")
+        data = {}
+    if not isinstance(data, dict):
+        errors.append("dump-not-object")
+        data = {}
+    errors.extend([_as_text(e) for e in (data.get("errors") or []) if e])
+
+    url = _as_text(data.get("url"))
+    state["url"] = url
+    state["title"] = _as_text(data.get("title"))[:300]
+    state["ready_state"] = _as_text(data.get("ready_state"))[:32]
+    body = _as_text(data.get("body_text"))[:MAX_BODY_TEXT]
+    state["body_text"] = body
+
+    m = re.search(r"/inbounds/(\d{6,})/", url)
+    state["url_inbound"] = m.group(1) if m else ""
+    if not state["shipment_id"] and state["url_inbound"]:
+        state["shipment_id"] = state["url_inbound"]
+
+    state["size_dimensions_tag"] = _as_text(data.get("size_dimensions_tag"))[:120]
+    state["volume_pill"] = _as_text(data.get("volume_pill"))[:120]
+    state["size_tag_allowed"] = size_tag_allowed(state["size_dimensions_tag"])
+
+    hit = _SIZE_SPACE_RESTRICTED_RE.search(body)
+    state["space_restricted"] = bool(hit)
+    state["space_restricted_text"] = (hit.group(0)[:200] if hit else "")
+
+    for key in ("stock_input_present", "stock_input_disabled"):
+        state[key] = bool(data.get(key))
+    state["stock_input_aria"] = _as_text(data.get("stock_input_aria"))[:120]
+    state["stock_input_value"] = _as_text(data.get("stock_input_value"))[:40]
+
+    state["probe_ok"] = bool(url or body or state["size_dimensions_tag"] or state["volume_pill"])
+    if not state["probe_ok"]:
+        errors.append("empty-dump（URL/正文/尺寸标签/体积全空 ⇒ 页面可能未加载或探针失效）")
+    return state
+
+
+def _hub_pending_items(hub: Any) -> list:
+    """hub 状态里 `done is False` 的项（**原文**），供②列未完成项。"""
+    if not isinstance(hub, dict):
+        return []
+    out = []
+    for e in (hub.get("items") or []):
+        if isinstance(e, dict) and e.get("done") is False:
+            label = _as_text(e.get("label"))[:160]
+            if label:
+                out.append(label)
+    return out
+
+
+def _coerce_hub(v: Any, shipment_id: str = "") -> Any:
+    """`step7_block_verdict` 的 hub 入参：**已解析状态**直接用，其余（原始 dump/None）就地解析。
+
+    判据是"有没有 `probe_ok` 键"——`parse_hub_dump()` 的产物恒有它（原文 dump 不会有）。
+    ⛔ 解析失败一律返回 `None`（= 证据缺失 ⇒ 走③），不上抛。
+    """
+    if v is None:
+        return None
+    if isinstance(v, dict) and "probe_ok" in v:
+        return v
+    try:
+        return parse_hub_dump(v, shipment_id=shipment_id)
+    except Exception:                                             # noqa: BLE001
+        return None
+
+
+def step7_block_verdict(hub: Any = None, units: Any = None, *,
+                        shipment_id: str = "", url: str = "",
+                        heals: int = 0) -> dict:
+    """步骤7「进不了箱数页」的**只读归因结论**（唯一判据入口；纯函数，可离线回归）。
+
+    `hub` / `units`：`parse_hub_dump()` / `parse_units_dump()` 的产物，**或**原始 dump
+    （str/dict ⇒ 就地解析）；`None` 表示该路探测不可用。`url` = 失败当时所在页 URL；
+    `heals` = 本轮错误弹窗自愈次数（③证据用）。
+
+    返回（**三个结论共用同一形状**，`err_type` 恒 `business` ⇒ ⛔ 探测结果不改变失败码）：
+
+        {"kind": "size-block"|"precondition"|"unattributed",
+         "err_type": "business", "blocking": True,
+         "conclusion_zh": "<一句话结论>", "reason": "<进 failed.reason 的完整文案>",
+         "trace": "<轮次日志一行，<1000 字>", "evidence": {...}, "signals": {...},
+         "probe_ok": bool}
+
+    ⛔ 本函数**只读、零副作用**：不点按钮、不写任何状态、不导航。
+    """
+    hub_state = _coerce_hub(hub, shipment_id)
+    units_state = units if (isinstance(units, dict) and "probe_ok" in units) else None
+    if units_state is None and units is not None:
+        try:
+            units_state = parse_units_dump(units, shipment_id=shipment_id)
+        except Exception:                                         # noqa: BLE001
+            units_state = None
+    if not isinstance(units_state, dict):
+        units_state = None
+
+    # ── 事实登记（一律先取回来，三个结论都要留痕）─────────────────────────────
+    hub_body = _as_text((hub_state or {}).get("body_text"))
+    units_body = _as_text((units_state or {}).get("body_text"))
+    tag = _as_text((units_state or {}).get("size_dimensions_tag")).strip()
+    volume = _as_text((units_state or {}).get("volume_pill")).strip()
+    space_text = _as_text((units_state or {}).get("space_restricted_text")).strip()
+    if not space_text:
+        _hit = _SIZE_SPACE_RESTRICTED_RE.search(units_body)
+        space_text = _hit.group(0) if _hit else ""
+    allowed = (units_state or {}).get("size_tag_allowed")
+    stock_disabled = bool((units_state or {}).get("stock_input_disabled"))
+    pending = _hub_pending_items(hub_state)
+
+    combined_body = f"{hub_body} {units_body}"
+    m_pending = _HUB_UNITS_PENDING_RE.search(combined_body)
+    units_pending_text = m_pending.group(0).strip() if m_pending else ""
+    m_pre = _HUB_PRECONDITION_TEXT_RE.search(combined_body)
+    precondition_text = m_pre.group(0).strip() if m_pre else ""
+
+    probe_ok = bool((hub_state or {}).get("probe_ok")) or bool((units_state or {}).get("probe_ok"))
+    units_page = _as_text((units_state or {}).get("url"))
+    hub_page = _as_text((hub_state or {}).get("url"))
+    # `url` = **失败当时所在页**（③ 的旧文案逐字用它）；`evidence_page` = **证据来自哪一页**
+    # （尺寸/体积在 units 页 ⇒ 证据页优先 units）。两者分开，否则"当时 URL"会被写成隔壁页面。
+    fail_url = url or units_page or hub_page
+    evidence_page = units_page or hub_page or fail_url
+    heals = int(heals or 0)
+
+    evidence = {
+        "url": fail_url,
+        "evidence_page": evidence_page,
+        "heals": heals,
+        "units_url": units_page,
+        "hub_url": hub_page,
+        "size_dimensions_tag": tag,
+        "volume_pill": volume,
+        "size_tag_allowed": allowed,
+        "space_restricted": bool(space_text),
+        "space_restricted_text": space_text,
+        "stock_input_disabled": stock_disabled,
+        "stock_input_value": _as_text((units_state or {}).get("stock_input_value")),
+        "hub_pending_items": pending,
+        "hub_units_pending_text": units_pending_text,
+        "hub_precondition_text": precondition_text,
+        "hub_probe_ok": bool((hub_state or {}).get("probe_ok")),
+        "units_probe_ok": bool((units_state or {}).get("probe_ok")),
+    }
+    signals = {
+        "size_tag_allowed": allowed,
+        "hub_pending_count": len(pending),
+        "space_restricted": bool(space_text),
+        "stock_input_disabled": stock_disabled,
+    }
+
+    # 证据串（三个结论共用；**带 tag/体积/原文**留痕，⛔ 不塞整页文本）
+    ev = {
+        "tag 原文": tag or "（未取到）",
+        "体积原文": volume or "（未取到）",
+        "空间原文": space_text or "（未取到）",
+        "hub「待复核商品」原文": units_pending_text or "（未取到）",
+        "未完成项原文": "；".join(pending) if pending else "（无 done=False 的项）",
+        "hub「前置未完成」原文": precondition_text or "（未取到）",
+        "箱数输入框": ("disabled（平台渲染态）" if stock_disabled
+                     else "（未取到 disabled 渲染态）"),
+        "证据页": evidence_page or "（URL 未取到）",
+    }
+
+    def _evidence_line(*skip: str) -> str:
+        """证据串（`skip` 里的键已进结论主句 ⇒ 不再重复一遍）。"""
+        return "｜".join(f"{k}={v}" for k, v in ev.items() if k not in skip)
+
+    evidence_line = _evidence_line()
+
+    # ── ① 产品尺寸分级阻塞（本批主目标）─────────────────────────────────────
+    if tag and allowed is False:
+        conclusion = (f"该商品被平台判为 **{tag}**"
+                      + (f"（{volume}）" if volume else "")
+                      + "，本货件空间只收**中小件**")
+        reason = (
+            f"⛔ 步骤7 无法进入箱数页：该商品被平台判为 **{tag}**"
+            + (f"（{volume}）" if volume else "")
+            + "，本货件空间只收**中小件** ⇒ 需运营**修正商品包装尺寸**或改走其他渠道；"
+              "脚本侧无解（⛔ 不是门户改版/选择器问题）"
+            + f"｜{evidence_line}"
+        )
+        # 轮次日志与 `reason` **同源同要素**（tag/体积/空间原文/两条 hub 原文/证据页
+        # 一个不少；⛔ 不塞整页文本，见 `_evidence_line()`），风格对齐既有 `_capacity_trace`
+        trace = f"⛔ 归因=尺寸分级阻塞｜{_evidence_line()}"
+        return {
+            "kind": "size-block", "err_type": "business", "blocking": True,
+            "conclusion_zh": conclusion + " ⇒ 需运营修正商品包装尺寸（或改走其他渠道）；脚本侧无解",
+            "reason": reason, "trace": trace[:1000],
+            "evidence": evidence, "signals": signals, "probe_ok": probe_ok,
+        }
+
+    # ── ② 前置未完成（非尺寸类）────────────────────────────────────────────
+    if pending or precondition_text:
+        items_txt = "；".join(pending) if pending else "（hub 未逐项给出，见下方页面原文）"
+        # 未完成项/前置原文已进主句 ⇒ 证据串里不再重复一遍
+        _ev2 = _evidence_line("未完成项原文", "hub「前置未完成」原文")
+        reason = (
+            "⛔ 步骤7 无法进入箱数页：hub 上有**未完成的前置项**（⛔ 不是门户改版/选择器问题）"
+            f"｜未完成项原文={items_txt}"
+            + (f"｜hub「前置未完成」原文={precondition_text}" if precondition_text else "")
+            + " ⇒ 需运营在门户完成这些项后再跑；脚本侧无解"
+            + f"｜{_ev2}"
+        )
+        # 同①：轮次日志带全**证据要素**（tag/体积/空间原文/hub 原文/证据页；缺的写"（未取到）"）
+        trace = f"⛔ 归因=前置未完成｜{_evidence_line()}"
+        return {
+            "kind": "precondition", "err_type": "business", "blocking": True,
+            "conclusion_zh": "需运营在门户完成未完成的前置项后再跑；脚本侧无解",
+            "reason": reason, "trace": trace[:1000],
+            "evidence": evidence, "signals": signals, "probe_ok": probe_ok,
+        }
+
+    # ── ③ 都不是 ⇒ **逐字保留旧文案** + 补一句证据（供 ml-dev 排查门户改版）──
+    legacy = (_STEP7_LEGACY_HEAD + f"｜{fail_url}"
+              + (f"｜现场为 ML 错误弹窗（Algo salió mal）且已自愈 {heals} 次并退避"
+                 f" ⇒ **平台侧**，不是业务缺数据" if heals else ""))
+    reason = (legacy
+              + "｜归因探测（只读）未命中：`Agrupa tu stock` 缺失"
+                f" + 当时 URL={fail_url or '（URL 未取到）'} + 自愈轮数={heals}"
+                " ⇒ 疑似门户改版，供 ml-dev 排查选择器"
+                + f"｜探测事实：{evidence_line}")
+    trace = (f"归因=未命中（疑似门户改版）｜`Agrupa tu stock` 缺失"
+             f"｜当时 URL={fail_url or '（URL 未取到）'}｜自愈轮数={heals}"
+             f"｜探测事实={evidence_line}")
+    return {
+        "kind": "unattributed", "err_type": "business", "blocking": True,
+        "conclusion_zh": "疑似门户改版（选择器/入口缺失）；归因探测未命中尺寸分级或前置未完成",
+        "reason": reason, "trace": trace[:1000],
+        "evidence": evidence, "signals": signals, "probe_ok": probe_ok,
+    }
+
+
+def _tri(v: Any) -> str:
+    return "是" if v is True else ("否" if v is False else "判不了")
+
+
+def item_lines(state: dict) -> list[str]:
+    """逐项一行（`中文项名「页面原文标签」=已完成/未完成/判不了`）。
+
+    供日志/备注/failures.jsonl **复用同源同文**。中文项名只为**运营可读**（用户明确要求
+    「一段运营可读话术」）；括号里恒为**页面原文**，⛔ 不改写、不翻译。
+    """
+    out = []
+    for e in state.get("items") or []:
+        label = _as_text(e.get("label"))[:60]
+        d = e.get("done")
+        mark = "已完成" if d is True else ("未完成" if d is False else "判不了")
+        key = _KEY_ZH.get(e.get("key") or "") or "未知项"
+        out.append(f"{key}「{label}」={mark}")
+    return out
+
+
+# 已知项的**中文显示名**（仅用于人读的摘要；判据仍是 key，⛔ 与识别无关）
+_KEY_ZH: dict[str, str] = {
+    KEY_PREPARE: "货件准备",
+    KEY_APPOINTMENT: "预约",
+    KEY_PACKAGING: "包装确认",
+    KEY_LABELS: "产品标签",
+    KEY_BOX_LABELS: "箱唛",
+}
+
+
+def summary_zh(state: dict) -> str:
+    """一句话中文摘要（供 stderr 日志 / 表备注 / 台账 detail 复用）。"""
+    if not state.get("probe_ok"):
+        err = "；".join(state.get("errors") or [])[:120] or "无证据"
+        return f"hub-v2 探针无有效结果（{err}）"
+    parts = [
+        f"预约{'已取消' if state.get('appointment_cancelled') is True else ('仍有效' if state.get('appointment_cancelled') is False else '判不了')}",
+        f"产品标签{'已下载' if state.get('labels_downloaded') is True else ('未下载' if state.get('labels_downloaded') is False else '判不了')}",
+        f"箱唛{'已下载' if state.get('box_labels_downloaded') is True else ('未下载' if state.get('box_labels_downloaded') is False else '判不了')}",
+    ]
+    tail = "；".join(item_lines(state)[:8])
+    return ("hub-v2 实测：" + "、".join(parts)
+            + (f"（{state.get('shipment_id')}）" if state.get("shipment_id") else "")
+            + (f"｜逐项：{tail}" if tail else ""))
+
+
+def completion_verdict(state: dict) -> dict:
+    """完成度裁定（**确定性规则**，供收口/前置校验/失败现场三处共用）。
+
+    `operationally_complete=True` ⇒ 「识别为运营手动完成（依据 hub-v2 实测）」。
+    ⛔ 本函数**不改任何数据**：它只给结论，写表与否由调用方按各自白名单决定。
+    """
+    ok = bool(state.get("operationally_complete"))
+    return {
+        "operationally_complete": ok,
+        "identified_as": "manual-completion-by-hub" if ok else "",
+        "note_zh": ("识别为运营手动完成（依据 hub-v2 实测）：" + summary_zh(state)) if ok else "",
+        "reason": state.get("complete_reason") or "",
+        "items": item_lines(state),
+        "shipment_id": state.get("shipment_id") or "",
+        "url_inbound": state.get("url_inbound") or "",
+        "probe_ok": bool(state.get("probe_ok")),
+    }
+
+
+# ────────────────────────────────────────────────
+# 内置夹具（纯离线；供 CLI 演示与回归共用判据）
+# ────────────────────────────────────────────────
+
+def _fixture_item(label: str, done: Optional[bool], *, card: str = "hub--card",
+                  testid: str = "link-fixture",
+                  completed: Optional[bool] = None) -> dict:
+    """夹具条目：`label` + **真机形态的卡片 html**（`hub--card` + `data-testid`）。
+
+    ⚠️ 2026-10-09 真机校准：html 必须带卡片根标记 —— 判据的**第 0 步**（残缺闸门）要
+    区分"预约区域没渲染"与"渲染了但判不了"；旧夹具的 `<div>{label}</div>` 在真机上
+    不存在，会把残缺闸门喂成假阳性。
+    """
+    comp = " andes-card--completed" if (completed is True or (completed is None and done is True)) else ""
+    info: dict = {
+        "label": label,
+        "html": (f'<div class="tour__fixture {card} " data-testid="{testid}" role="button" '
+                 f'tabindex="0"><div class="andes-card{comp} andes-card--flat '
+                 f'andes-card--primary andes-card--padding-0"><div class="andes-card__content">'
+                 f'<span class="hub--card__content-summary-title">{label}</span>'
+                 f'</div></div></div>'),
+        "data_testid": testid,
+        "card_completed_class": bool(comp),
+        # v2 证据字段：与 class 命中**同义**（真机探针会同时给出这两者）
+        "done_class_hits": (["andes-card--completed"] if (completed is True
+                                                          or (completed is None and done is True))
+                            else []),
+        "todo_class_hits": [],
+    }
+    if done is True:
+        info["aria_checked"] = True
+    elif done is False:
+        info["has_todo_button"] = True
+    return info
+
+
+FIXTURES: dict[str, dict] = {
+    # ① 全勾选 + 预约取消（= 现场 79096447 的形态）
+    "all-done": {
+        "url": hub_url("79096447", FIXTURE_BASE_URL),
+        "title": "Envío #79096447",
+        "h1": "Envío #79096447",
+        "ready_state": "complete",
+        "body_text": ("Ir a Gestión de envíos Full Cómo preparar tu envío Envío #79096447 "
+                      "Preparación del envío Elige cómo y cuándo vas a enviar tus productos "
+                      "Reserva cancelada Revisa la preparación y reglamentación de tus productos "
+                      "Descarga las etiquetas para tus productos Descarga las etiquetas de tus bultos"),
+        "cancel_button_present": False,
+        "items": [
+            _fixture_item("Preparación del envío Completado", True),
+            _fixture_item("Elige cómo y cuándo vas a enviar tus productos Reserva cancelada", True),
+            _fixture_item("Revisa la preparación y reglamentación de tus productos Completado", True),
+            _fixture_item("Descarga las etiquetas para tus productos Completado", True),
+            _fixture_item("Descarga las etiquetas de tus bultos Completado", True),
+        ],
+    },
+    # ② 缺箱唛（预约已取消、标签已下载、箱唛仍待下载）
+    "missing-box": {
+        "url": hub_url("79096447", FIXTURE_BASE_URL),
+        "h1": "Envío #79096447",
+        "body_text": ("Preparación del envío Reserva cancelada Revisa la preparación "
+                      "Descarga las etiquetas para tus productos Descargar etiquetas"),
+        "cancel_button_present": False,
+        "items": [
+            _fixture_item("Preparación del envío Completado", True),
+            _fixture_item("Elige cómo y cuándo vas a enviar tus productos Reserva cancelada", True),
+            _fixture_item("Revisa la preparación Completado", True),
+            _fixture_item("Descarga las etiquetas para tus productos Completado", True),
+            _fixture_item("Descarga las etiquetas de tus bultos Descargar etiquetas", False),
+        ],
+    },
+    # ③ 改版结构：全是不认识的项，零完成标记（保守 ⇒ 判不了/未完成）
+    "revamp-unknown": {
+        "url": hub_url("79096447", FIXTURE_BASE_URL),
+        "h1": "Envío #79096447",
+        "body_text": "Nueva interfaz de preparación de envíos",
+        "items": [
+            {"label": "Paso alpha", "html": "<div class='x'>Paso alpha</div>"},
+            {"label": "Paso beta", "html": "<div class='y'>Paso beta</div>"},
+        ],
+    },
+    # ④ 空 dump（探针失效）
+    "empty": {},
+    # ── ⑤~⑧ 真机校准新增（2026-10-09）：四条**负样本**，全部"宁可不判也不误判完成" ──
+    # ⑤ 预约**仍活着**：取消按钮还在 ⇒ 必须 false（按钮反证压过一切正证据）。
+    #    形态 = 真机样本原样 + 只把 `cancel_button_present` 翻成 True + 正文补回预约文案。
+    "appointment-alive": {
+        "url": hub_url("12345678", FIXTURE_BASE_URL),
+        "h1": "Preparación del envío",
+        "body_text": ("Preparación del envío Elige cómo y cuándo vas a enviar tus productos "
+                      "Cita: lunes 13 de octubre Cancelar reserva"),
+        "cancel_button_present": True,
+        "items": [
+            _fixture_item("Vas a enviar 9 unidades Descargar listado Editar", True,
+                          testid="link-units"),
+            _fixture_item("Elige cómo y cuándo vas a enviar tus productos", True,
+                          testid="link-appointment"),
+            _fixture_item("Revisaste la preparación y reglamentación de tus productos Editar",
+                          True, testid="link-procedures"),
+            _fixture_item("Descargaste las etiquetas para todos tus productos Descargar listado",
+                          True, testid="link-identifiers"),
+            _fixture_item("Preparaste e identificaste 3 bultos Revisar", True,
+                          testid="link-volumes"),
+        ],
+    },
+    # ⑥ 预约**从未预约**（环节没结束、也没有取消按钮）⇒ 判不了，⛔ 绝不当成"已取消"。
+    #    这是组合判据的**关键护栏**：只看"没有取消按钮"会把它误判成完成。
+    "appointment-not-concluded": {
+        "url": hub_url("12345678", FIXTURE_BASE_URL),
+        "h1": "Preparación del envío",
+        "body_text": ("Preparación del envío Elige cómo y cuándo vas a enviar tus productos "
+                      "Revisaste la preparación y reglamentación de tus productos "
+                      "Descargaste las etiquetas para todos tus productos"),
+        "cancel_button_present": False,
+        "items": [
+            _fixture_item("Vas a enviar 9 unidades Descargar listado Editar", True,
+                          testid="link-units"),
+            _fixture_item("Elige cómo y cuándo vas a enviar tus productos", None,
+                          testid="link-appointment"),
+            _fixture_item("Revisaste la preparación y reglamentación de tus productos Editar",
+                          True, testid="link-procedures"),
+            _fixture_item("Descargaste las etiquetas para todos tus productos Descargar listado",
+                          True, testid="link-identifiers"),
+            _fixture_item("Preparaste e identificaste 3 bultos Revisar", True,
+                          testid="link-volumes"),
+        ],
+    },
+    # ⑦ 页面残缺：预约区域**整个没渲染**（被渲染残缺卡顶替）⇒ 判不了、⛔ 不算完成
+    #    （真机上那段 `Algo salió mal...No pudimos mostrar la información`）
+    "page-broken": {
+        "url": hub_url("12345678", FIXTURE_BASE_URL),
+        "h1": "Preparación del envío",
+        "body_text": ("Preparación del envío Descargaste las etiquetas para todos tus productos "
+                      "Algo salió mal"),
+        "cancel_button_present": False,
+        "error_cards": [{"label": ("Algo salió mal...No pudimos mostrar la información. "
+                                   "Prueba recargando la página.Recargar página"),
+                         "classes": "seller-monitor__error-card"}],
+        "items": [
+            _fixture_item("Vas a enviar 9 unidades Descargar listado Editar", True,
+                          testid="link-units"),
+            {"label": ("Algo salió mal...No pudimos mostrar la información. "
+                       "Prueba recargando la página.Recargar página"),
+             "html": ('<div class="seller-monitor__error-card"><span>Algo salió mal...'
+                      'No pudimos mostrar la información.</span></div>')},
+            _fixture_item("Descargaste las etiquetas para todos tus productos Descargar listado",
+                          True, testid="link-identifiers"),
+            _fixture_item("Preparaste e identificaste 3 bultos Revisar", True,
+                          testid="link-volumes"),
+        ],
+    },
+    # ⑧ 预约项在，但**卡片本身没渲染**（html 空）⇒ 判不了、⛔ 不算完成
+    "appointment-card-blank": {
+        "url": hub_url("12345678", FIXTURE_BASE_URL),
+        "h1": "Preparación del envío",
+        "body_text": "Elige cómo y cuándo vas a enviar tus productos",
+        "cancel_button_present": False,
+        "items": [
+            _fixture_item("Vas a enviar 9 unidades Descargar listado Editar", True,
+                          testid="link-units"),
+            {"label": "Elige cómo y cuándo vas a enviar tus productos", "html": ""},
+            _fixture_item("Descargaste las etiquetas para todos tus productos Descargar listado",
+                          True, testid="link-identifiers"),
+            _fixture_item("Preparaste e identificaste 3 bultos Revisar", True,
+                          testid="link-volumes"),
+        ],
+    },
+}
+
+# ── 文件夹具（体积大/由真机 dump 脱敏而来，⛔ 原始生产 dump 绝不进仓库）──────────────
+# `real-anon`：真机样本（货件 79096447，运营已手动完成）**脱敏**后的逐项 DOM 证据。
+# 脱敏口径：货件号/数量/箱数/标题一律换占位符 ⇒ **只保留结构与信号**。
+FIXTURE_DIR = pathlib.Path(__file__).resolve().parent / "tests" / "fixtures"
+FIXTURE_FILES: dict[str, str] = {"real-anon": "hub-v2-real-anon.json"}
+
+
+def load_fixture(name: str) -> dict:
+    """取夹具（内置 dict 或文件夹具）。⛔ 文件缺失时**响亮失败**，不静默退化成空 dump。"""
+    if name in FIXTURES:
+        return dict(FIXTURES[name])
+    fname = FIXTURE_FILES.get(name)
+    if not fname:
+        raise KeyError(f"未知夹具：{name}")
+    path = FIXTURE_DIR / fname
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def fixture_names() -> list[str]:
+    return sorted(list(FIXTURES) + list(FIXTURE_FILES))
+
+
+def _main(argv: Optional[list[str]] = None) -> int:
+    p = argparse.ArgumentParser(
+        prog="ml_hub_status.py",
+        description="hub-v2 货件真实状态：纯解析器（离线；真机抓取用 orchestrator --mode hub-status）")
+    src = p.add_mutually_exclusive_group(required=True)
+    src.add_argument("--dump-file", help="DOM dump JSON 文件（`-` = 从 stdin 读）")
+    src.add_argument("--fixture", choices=fixture_names(), help="跑内置/文件夹具")
+    p.add_argument("--shipment-id", default="", help="货件号（dump 里没有时用于回填）")
+    p.add_argument("--list-status", default="",
+                   help="列表页/表里的粗粒度状态原文（**可选**：只能否决组合判据或佐证留痕）")
+    p.add_argument("--json", action="store_true", help="输出完整 JSON（默认：中文摘要 + 裁定）")
+    args = p.parse_args(argv)
+
+    if args.fixture:
+        try:
+            dump: Any = load_fixture(args.fixture)
+        except (KeyError, OSError) as exc:
+            print(f"⛔ 取不到夹具 {args.fixture}：{exc}", file=sys.stderr)
+            return 2
+    elif args.dump_file == "-":
+        dump = sys.stdin.read()
+    else:
+        try:
+            dump = open(args.dump_file, encoding="utf-8").read()
+        except OSError as exc:
+            print(f"⛔ 读不到 dump 文件：{exc}", file=sys.stderr)
+            return 2
+
+    state = parse_hub_dump(dump, shipment_id=args.shipment_id, list_status=args.list_status)
+    verdict = completion_verdict(state)
+    if args.json:
+        print(json.dumps({"hub": state, "verdict": verdict}, ensure_ascii=False, indent=2))
+    else:
+        print(summary_zh(state))
+        print(("✅ " if verdict["operationally_complete"] else "⛔ ") + verdict["reason"])
+        for line in verdict["items"]:
+            print(f"  · {line}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(_main())