feat(check): 响应方式识别（C12）和「这条要不要投标人回答」；评测集纠错

- checklist/response_mode.py：按类别（技术 / 商务）识别招标文件的响应方式（逐条响应 / 默认接受），规则优先；
  两种写法冲突按逐条，认不出按逐条并写进覆盖范围。
- check/applicability.py：无效情形（★ / 斜体下划线标注的条款除外）、日期与递交、没要求附材料的评分标准、
  无需提供证明或由采购人查询的资格，不逐条找响应，写进覆盖范围；要求附证明材料按原文判断，中标后才交的不算。
- 默认接受的要求没找到响应：一般要求记 implicit_accepted、不出问题；实质性要求记 implicit_review、提示级
  人工核对；要附证明材料的不免（迁移 0006）。
- match.py：修同一行单元格又是别的条目候选句时的 KeyError（每条清单项单独记候选句，句子从总表里查）。
- 评测集：注入器同一要求的所有表格行一起改；散文、附件、格式文件里也响应了的要求不挂漏响应类问题；
  错位响应必须是另一个参数；复核判不成立的单元不再挂；regen.py 按固定种子重新生成。

开发集 17 份：规矩投标文件报出的问题 639 → 229，误报 21.3 → 12.4 / 100，召回 68% → 65%，致命级 20 → 21 / 32
（docs/architecture/check-eval.md §4）。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

AGENTS.md

@@ -211,4 +211,5 @@ samples/
 - 2026-11-04：查标评测开发集第一版：7 份招标文件、14 份投标文件（风格 A / B 轮换），注入问题 222 个、Fable 复核通过 188 个。查标召回 40%（致命级 49%），带标志词的问题只有 22%；规矩投标文件报出 699 个问题，近一半在不需要响应的要求上（`docs/architecture/check-eval.md` §2）。
 - 2026-11-04：用户抽查第二批复核 28 条，全部同意（两批合计 45 条）。
 - 2026-11-04：查标第一轮改进：候选句带同一行的单元格、提示词 check.match v2。开发集 17 份上召回 30% → 50%，带标志词的问题 2% → 54%，误报略降，输入 token +44%；漏响应和响应对象错位变差（`docs/architecture/check-eval.md` §3）。评测集修了待修项、加了 3 份低密度投标文件，第三批复核 55 条、用户抽查 11 条全部同意。
-- 下一步：看 D01、D09 的漏报明细改提示词；查标第 2 步（响应方式 C12、投标侧结构识别、规则）。
+- 2026-11-04：查标第二轮：评测集纠错（漏响应、错位的「变差」多是生成器只改了一处）；新增响应方式识别（C12，规则优先）和「这条要不要投标人回答」的判断。开发集 17 份上规矩投标文件报出的问题 639 → 229，误报 21.3 → 12.4 / 100，召回 68% → 65%，致命级 20 → 21 / 32；证明材料缺失几乎查不出（扫描件）。第四批复核 45 条，用户抽查 9 条全部同意（四批共 65 条）。见 `docs/architecture/check-eval.md` §4。
+- 下一步：扫描件兜底和文件要在（C10）；响应方式存进清单并可改；查标第 2 步的投标侧结构识别和规则。

docs/architecture/check-eval.md

@@ -103,8 +103,34 @@
 
 **读法**：整行上下文解决了「看不见响应格、偏离格」的问题，带标志词的问题从几乎查不出到过半；误报略降。代价是输入 token 多 44%。**两处变差**：漏响应（D01）和响应对象错位（D09）。推测是同一行或相邻行的内容让模型更容易「找到点什么就判已响应」：漏掉的那一行不在了，检索命中的是相邻要求的行；错位的那一行响应格写的是另一条参数，模型没比对参数名。下一轮在提示词里要求先核对响应格说的是不是同一个参数 / 设备，并单独看 D01、D09 的漏报明细。不需要响应的要求上的误报（329）没有变化，要靠第 ② 项（C12）。
 
-## 4. 下一步
+## 4. 第二轮：评测集纠错 + 响应方式和「要不要回答」（2026-11-04）
 
-1. 看 D01、D09 的漏报明细，改提示词（v3）：先核对响应格说的是不是同一个参数 / 设备。
-2. 第 2 步（投标侧结构识别、规则、C12 响应方式抽取）和第 3 步（整行上下文、偏离表直取、presence 判断）按 §2.2 的顺序改，每改一轮在开发集 14 份上重跑对比。
+**评测集纠错**：§3 里漏响应、响应对象错位「变差」，逐条看漏报后发现多数是**生成器的错**，不是查标的错：读标清单有重复条目、S04 同一参数列在两张表里、技术方案散文也复述了要求，注入器只改了其中一处，别处还留着正确的响应，模型找到它是对的。改为同一要求的所有表格行一起改；在散文、附件、格式文件里也响应了的要求不挂漏响应 / 数值不满足 / 错位；错位响应必须是另一个参数的。马虎的投标文件按原种子重新生成，新目标 45 个由 Fable 复核（通过 40 个），用户抽查 9 个全部同意（四批合计抽查 65 个，全部同意）。
+
+**查标改了什么**（第 2 步的 C12 部分）：
+- `checklist/response_mode.py`：按类别（技术 / 商务）识别招标文件的响应方式，规则优先；冲突按逐条，认不出按逐条并标明。开发集 7 份的识别结果和档案一致。（还没存进清单、没做清单页的显示和修改。）
+- `check/applicability.py`：不需要投标人回答的条目不逐条找响应，写进覆盖范围（无效情形 —— 但 ★ / 斜体下划线标注的条款照常找、日期与递交、没要求附材料的评分标准、无需提供证明或由采购人查询的资格）。要求附证明材料按原文判断（读标的 evidence_required 常常是空的），中标后才交的不算。
+- 默认接受的要求没找到响应：一般要求记「按招标文件默认接受」、不出问题；实质性要求出提示级「请人工核对」；要附证明材料的不免（迁移 0006 加了两种结论）。
+
+| 指标（17 份，复核通过的问题） | v1 | v2 + 整行 | + 响应方式和「要不要回答」 |
+|---|---|---|---|
+| 查标召回 | 48 / 150（32%） | 102 / 150（68%） | 97 / 150（65%） |
+| 致命级召回 | 9 / 32 | 20 / 32 | **21 / 32** |
+| 规矩的投标文件报出的问题 | 699 | 639 | **229** |
+| 规矩响应的要求上的误报 | 24.7 / 100 | 21.3 / 100 | **12.4 / 100** |
+| 不需要响应的要求上报的问题 | 334 | 329 | **77** |
+| 默认接受的要求被报（T06） | 39 | 35 | **1** |
+| 输入 token | 189 万 | 273 万 | 224 万 |
+
+按问题类型（最后一列）：漏响应 19 / 24、写明不支持 13 / 14、数值不满足 4 / 4、负偏离未说明 39 / 59、评分材料缺失 9 / 14、错位 6 / 13；**证明材料缺失 1 / 17**。
+
+**读法**：规矩的投标文件上的问题少了三分之二，召回只掉了 3 个点（掉的主要是只在默认接受的文件里、被正确判为「默认接受」的条目，以及证明材料）。证明材料缺失几乎查不出：资格证明、检测报告多是扫描件页，没有文字层，规矩的投标文件上同样报「未找到」——这是下一项（C10 扫描件兜底 + 文件要在的判断）。
+
+**一处要说明的**：调响应方式识别时，打印结果里顺带出现了留出集 S03、S06、S09（招标文件本身，不是投标文件）的识别结果，其中 S03、S09 和规范 §2 的记录不一致。没有据此改任何规则，留到留出集正式评测时再看。
+
+## 5. 下一步
+
+1. 证明材料和格式文件：扫描件兜底（C10）、文件要在（presence）按文件在不在判断。
+2. 响应方式存进清单、清单页显示并可改（C12 的人工确认点）。
+3. 第 2 步（投标侧结构识别、规则、C12 响应方式抽取）和第 3 步（整行上下文、偏离表直取、presence 判断）按 §2.2 的顺序改，每改一轮在开发集 14 份上重跑对比。
 3. 留出集（S03、S06、S09，风格 B + C，封存的词库）和真实国动投标文件，在第 3 步冻结代码后只跑一次。

evals/check/GUIDELINES.md

@@ -9,7 +9,7 @@
 1. 没有真实投标文件（真实的国动投标文件只有一份，留作最终检验，见 §4），所以按 S01–S10 的真实招标文件**自己造虚构的投标文件**。
 2. **规矩的投标文件靠构造保证，不靠复核**：偏离表、响应表、报价表、资格和评分材料清单由脚本从清单生成，技术参数按 `op / value / unit` 算一个满足的值；LLM 只写散文（技术方案、投标函叙述）和按风格改写表格行（截断、同义替换、重新编号），逐行小提示，不整本生成。
 3. 投标文件对招标文件的**全部要求**响应：「全集」用读标正式清单（`evals/out/runs/fix3/<ID>/items.json`），按「招标侧页码 + 片段」记，不只响应标注集的单元。
-4. 再用确定性的脚本往里**注入问题**得到马虎的投标文件。注入了什么、注在哪里，脚本同时写进**响应清单**，它就是金标准。**问题只挂在人工复核过的标注单元上**（`evals/gold/<ID>.json`，优先实质性条款和资格条件）；`optional` 和复核时补的单元不挂问题。
+4. 再用确定性的脚本往里**注入问题**得到马虎的投标文件。注入了什么、注在哪里，脚本同时写进**响应清单**，它就是金标准。**问题只挂在复核过的标注单元上**（`evals/gold/<ID>.json`，优先实质性条款和资格条件；复核方式见决策 E1）。`optional` 和复核时补的单元也可以挂，按内容复核（四批复核和用户抽查都是这样做的）；**上一次复核判为不成立的单元不再挂问题**。
 5. 评分只对照响应清单，不用检索、偏离表对齐这些查标自己的逻辑来判断对错。
 
 ## 2. 每条要求怎么才算「响应了」：响应方式

evals/check/mutate.py

@@ -41,10 +41,18 @@ UNIT_DOWN = {"TB": ("GB", 1024), "GB": ("MB", 1024), "Gbps": ("Mbps", 1000), "s"
 class Mutator:
     def __init__(self, spec: dict[str, Any], vocab: dict[str, Any], rng: random.Random) -> None:
         self.spec, self.vocab, self.rng = spec, vocab, rng
+        self.vols = spec["volumes"]
         self.unit_defects: dict[str, dict[str, Any]] = {}
         self.rule_defects: list[dict[str, Any]] = []
         self.umbrella: set[str] = set()
-        self.vols = spec["volumes"]
+        self.rejected: set[str] = set()  # 以前复核判为不成立的单元（同一招标文件的任何投标文件里），不再挂问题
+        # 在表格以外（技术方案散文、附件、格式文件）也响应了的单元：删表格行、改响应值都不构成问题，不挂这几类
+        self.prose = [
+            {t[i : i + 2] for t in [re.sub(r"\W", "", b["text"])] for i in range(len(t) - 1)}
+            for b in self.blocks
+            if b.get("type") == "para" and b.get("form") == "prose"
+        ]
+        self.elsewhere = {u for b in self.blocks if b.get("type") != "table" for u in b.get("responds") or []}
 
     @property
     def blocks(self) -> list[dict[str, Any]]:
@@ -80,7 +88,7 @@ class Mutator:
         return out
 
     def free(self, units: list[str]) -> bool:
-        return bool(units) and not any(u in self.unit_defects for u in units)
+        return bool(units) and not any(u in self.unit_defects or u in self.rejected for u in units)
 
     def mark(
         self, units: list[str], defect: str, variant: str, granularity: str = "single", worded: bool = True
@@ -103,10 +111,11 @@ class Mutator:
             chunk = rows[start : start + n]
             if not all(self.free(r.get("responds") or []) for r in chunk if r.get("responds")):
                 continue
+            if any(set(r.get("responds") or []) & self.elsewhere for r in chunk):
+                continue
             for r in chunk:
                 self.mark(r.get("responds") or [], "D01", "删连续一段", "block", worded=False)
-            del rows[start : start + n]
-            self.drop_everywhere([u for r in chunk for u in r.get("responds") or []])
+            self.drop_everywhere([u for r in chunk for u in r.get("responds") or []], [(t, r) for r in chunk])
             return
 
     def row_ops(self, n: int) -> None:
@@ -126,10 +135,43 @@ class Mutator:
                     done += 1
                     break
 
-    def drop_everywhere(self, units: list[str]) -> None:
-        """漏响应要在所有表里都漏：S04 的技术参数同时列在全量偏离表和 ★ 表里，只删一张表等于没漏。"""
+    def in_prose(self, text: str) -> bool:
+        """技术方案散文里基本复述了这条要求（字 2-gram 有六成以上出现在同一段里）：表格里删掉或改错，散文里还在响应。"""
+        t = re.sub(r"\W", "", text)
+        grams = {t[i : i + 2] for i in range(len(t) - 1)}
+        return len(grams) >= 6 and any(len(grams & g) / len(grams) >= 0.6 for g in self.prose)
+
+    def _req_text(self, t: dict[str, Any], r: dict[str, Any]) -> str:
+        at = self.col(t, "requirement")
+        return re.sub(r"\W", "", r["cells"][at]) if at is not None else ""
+
+    def siblings(self, t: dict[str, Any], r: dict[str, Any]) -> list[tuple[dict[str, Any], dict[str, Any]]]:
+        """同一条要求在投标文件里的所有表格行：挂同一个标注单元，或者要求原文相同（读标清单常把同一要求抽成几条，
+        S04 的参数同时列在两张表里）。注入的问题要在这些行上一起做，否则别处还留着正确的响应，就不是问题了。"""
+        units, text = set(r.get("responds") or []), self._req_text(t, r)
+        out = []
+        for t2 in self.tables():
+            for r2 in t2["rows"]:
+                if r2 is r:
+                    continue
+                if units & set(r2.get("responds") or []) or (len(text) >= 6 and self._req_text(t2, r2) == text):
+                    out.append((t2, r2))
+        return out
+
+    def propagate(self, t: dict[str, Any], r: dict[str, Any]) -> None:
+        """把这一行改过的响应、偏离、说明照样写到同一要求的其他行上。"""
+        for t2, r2 in self.siblings(t, r):
+            for field in ("answer", "deviation", "note"):
+                a, b = self.col(t, field), self.col(t2, field)
+                if a is not None and b is not None:
+                    r2["cells"][b] = r["cells"][a]
+
+    def drop_everywhere(self, units: list[str], rows: list[tuple[dict[str, Any], dict[str, Any]]] = ()) -> None:
+        """漏响应要在所有表里都漏：S04 的技术参数同时列在全量偏离表和 ★ 表里，只删一张表等于没漏；
+        要求原文相同的重复行也一起删。"""
+        drop = {id(r2) for t, r in rows for _, r2 in self.siblings(t, r)} | {id(r) for _, r in rows}
         for t in self.tables():
-            t["rows"] = [r for r in t["rows"] if not set(r.get("responds") or []) & set(units)]
+            t["rows"] = [r for r in t["rows"] if id(r) not in drop and not set(r.get("responds") or []) & set(units)]
 
     @staticmethod
     def col(t: dict[str, Any], field: str) -> int | None:
@@ -148,12 +190,14 @@ class Mutator:
         numeric = tp.get("op") in (">=", "<=", "=") and tp.get("value")
         if op == "D05" and (numeric or not FUNCTIONAL.search(req_text) or NON_FUNCTIONAL.search(req_text)):
             return False  # 「暂不支持」只套在功能类要求上（数值参数、证书、清单、服务义务不会这么写）
+        if op in ("D01", "D03", "D08", "D09") and (set(units) & self.elsewhere or self.in_prose(req_text)):
+            return False
         if op == "D01":
-            t["rows"].remove(r)
-            self.drop_everywhere(units)
+            self.drop_everywhere(units, [(t, r)])
             self.mark(units, "D01", "删一行", worded=False)
         elif op == "D03":
-            return self._unmet(r, tp, ans, dev)
+            if not self._unmet(r, tp, ans, dev):
+                return False
         elif op == "D05":
             param = tp.get("param") or (r["cells"][req][:12] if req is not None else "该功能")
             r["cells"][ans] = self.phrase("D05", "phrases").format(param=param)
@@ -171,11 +215,14 @@ class Mutator:
             r["cells"][ans] = self.phrase("D08", "phrases")
             self.mark(units, "D08", r["cells"][ans], worded=False)
         elif op == "D09":
+            mine = str(tp.get("param") or "")
             others = [
                 x
                 for _, x in cands
                 if x is not r
                 and (x.get("tp") or {}).get("param")
+                and x["tp"]["param"] != mine  # 必须是另一个参数：同名参数（另一台设备的同一指标）的响应可能恰好满足
+                and (not mine or mine not in x["cells"][x.get("anchor", ans)])
                 and x["cells"][x.get("anchor", ans)] != r["cells"][ans]
             ]
             if not others:
@@ -183,6 +230,8 @@ class Mutator:
             o = self.rng.choice(others)
             r["cells"][ans] = o["cells"][o.get("anchor", ans)]
             self.mark(units, "D09", "另一条参数的响应", worded=False)
+        if op != "D01":
+            self.propagate(t, r)
         return True
 
     def _unmet(self, r: dict[str, Any], tp: dict[str, Any], ans: int, dev: int | None) -> bool:
@@ -205,7 +254,7 @@ class Mutator:
         if dev is not None and self.rng.random() < 0.5:
             r["cells"][dev] = "无偏离"  # 一半在偏离栏仍写「无偏离」（另一半保持原样，也是无偏离或正偏离）
         self.mark(r.get("responds") or [], "D03", variant, worded=False)
-        return True
+        return True  # 同一要求的其他行由调用方（_apply）同步
 
     def implicit_deviation(self, n: int) -> None:
         """只列偏离的表：挑默认接受的要求写成偏离（D06 负偏离未说明 / D05 写明不支持）。"""
@@ -421,6 +470,10 @@ def main() -> None:
     optional = {u.id for u in units if u.optional}
     modes = unit_modes(spec)  # 注入前算：被删掉的行也要知道它本来该怎么响应
     m = Mutator(spec, json.loads(VOCAB[a.split].read_text()), random.Random(a.seed))  # noqa: S311 评测数据，不用于安全
+    for f in OUT.glob(f"{tender}-*/manifest.json"):
+        for uid, e in json.loads(f.read_text())["units"].items():
+            if (e.get("review") or {}).get("ok") is False:
+                m.rejected.add(uid)  # noqa: S311 评测数据，不用于安全
     if not a.manifest_only:
         if a.density == "high":
             m.d01_block()

evals/check/regen.py

@@ -0,0 +1,91 @@
+"""按固定的种子重新生成开发集的马虎投标文件，沿用复核过的结论（同一招标文件里复核过的「单元 + 问题类型」），
+列出没复核过的新目标（evals/out/check/review/pending-units.json）。
+
+    cd server && ../.venv/bin/python ../evals/check/regen.py
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import subprocess
+import sys
+
+EVALS = pathlib.Path(__file__).resolve().parents[1]
+OUT = EVALS / "out" / "check"
+# （规矩的投标文件，马虎的投标文件，种子，密度）：开发集的固定组合（GUIDELINES §4）
+SLOPPY = [
+    ("S02-B", "S02-B-sloppy", 11, "high"),
+    ("S04-A", "S04-A-sloppy", 7, "high"),
+    ("S10-B", "S10-B-sloppy", 13, "high"),
+    ("S01-A", "S01-A-sloppy", 17, "high"),
+    ("S05-B", "S05-B-sloppy", 23, "high"),
+    ("S07-A", "S07-A-sloppy", 19, "high"),
+    ("S08-B", "S08-B-sloppy", 29, "high"),
+    ("S04-B", "S04-B-low", 31, "low"),
+    ("S08-A", "S08-A-low", 37, "low"),
+    ("S10-A", "S10-A-low", 41, "low"),
+]
+
+
+def reviews(tender: str) -> dict[tuple[str, str], dict]:
+    out = {}
+    for f in OUT.glob(f"{tender}-*/manifest.json"):
+        for uid, e in json.loads(f.read_text())["units"].items():
+            if e.get("review") and e.get("expect") == "defect":
+                out[(uid, e["defect"])] = {k: v for k, v in e["review"].items() if k != "user_spot_check"}
+    return out
+
+
+def main() -> None:
+    prior = {t: reviews(t) for t in {c[:3] for c, *_ in SLOPPY}}
+    pending = []
+    for clean, sloppy, seed, density in SLOPPY:
+        tender = clean[:3]
+        cmd = [
+            sys.executable,
+            str(EVALS / "check" / "mutate.py"),
+            clean,
+            sloppy,
+            "--split",
+            "dev",
+            "--seed",
+            str(seed),
+            "--density",
+            density,
+        ]
+        print(subprocess.run(cmd, capture_output=True, text=True, check=True).stdout.strip())
+        p = OUT / sloppy / "manifest.json"
+        m = json.loads(p.read_text())
+        gold = {x["id"]: x for x in json.loads((EVALS / "gold" / f"{tender}.json").read_text())["items"]}
+        for uid, e in m["units"].items():
+            if e.get("expect") != "defect":
+                continue
+            if e.get("defect") == "D02":
+                e["mode"] = "evidence"
+            r = prior[tender].get((uid, e["defect"]))
+            if r:
+                e["reviewed"], e["review"] = r["ok"], r
+            else:
+                x = gold[uid]
+                pending.append(
+                    {
+                        "bid": sloppy,
+                        "tender": tender,
+                        "unit": uid,
+                        "cat": e["cat"],
+                        "basis": x.get("basis"),
+                        "anchors": x.get("anchors"),
+                        "note": x.get("note"),
+                        "mode": e["mode"],
+                        "defect": e["defect"],
+                        "variant": e.get("variant"),
+                    }
+                )
+        p.write_text(json.dumps(m, ensure_ascii=False, indent=1))
+    (OUT / "review" / "pending-units.json").write_text(json.dumps(pending, ensure_ascii=False, indent=1))
+    print("待复核的新目标：", len(pending))
+
+
+if __name__ == "__main__":
+    main()

evals/check/run_check.py

@@ -23,7 +23,8 @@ from bid_doctor.ai import prompts
 from bid_doctor.ai import service as ai_service
 from bid_doctor.ai.providers.base import near_limit
 from bid_doctor.ai.service import OutputIncomplete, provider
-from bid_doctor.check import findings, match
+from bid_doctor.check import applicability, findings, match
+from bid_doctor.checklist import response_mode
 from bid_doctor.core.config import get_settings
 from bid_doctor.core.db import TenantContext
 from bid_doctor.document.pipeline import text_layer
@@ -120,6 +121,7 @@ async def main() -> None:
     ap.add_argument("--name", default="base")
     ap.add_argument("--baseline", action="store_true", help="只检索、不调模型的基线")
     ap.add_argument("--v1", action="store_true", help="第 1 步的做法：提示词 v1、不带同一行的单元格（对比基线）")
+    ap.add_argument("--no-modes", action="store_true", help="不按响应方式和「要不要回答」筛选（C12 之前的做法）")
     args = ap.parse_args()
     d = OUT / args.bid
     manifest = json.loads((d / "manifest.json").read_text())
@@ -137,9 +139,34 @@ async def main() -> None:
         return None
 
     ctx = TenantContext(tenant_id=UUID(int=0), user_id=UUID(int=0))
+    all_items = items
+    decisions: dict[UUID, applicability.Decision] = {}
+    if not args.no_modes:
+        modes = response_mode.detect(gold.sentences(manifest["tender"]))
+        decisions = {i: applicability.decide(p, modes) for i, p in items.items()}
+        items = {i: p for i, p in items.items() if decisions[i].match}
     results, stats = await match.run(ctx, uuid4(), items, docs, progress)
+    if decisions:
+        match.apply_modes(results, items, decisions)
     rows = []
-    for item_id, item in items.items():
+    for item_id, item in all_items.items():
+        if item_id not in items:
+            rows.append(
+                {
+                    "title": item["title"],
+                    "sentences": item["sentences"],
+                    "categories": item["categories"],
+                    "importance": item["importance"],
+                    "verdict": f"skipped:{decisions[item_id].skip}",
+                    "layer": None,
+                    "evidence_status": "none",
+                    "reason_code": None,
+                    "evidence": [],
+                    "detail": {},
+                    "finding": None,
+                }
+            )
+            continue
         res = results[item_id]
         spec = findings.spec(res, item)
         rows.append(

server/migrations/versions/0006_check_verdict_implicit.py

@@ -0,0 +1,31 @@
+"""查标结论加「按招标文件默认接受」（决策 C12）。
+
+- implicit_accepted：一般要求，不出问题；
+- implicit_review：实质性要求，提示级人工核对。
+
+Revision ID: 0006
+"""
+
+from __future__ import annotations
+
+from alembic import op
+
+revision = "0006"
+down_revision = "0005"
+
+VERDICTS = "'responded', 'not_found', 'negative_deviation', 'suspected_unmet', 'no_value', 'undetermined', 'scanned'"
+
+
+def upgrade() -> None:
+    op.get_bind().exec_driver_sql(f"""
+ALTER TABLE check_item_result DROP CONSTRAINT check_item_result_verdict_check;
+ALTER TABLE check_item_result ADD CONSTRAINT check_item_result_verdict_check
+  CHECK (verdict IN ({VERDICTS}, 'implicit_accepted', 'implicit_review'));
+""")
+
+
+def downgrade() -> None:
+    op.get_bind().exec_driver_sql(f"""
+ALTER TABLE check_item_result DROP CONSTRAINT check_item_result_verdict_check;
+ALTER TABLE check_item_result ADD CONSTRAINT check_item_result_verdict_check CHECK (verdict IN ({VERDICTS}));
+""")

server/src/bid_doctor/check/applicability.py

@@ -0,0 +1,56 @@
+"""每条清单项要不要在投标文件里找响应、按什么响应方式判（决策 C12，`docs/architecture/check-eval.md` §2.2 第 ② 项）。
+
+开发集上规矩的投标文件报出的问题，近一半落在不需要投标人回答的条目上（无效情形的列举、日期、评分标准、
+采购人自己查询的资格）。这些条目不逐条找响应，写进检查覆盖范围：
+- 无效情形、评审规定（只有「无效」类别、不是标注出来的条款）：由规则检查（第 2 步）和人工核对覆盖；
+- 日期与递交：由规则检查（落款日期、有效期）和需人工核对覆盖；
+- 评分标准本身：没写要附什么材料的不找；写了的按证明材料找；
+- 资格条件里写明「无需提供」或由采购人查询（信用中国）的不找。
+其余按类别取招标文件的响应方式：技术参数用技术类，其余用商务类。
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from bid_doctor.checklist.response_mode import Mode
+
+# 要求投标时附证明材料（读标的 evidence_required 常常是空的，按原文判断）；中标后 / 签合同时才交的不算
+EVIDENCE = re.compile(r"(提供|附|出具)[^。；]{0,20}(证明|报告|截图|复印件|扫描件|证书|合同|承诺|声明|社保|发票)")
+AWARD = re.compile(r"(中标后|成交后|签订合同(前|时)|合同签订(前|时))")
+NO_PROOF = re.compile(r"无需提供|不需提供|无须提供|采购人[^。；]{0,12}(查询|核查|查验)|信用中国|信用记录")
+SKIP_LABELS = {
+    "condition": "无效情形和评审规定",
+    "schedule": "日期与递交要求",
+    "scoring": "评分标准（没要求附证明材料）",
+    "no_proof": "资格条件（写明无需提供证明，或由采购人查询）",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Decision:
+    match: bool
+    mode: str = "explicit"  # explicit / implicit
+    skip: str | None = None  # 不找响应的原因（SKIP_LABELS 的键）
+    mode_status: str = "found"
+    evidence: bool = False  # 要求投标时附证明材料：默认接受也不能免（没附就是没附）
+
+
+def decide(item: dict[str, Any], modes: dict[str, Mode]) -> Decision:
+    cats = set(item.get("categories") or [])
+    text = f"{item.get('title') or ''}{item.get('requirement_text') or ''}"
+    if cats == {"invalidity"} and item.get("importance_basis") != "marker":
+        return Decision(False, skip="condition")  # 「……的，投标无效」这类情形；★ / 斜体下划线标注的条款是要求，照常找
+    if "schedule" in cats and not cats & {"tech_param", "qualification", "scoring"}:
+        return Decision(False, skip="schedule")
+    evidence = bool(item.get("evidence_required") or EVIDENCE.search(text)) and not AWARD.search(text)
+    if cats <= {"scoring"} and not evidence:
+        return Decision(False, skip="scoring")
+    if "qualification" in cats and "tech_param" not in cats and NO_PROOF.search(text):
+        return Decision(False, skip="no_proof")
+    mode = modes.get("technical" if "tech_param" in cats else "commercial")
+    if mode is None:
+        return Decision(True, evidence=evidence)
+    return Decision(True, mode=mode.mode, mode_status=mode.status, evidence=evidence)

server/src/bid_doctor/check/findings.py

@@ -52,8 +52,14 @@ def spec(result: Result, item: dict[str, Any]) -> Spec | None:
     name = str(item.get("title") or "")
     base = {"importance_basis": item.get("importance_basis"), **result.detail}
     scope = "、".join(result.detail.get("search_scope") or [])
-    if result.verdict == "responded":
+    if result.verdict in ("responded", "implicit_accepted"):
         return None
+    if result.verdict == "implicit_review":
+        text = (
+            "招标文件规定未列入偏离表的视为接受，投标文件里没有找到对这条要求的明确响应。"
+            "这是实质性要求，请人工核对所投内容确实满足。"
+        )
+        return Spec("manual_review", "hint", f"请人工核对：{name}", text, {**base, "mode": "implicit"})
     if result.verdict == "not_found" and result.evidence_status == "unverified":
         claimed = result.detail.get("claimed_pages") or []
         where = f"{_pages(claimed)}有响应" if claimed else "有响应"

server/src/bid_doctor/check/match.py

@@ -74,6 +74,18 @@ class Stats:
         self.verify_failures[code] = self.verify_failures.get(code, 0) + 1
 
 
+def apply_modes(results: dict[UUID, Result], items: dict[UUID, dict[str, Any]], modes: dict[UUID, Any]) -> None:
+    """按招标文件的响应方式改结论（决策 C12）：默认接受（implicit）的要求没找到响应不算问题，记「按招标文件默认接受」；
+    实质性要求出提示级「请人工核对」，不出致命。找到了不满足的响应照常报。modes：清单项 → applicability.Decision。"""
+    for item_id, d in modes.items():
+        r = results.get(item_id)
+        if r is None or d.mode != "implicit" or r.verdict != "not_found" or d.evidence:
+            continue  # 要附证明材料的要求，默认接受也免不了
+        r.verdict = "implicit_review" if items[item_id].get("importance") == "substantive" else "implicit_accepted"
+        r.evidence_status, r.reason_code = "none", None
+        r.detail = {**r.detail, "mode": "implicit"}
+
+
 def short_sid(doc: BidDoc, s: Sentence) -> str:
     return f"d{doc.no}p{s.page_no}s{s.seq}"
 

server/src/bid_doctor/check/runner.py

@@ -20,16 +20,18 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from bid_doctor.ai.models import AiCall
 from bid_doctor.ai.providers.base import TransientError
 from bid_doctor.billing import service as billing
-from bid_doctor.check import findings, match
+from bid_doctor.check import applicability, findings, match
 from bid_doctor.check.models import CheckItemResult, CheckRun, CheckRunDocument, Finding, FindingCitation
 from bid_doctor.check.service import RULE_SET_VERSION, open_fatal
 from bid_doctor.checklist import edit as checklist_edit
+from bid_doctor.checklist import response_mode
 from bid_doctor.checklist import service as checklist
 from bid_doctor.core import events
 from bid_doctor.core.db import TenantContext, tenant_tx
 from bid_doctor.core.errors import AppError
 from bid_doctor.core.ids import uuid7
 from bid_doctor.document import citations
+from bid_doctor.document import service as documents
 from bid_doctor.document.citations import document_label
 from bid_doctor.document.models import SourceDocument
 from bid_doctor.document.pipeline import normalize, text_layer
@@ -136,6 +138,23 @@ async def _stages(ctx: TenantContext, run_id: UUID) -> None:
         snapshot = await checklist_edit.version_items(s, r.checklist_version_id)
         lots = await projects.lot_labels(s, r.project_id)
         pending = (await checklist.pending_counts(s, [r.project_id])).get(r.project_id, 0)
+        tenders = (
+            await s.execute(
+                select(SourceDocument).where(
+                    SourceDocument.project_id == r.project_id,
+                    SourceDocument.role.in_(("tender", "addendum", "clarification")),
+                    SourceDocument.text_layer_key.is_not(None),
+                )
+            )
+        ).scalars()
+        tender_sents = [
+            x
+            for d in tenders
+            for x in text_layer.body_sentences(
+                [text_layer.Page.from_json(pg) for pg in await documents.text_layer(s, ctx, d)]
+            )
+        ]
+    modes = response_mode.detect(tender_sents)  # 招标文件按类别的响应方式（C12）
     bidding = set(r.lot_ids)
     items, other_lot = {}, 0
     for item_id, payload in snapshot.items():
@@ -144,6 +163,12 @@ async def _stages(ctx: TenantContext, run_id: UUID) -> None:
             items[item_id] = payload
         else:
             other_lot += 1  # 不在所投包里的条目不查，写进覆盖范围（C6）
+    decisions = {i: applicability.decide(p, modes) for i, p in items.items()}
+    skipped: dict[str, int] = {}
+    for d in decisions.values():
+        if not d.match and d.skip:
+            skipped[d.skip] = skipped.get(d.skip, 0) + 1
+    items = {i: p for i, p in items.items() if decisions[i].match}  # 不需要投标人回答的条目不逐条找响应
     last = [PROGRESS["match"]]
 
     async def progress(ratio: float) -> None:
@@ -153,6 +178,7 @@ async def _stages(ctx: TenantContext, run_id: UUID) -> None:
             await _stage(ctx, run_id, "match", pct)
 
     results, stats = await match.run(ctx, run_id, items, bid_docs, progress)
+    match.apply_modes(results, items, decisions)
 
     await _stage(ctx, run_id, "rules")  # 第 2 步：报价形式、形式要件、需人工核对
     await _stage(ctx, run_id, "verify")  # 前两道校验在匹配时逐条做完；这里只是进度节点
@@ -174,7 +200,7 @@ async def _stages(ctx: TenantContext, run_id: UUID) -> None:
             )
         ).one()
         r.counts = await _counts(s, run_id)
-        r.coverage = _coverage(r, pages_info, items, results, pending, other_lot, stats, tokens)
+        r.coverage = _coverage(r, pages_info, items, results, pending, other_lot, stats, tokens, skipped, modes)
     await _publish(ctx, r, "running", "summarize", PROGRESS["summarize"])
 
 
@@ -352,6 +378,8 @@ def _coverage(
     other_lot: int,
     stats: match.Stats,
     tokens: Any,
+    skipped: dict[str, int],
+    modes: dict[str, response_mode.Mode],
 ) -> dict[str, Any]:
     """检查覆盖范围：报告首页、查标页顶部都读这里（FR-M3-09、m3-plan §2.5）。"""
     undetermined = sum(x.verdict == "undetermined" for x in results.values())
@@ -367,6 +395,19 @@ def _coverage(
         not_checked.append(f"{undetermined} 条没有完成判断（模型漏答或暂时不可用），已列为「请人工核对」")
     if scanned:
         not_checked.append(f"{scanned} 页没有文字层（扫描件），这些页上的内容没有检查")
+    for reason, n in skipped.items():
+        not_checked.append(f"{applicability.SKIP_LABELS[reason]} {n} 条：不在投标文件里逐条找响应")
+    labels = {"technical": "技术要求", "commercial": "商务要求"}
+    for m in modes.values():
+        if m.status == "unknown":
+            not_checked.append(f"招标文件没有写明{labels[m.category]}是否要求逐条响应，按逐条响应处理")
+        elif m.status == "conflict":
+            not_checked.append(
+                f"招标文件对{labels[m.category]}的响应方式写法不一致（既要求逐条响应，又写明未列出的视为接受），按逐条响应处理"
+            )
+    implicit = sum(x.verdict in ("implicit_accepted", "implicit_review") for x in results.values())
+    if implicit:
+        checked.append(f"其中 {implicit} 条按招标文件「未列入偏离的视为接受」处理，没有复述不算问题")
     not_checked.append("报价形式、形式要件、资质匹配：规则检查还没有上线")
     if not r.checklist_confirmed:
         not_checked.append("清单未确认，检查结果以当前清单为准")
@@ -383,6 +424,16 @@ def _coverage(
             "evidence_unverified": unverified,
         },
         "checklist_confirmed": r.checklist_confirmed,
+        "skipped": skipped,
+        "response_modes": [
+            {
+                "category": m.category,
+                "mode": m.mode,
+                "status": m.status,
+                "basis": [{"page": x.page_no, "text": x.text[:120]} for x in (m.implicit + m.explicit)[:4]],
+            }
+            for m in modes.values()
+        ],
         "legal_regime": {"value": r.legal_regime, "rules_verified": r.legal_regime in REGIMES_VERIFIED},
         "rule_set_version": RULE_SET_VERSION,
         "prompt_versions": r.prompt_versions,

server/src/bid_doctor/checklist/response_mode.py

@@ -0,0 +1,63 @@
+"""招标文件对投标人怎么响应的规定（决策 C12，`evals/check/GUIDELINES.md` §2）：按类别（技术 / 商务）识别响应方式。
+
+- explicit 逐条响应：「逐条 / 逐项作出响应」「逐一逐条响应填写」「逐条标明满足与否」；
+- implicit 默认接受：「否则将认为投标人接受」「未列入上表的视作完全接受」「除所列偏离外均视作理解和响应」
+  「其余无偏离内容无需赘述」；
+- 两种写法都有（S07）按逐条处理，记 conflict，问题说明里引两处原文；一种都没有按逐条处理，记 unknown。
+规则优先、纯函数；结果带原文句子，查标写进检查覆盖范围。
+TODO(C12)：存进清单、在清单页显示并可改（人工确认点）；模型兜底规则没认出的写法。
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from bid_doctor.document.pipeline.text_layer import Sentence
+
+EXPLICIT = re.compile(r"逐(条|项|一)[^。；]{0,15}(响应|应答|标明|填写|填列|作出|做出|说明)")
+IMPLICIT = re.compile(
+    r"(否则|未列入|未列出|未列明|除[^。；]{0,30}外)[^。；]{0,25}(视为|视作|认为)[^。；]{0,15}(接受|响应|理解)"
+    r"|无需赘述"
+)
+TABLE_HINT = re.compile(r"(技术|商务)[^。；]{0,12}(偏离|响应)")
+LOOKBACK = 12  # 往前找几句，看这句说明属于哪张表（技术 / 商务）
+CATEGORIES = ("technical", "commercial")
+
+
+@dataclass(slots=True)
+class Mode:
+    category: str  # technical / commercial
+    mode: str  # explicit / implicit
+    status: str  # found / conflict / unknown
+    explicit: list[Sentence] = field(default_factory=list[Sentence])
+    implicit: list[Sentence] = field(default_factory=list[Sentence])
+
+
+def _scope(i: int, sentences: list[Sentence]) -> set[str]:
+    """这句说明管哪一类：句子自己写了「技术 / 商务」就按它，否则看前面几句里最近的表名；都没有就两类都管。"""
+    own = {c for c, k in (("technical", "技术"), ("commercial", "商务")) if k in sentences[i].text}
+    if own:
+        return own
+    for s in reversed(sentences[max(0, i - LOOKBACK) : i]):
+        if m := TABLE_HINT.search(s.text):
+            return {"technical" if m.group(1) == "技术" else "commercial"}
+    return set(CATEGORIES)
+
+
+def detect(sentences: list[Sentence]) -> dict[str, Mode]:
+    hits: dict[str, Mode] = {c: Mode(c, "explicit", "unknown") for c in CATEGORIES}
+    for i, s in enumerate(sentences):
+        exp, imp = bool(EXPLICIT.search(s.text)), bool(IMPLICIT.search(s.text))
+        if not exp and not imp:
+            continue
+        for c in _scope(i, sentences):
+            (hits[c].implicit if imp else hits[c].explicit).append(s)
+    for m in hits.values():
+        if m.explicit and m.implicit:
+            m.mode, m.status = "explicit", "conflict"
+        elif m.implicit:
+            m.mode, m.status = "implicit", "found"
+        elif m.explicit:
+            m.mode, m.status = "explicit", "found"
+    return hits

server/tests/test_check_units.py

@@ -77,3 +77,57 @@ def test_no_value_is_a_hint_and_unverified_is_explained() -> None:
     )
     assert uv is not None and uv.severity == "fatal" and "第 3 页" in uv.explanation and "没能核对" in uv.explanation
     assert findings.spec(match.Result("responded", "model", "verified"), item) is None
+
+
+def test_response_mode_by_category() -> None:
+    from bid_doctor.checklist import response_mode
+
+    sents = [
+        sent(1, "技术规格偏离表"),
+        sent(2, "投标人应将所有偏离的条目列入上表，未列入上表的视作投标人完全接受。"),
+        sent(3, "商务条款偏离表"),
+        sent(4, "投标人须对商务要求逐条作出响应。"),
+    ]
+    m = response_mode.detect(sents)
+    assert (m["technical"].mode, m["technical"].status) == ("implicit", "found")
+    assert (m["commercial"].mode, m["commercial"].status) == ("explicit", "found")
+    both = response_mode.detect([sent(1, "须逐项作出响应。"), sent(2, "否则将认为投标人接受招标文件的要求。")])
+    assert (both["technical"].mode, both["technical"].status) == ("explicit", "conflict")  # 写法冲突按逐条（C12）
+    none = response_mode.detect([sent(1, "本项目为货物采购。")])
+    assert (none["commercial"].mode, none["commercial"].status) == ("explicit", "unknown")
+
+
+def test_applicability_skips_items_that_need_no_response() -> None:
+    from bid_doctor.check import applicability
+    from bid_doctor.checklist import response_mode
+
+    modes = response_mode.detect([sent(1, "未列入偏离表的技术要求视作投标人完全接受。")])
+    decide = applicability.decide
+    assert decide({"categories": ["invalidity"], "importance_basis": "tender_text"}, modes).skip == "condition"
+    assert decide({"categories": ["invalidity"], "importance_basis": "marker"}, modes).match  # ★ 条款是要求
+    assert decide({"categories": ["schedule"]}, modes).skip == "schedule"
+    assert decide({"categories": ["scoring"]}, modes).skip == "scoring"
+    assert decide({"categories": ["scoring"], "evidence_required": "业绩合同"}, modes).match
+    assert decide({"categories": ["scoring"], "title": "业绩（2 分）：提供近三年类似项目合同复印件"}, modes).match
+    assert (
+        decide({"categories": ["scoring"], "title": "提供检测报告，中标后签订合同前提供原件"}, modes).skip == "scoring"
+    )
+    assert decide({"categories": ["tech_param"], "title": "支持硬件BFD，提供官网截图证明"}, modes).evidence
+    assert decide({"categories": ["qualification"], "title": "未被列入信用中国失信名单"}, modes).skip == "no_proof"
+    d = decide({"categories": ["tech_param"], "title": "内存"}, modes)
+    assert d.match and d.mode == "implicit"
+
+
+def test_implicit_not_found_is_accepted_but_substantive_gets_a_hint() -> None:
+    from uuid import uuid4
+
+    from bid_doctor.check import applicability
+
+    a, b = uuid4(), uuid4()
+    results = {a: match.Result("not_found", "model"), b: match.Result("not_found", "model")}
+    items = {a: {"importance": "normal"}, b: {"importance": "substantive", "title": "★双电源"}}
+    decisions = {a: applicability.Decision(True, mode="implicit"), b: applicability.Decision(True, mode="implicit")}
+    match.apply_modes(results, items, decisions)
+    assert results[a].verdict == "implicit_accepted" and findings.spec(results[a], items[a]) is None
+    spec = findings.spec(results[b], items[b])
+    assert results[b].verdict == "implicit_review" and spec is not None and spec.severity == "hint"