From 2ae5527695f19dc29b94f57581901636a167b712 Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 13:51:08 +0800 Subject: [PATCH 01/13] =?UTF-8?q?docs(plan):=20A1=20=E8=A3=81=E5=88=A4?= =?UTF-8?q?=E9=9B=86=E6=89=A9=E5=85=85=E8=AE=A1=E5=88=92=E6=8C=89=E5=8F=8C?= =?UTF-8?q?=E5=B8=AD=E4=BD=8D=E8=AF=84=E5=AE=A1=E4=BF=AE=E5=A4=8D=E6=B8=85?= =?UTF-8?q?=E5=8D=95=E5=AE=9A=E7=A8=BF=EF=BC=888=20=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 按用户拍板的 A 方案，逐条闭环评审的三张 RED 与必须现在补的黄卡： - RED#1 接线缝缺失（dead-green：7 任务全绿而生产路径语法裁判恒不生效）⇒ Task 1 的 Files/Interfaces 显式登记接缝：processor.get_loaded_nlp()（只读、不触发加载/下载）+ _make_judge/_JudgeRecorder + 端点注入 judge= + 走端点的接线回归用例。 - RED#2 fail-closed 缺失（降级态仍可 converged:true）⇒ Task 1 落判据「converged==true MUST 蕴含所有已接线确定性层都真跑过」；降级时不返回裁决（非 dict 哨兵 ⇒ judge_unreliable/judge_error）；禁止用塞人造 violation 实现。Global Constraints 新增该条与既有断言冲突裁决规则。 - RED#3 同步调用超时/取消无效 + SSE 不可达 except ⇒ 新增 Task 8（dispatch wait_for + judge to_thread + 修 error 帧语义）。 - 黄卡：Task 2 补 Step 0 并把官方 10 篇 0/10 误报基线（编排者已实测）落成用例；Task 6/7 补可证伪 Produces 签名；Task 7 补 tests/test_server.py 并改写那条三态全绿的 dead-green 回归闸；Task 7 立论冲突选 b（提示词按文本族参数化，由产品层装配）。 - Out of Scope 精确化：「不改内核结构」但允许经注入缝/可选参数改变裁判与提示词语义（与暂缓的 Pi 式重构不冲突，同向）。 - 新增 backlog 登记表（B1 输入静默截断 / B2 截断不可见 / B3 token 闸只算 completion / B4 services⇄tools 双向依赖与 import 期拉起被排除模块）。 --- docs/plans/2026-10-15-a1-judge-expansion.md | 83 +++++++++++++++++---- 1 file changed, 67 insertions(+), 16 deletions(-) diff --git a/docs/plans/2026-10-15-a1-judge-expansion.md b/docs/plans/2026-10-15-a1-judge-expansion.md index b11a2018..32062b91 100644 --- a/docs/plans/2026-10-15-a1-judge-expansion.md +++ b/docs/plans/2026-10-15-a1-judge-expansion.md @@ -7,6 +7,9 @@ > - **禁止 LLM 裁判**：vault `01-Rules/AGENT-CONDUCT.md:249` 的三层校验明确 LLM-as-a-Judge **只用于无法形式化定义的开放语言**、**严禁参与物理真值判断**。语法维度是可形式化的 ⇒ MUST 确定性规则。LLM 辅助若将来要加，只能落在 advisory（`level=warning`）且不得阻止收敛（见 Fog of War）。 > - **误报（FP）是一等公民**：每条新规则 MUST 同时具备①正样本零误报 ②负样本能报 ③边界不报 三条用例；**官方 `A1_SCHREIBEN_TEIL2` 的 10 篇 `sample_email` 在扩后裁判下 `violations == 0` 是硬门**（连官方范文都报错 ⇒ 规则过严 ⇒ 循环永不可能收敛）。 > - **静默降级 = 静默假收敛（红线 1）**：`analyze_a1_email` 现为**纯规则、不依赖 spaCy**。接入语法维度后，若运行时无 spaCy ⇒ 语法违规会**静默消失**，裁判会判出「零违规」。故裁判输出 MUST 带引擎标记（如 `judge_engine` / `degraded`），且**端点 MISS 把降级状态带到返回体**（不得让"没检查"看起来像"检查通过"）。 +> - **接线缝 MUST 显式登记（评审 RED#1）**：任何"裁判能力"的改动 MUST **同时指名"谁把它送进循环"**。本次固化 = 端点 `_run_polish` 注入 `judge=`（含 nlp 来源）。**禁止**只改 `writing.py` 就让 7 个任务的测试全绿 —— 那是 dead-green（生产路径上语法裁判恒不生效，而 §4.3 判据表还能被打勾解除）。 +> - **fail-closed（评审 RED#2）**：验收判据一句话 —— **`converged == true` MUST 蕴含「所有已接线的确定性层都真的跑过且无话可说」**。裁判降级（spaCy 缺席 / 引擎非 `rules+spacy`）时 **MUST NOT 返回"收敛成功"**，只加标记不够。⚠️ 禁止用"降级时塞一条人造 violation"实现 —— 那是把"没检查"伪装成"检测到错误"，同样违反不撒谎纪律。 +> - **既有断言冲突的裁决规则（本次新增）**：当"只增不改"与某条既有测试的 **pin 对象本身错误**（钉住的是默认值而非生产装配）冲突时，允许把该 pin **从默认值改为装配点** —— 属**强化**不是放宽，但 MUST 在提交信息里逐条写明"改的是哪条断言、为什么这是强化"。 > - **只增不改**：`analyze_a1_email` 既有的 `suggestions` 字段与 `detect_*` 既有返回形状逐字不动，新增统一形状的并列字段；`tests/test_writing_rules.py`（34 条）与 `tests/test_goethe_a1_writing.py` 既有断言不许放宽。 > - 测试**一律 stub**（真 `DEEPSEEK_API_KEY` 在门禁上恒 skip = 没有测试）；spaCy 相关用例沿用既有的 `nlp` fixture 惯例。 > - 行尾 CRLF；提交信息中文 + 行号/函数锚点。 @@ -52,26 +55,31 @@ **Files:** - Modify: `delector/services/writing.py`（新增统一抽取器与形状常量） -- Modify: `delector/routes/main.py`（`_a1_violations_if_letter` 改走统一抽取器；返回体透出引擎标记） -- Test: `tests/test_writing_rules.py`（追加）+ `tests/test_ai_polish_loop.py`（不动既有） +- Modify: `delector/nlp_engine/processor.py`（**新增只读** `get_loaded_nlp()`：只读 `_nlp_resolved` / `_nlp_model`，**不触发加载、绝不触发 `spacy.cli.download`**） +- Modify: `delector/routes/main.py`（`_a1_violations_if_letter` 改走统一抽取器；**`_run_polish` 注入 `judge=` 并接住引擎标记**；返回体透出 `judge_degraded`） +- Test: `tests/test_writing_rules.py`（追加）+ `tests/test_server.py`（**端点级接线回归，MUST**）+ `tests/test_ai_polish_loop.py`（按下面裁决规则处理那一条 pin） **Interfaces:** - Consumes: `analyze_a1_email(text, leitpunkte) -> dict`（既有）；`detect_determiner_noun_agreement` / `detect_preposition_case` 的 span 形状 `{severity, error_type, corrected_form, explanation_zh, start, end}` - Produces: `def collect_violations(analysis: dict[str, Any]) -> list[dict[str, Any]]` —— 统一形状 `{"rule": str, "level": "error"|"warning", "message": str, "span": tuple[int, int] | None}`；**新键优先、旧键回退**（`violations` → legacy `suggestions` 的 `level=="error"` 过滤） - Produces: `analyze_a1_email` 追加并列字段 `violations: list[dict]` 与 `judge_engine: str`（`"rules+spacy"` / `"rules_only"`），**既有键逐字不动** - Produces（端点侧）: `_PolishOutcome` 追加 `judge_engine: str`；响应体 `result` 追加 `judge_degraded: bool`（**只增不改**） +- Produces（**接线缝，评审 RED#1 的闭环点**）: `def _make_judge(leitpunkte: list[str] | None, nlp: Any | None) -> Callable[[str], dict]`（端点侧装配器；**内部接住 verdict 的 `judge_engine` 交给 `_JudgeRecorder`**）+ `class _JudgeRecorder`（与既有 `_PolishReplyRecorder` 同形，`main.py:2238-2292`） +- Produces（**fail-closed，评审 RED#2 的闭环点**）: 上面的 `_make_judge` 在 `engine != "rules+spacy"` 时**不返回裁决**（返回非 dict 哨兵）⇒ 循环既有两条路径把它转成 `judge_unreliable`（`:454-457`）或 `judge_error`（`:333-335/:440-453`）⇒ `converged` 恒 `False`、`unconverged_reason` 有值 -> ⚠️ 本任务只立形状与降级标记，**不加任何新规则**（接线在 Task 2+）。 +> ⚠️ 本任务只立**形状 + 接缝 + fail-closed**，**不加任何新规则**（新规则在 Task 2+）。 +> ⚠️ **不允许**"只改 `writing.py` 就算完"：MUST 有一条**走端点**的用例证明语法违规真被计数且 `judge_degraded is False`（否则就是 dead-green）。 +> ⚠️ **既有 pin 的处置**：`tests/test_ai_polish_loop.py::test_real_judge_is_wired_by_default` 逐字钉住「内核默认裁判 = `writing.analyze_a1_email`」。本任务按 Global Constraints 的裁决规则把它**从默认值改为装配点**（断言生产链路 `_run_polish` 装配的裁判是 A1 裁判 + nlp；不是放宽 —— 旧 pin 钉的是"内核自带业务"，新 pin 钉的是"业务在产品层装配"），并在提交信息里逐条写明。 **Subagent Prompt Scaffold (for /dfs-exec):** -> "统一 A1 裁判的违规形状并加引擎降级标记。现状：`analyze_a1_email` 出 `{suggestions:[{rule,level,message}]}`（纯规则），而 `detect_*` 出 `{severity,error_type,corrected_form,explanation_zh,start,end}`（spaCy span）—— 两套形状让端点层 `_a1_violations_if_letter` 只能认一套。① 在 `delector/services/writing.py` 加 `collect_violations(analysis)`：统一形状 `{rule,level,message,span}`，**新键 `violations` 优先、legacy `suggestions` 回退**，`level` 只认 `error`（warning 不阻止收敛 —— 这是 Task 4/5/6 已钉死的语义）；② `analyze_a1_email` **追加**并列字段 `violations` 与 `judge_engine`（`rules+spacy` / `rules_only`），既有键与既有断言逐字不动；③ 端点 `_a1_violations_if_letter` 改用 `collect_violations`，`_PolishOutcome`/响应体加 `judge_engine`/`judge_degraded`（只增不改，前端文案表不动）。TDD：先在 `tests/test_writing_rules.py` 写 RED（统一形状 + 回退 + level 过滤），再实现。RUN：`python -m pytest tests/test_writing_rules.py tests/test_goethe_a1_writing.py tests/test_ai_polish_loop.py tests/test_server.py -q`（既有断言只许新增不许放宽）。" +> "统一 A1 裁判的违规形状并加引擎降级标记。现状：`analyze_a1_email` 出 `{suggestions:[{rule,level,message}]}`（纯规则），而 `detect_*` 出 `{severity,error_type,corrected_form,explanation_zh,start,end}`（spaCy span）—— 两套形状让端点层 `_a1_violations_if_letter` 只能认一套。① 在 `delector/services/writing.py` 加 `collect_violations(analysis)`：统一形状 `{rule,level,message,span}`，**新键 `violations` 优先、legacy `suggestions` 回退**，`level` 只认 `error`（warning 不阻止收敛 —— 这是 Task 4/5/6 已钉死的语义）；② `analyze_a1_email` **追加**并列字段 `violations` 与 `judge_engine`（`rules+spacy` / `rules_only`），既有键与既有断言逐字不动；③ 端点 `_a1_violations_if_letter` 改用 `collect_violations`，`_PolishOutcome`/响应体加 `judge_engine`/`judge_degraded`（只增不改，前端文案表不动）。TDD：先在 `tests/test_writing_rules.py` 写 RED（统一形状 + 回退 + level 过滤），再实现。**④（评审 RED#1，MUST）堵接缝**：`processor.py` 加只读 `get_loaded_nlp()`（不触发加载/下载）；`_run_polish` 改为**注入** `judge=_make_judge(leitpunkte, get_loaded_nlp())`；新增 `_JudgeRecorder` 接住 verdict 里的 `judge_engine`；在 `tests/test_server.py` 加**走端点**的用例（注入可用 nlp + 喂带语法错的非书信体文本 ⇒ 断言违规真被计数 且 `judge_degraded is False`）。**⑤（评审 RED#2，MUST）fail-closed**：`_make_judge` 在 `engine != "rules+spacy"` 时**不返回裁决**（非 dict 哨兵）⇒ 循环转 `judge_unreliable`/`judge_error` ⇒ `converged` 恒 False；用例断言降级态响应体**绝不出现** `converged: true`（禁止靠塞人造 violation 实现）。RUN：`python -m pytest tests/test_writing_rules.py tests/test_server.py tests/test_goethe_a1_writing.py tests/test_ai_polish_loop.py -q`（既有断言只许新增不许放宽；那条 pin 按裁决规则改造并在提交信息写明）。" **Step Breakdown:** -- [ ] Step 1: 写失败测试（RED：统一形状 / legacy 回退 / `level=warning` 不入违规） -- [ ] Step 2: 跑并记录预期失败原文 -- [ ] Step 3: 实现 `collect_violations` + `violations`/`judge_engine` 并列字段 + 端点透出（GREEN） -- [ ] Step 4: 变异自证（把回退分支删掉 ⇒ 相关用例红；把 `level` 过滤删掉 ⇒ warning 入违规 ⇒ 红） -- [ ] Step 5: 关联套件 + `ruff` + mypy 四档 + 原子提交 +- [ ] Step 1: 写失败测试（RED：统一形状 / legacy 回退 / `level=warning` 不入违规 / **端点接线** / **降级态不返回 converged:true**） +- [ ] Step 2: 跑并记录预期失败原文（**注意 RED 的形态是"报 0"或"字段缺失"，不是报错**） +- [ ] Step 3: 实现 `collect_violations` + `violations`/`judge_engine` 并列字段 + `get_loaded_nlp()` + `_make_judge`/`_JudgeRecorder` + 端点注入与 `judge_degraded` 透出（GREEN） +- [ ] Step 4: 变异自证（① 删回退分支 ⇒ 红；② 删 `level` 过滤 ⇒ warning 入违规 ⇒ 红；③ **端点不注入 judge（退回内核默认）⇒ 端点接线用例 MUST 红**；④ **`_make_judge` 去掉 fail-closed ⇒ 降级态用例 MUST 红**） +- [ ] Step 5: 关联套件 + `ruff` + mypy 四档 + 原子提交（提交信息逐条写明那条 pin 的改造理由） --- @@ -91,6 +99,7 @@ > "把仓内**已有**的两件确定性语法算力接进 A1 裁判（照抄 `analyze_essay_text(text, nlp)` 的「显式传 nlp」惯例，不要在模块内自读全局 nlp）。① `analyze_a1_email(text, leitpunkte=None, nlp=None)`：`nlp` 可用时把 `detect_determiner_noun_agreement` + `detect_preposition_case` 的 span 折进 `violations`（映射 `error_type`→`rule`、`explanation_zh`→`message`、`start/end`→`span`、severity→level），`nlp is None` 时不产语法违规并把 `judge_engine` 置 `rules_only`。② **硬门（D3）**：新增用例遍历 `delector/data/a1_writing_dict.A1_SCHREIBEN_TEIL2` 的 10 篇 `sample_email`，断言在这两件算力下 **`violations == 0`**（官方范文被报违规 ⇒ 规则过严 ⇒ 必须修规则或收窄触发条件，不许改断言）。③ 负样本用例：`Ich habe ein Hund.` 与 `Ich fahre mit den Bus.` MUST 各报 1 条；边界用例：无冠词 / 双格介词（`in/auf`）/ 固定搭配 MUST **不报**（既有 `test_two_case_preposition_skipped` 等已覆盖，别删）。RUN：`python -m pytest tests/test_writing_rules.py tests/test_goethe_a1_writing.py -q`。" **Step Breakdown:** +- [x] **Step 0（✅ 2026-10-15 已跑，评审黄卡已消）**：官方 `A1_SCHREIBEN_TEIL2` 10 篇 `sample_email` 在两件既有算力下 **误报 0/10**（逐篇 `det=0 prep=0`；评审点名的高危句 `für Ihre 2-Zimmer-Wohnung` / `vom 15. bis 18. August` / `im Preis enthalten` 均不误报）⇒ **本任务是"接线"而非"修规则"**，硬门基线绿。执行时把这条基线**落成用例**（不是再跑一次人眼）。 - [ ] Step 1: 写失败测试（RED：负样本两例报违规 + 官方 10 篇零违规门） - [ ] Step 2: 跑并记录预期失败原文（**红色是"报 0"，不是"报错"**） - [ ] Step 3: 实现接线（GREEN） @@ -180,7 +189,7 @@ **Interfaces:** - Consumes: `A1_SCHREIBEN_TEIL2`（10 篇官方范文，正样本）· 自建负样本集（每维 ≥5 句手工构造的定向错误句）· 候选规则（本任务**只写探测实现，不接线**） -- Produces: `python tools/bench_judge_fp.py` 的**原始输出**（每维 FP 率 / FN 率 / 误报样例逐条列出）+ 一份结论：每维 ∈ {**接线为 error** | **接线为 warning(advisory)** | **不做**}，附判据与阈值 +- Produces（**可证伪签名，评审黄卡已补**）: `def measure_candidates(candidates: Sequence[Candidate], positives: Sequence[str], negatives: Sequence[str]) -> Report`（`Report = {per_candidate: [{name, fp, fn, fp_samples: list[str], fn_samples: list[str]}], verdict: dict[str, str]}`）+ CLI `python tools/bench_judge_fp.py --json`（**退出码 0 = 标定完成；非 0 = 样本集自身无效**）；每维结论 ∈ {**接线为 error** | **接线为 warning(advisory)** | **不做**}，附判据与阈值 > **为什么这维度必须是 HITL + Tier 3**：探针已实测 spaCy 对 `Ich muss gehen heute nach Hause.` 的**框架解析失败**（`muss` 判 `nk`、`gehen` 判 `ROOT`）⇒ 直接接线会**误报**，而误报比漏报危险（模型会去"修"一个不存在的错误 = 奖励黑客的反面）。做/不做是**产品语义决定**，必须人拍板。 @@ -199,15 +208,18 @@ ### Task 7: 适用性闸门收窄（循环价值面扩到任意德语文本）+ §4.3 门槛解除判据 [Tier: 2-Standard] [Mode: HITL] [Role: TDD Builder] **Files:** -- Modify: `delector/routes/main.py`（`_a1_violations_if_letter` 的闸门范围） +- Modify: `delector/routes/main.py`（`_a1_violations_if_letter` 的闸门范围 + **文本族感知的系统提示词装配**） +- Modify: `delector/services/polish_loop.py`（**只加一个可选参数** `system_prompt: str | None = None`（None ⇒ 用现有 A1 默认值，向后兼容）；业务提示词由产品层传入 —— 见下方"立论冲突的解法"） - Modify: `docs/plans/2026-10-15-a1-judge-expansion.md`（本文件：记录解除判据与实测值） -- Test: `tests/test_goethe_a1_writing.py` +- Test: `tests/test_goethe_a1_writing.py` + **`tests/test_server.py`（评审黄卡：该文件此前未列入 ⇒ 会让一条既有回归闸变成 dead-green，见 scaffold ③）** **要解决的现状（实测）**：`_a1_violations_if_letter` 目前「称呼语不合法 ⇒ 零违规」，因为当时的裁判**只有书信格式规则**。扩了语法维度后，前提变了：**语法违规与题材无关** ⇒ 语法维度对任何德语文本都该生效，只有书信格式/字数规则保留"仅书信体"闸门。这一步把循环的真实迭代价值面从「仅 A1 书信体」扩到「任意德语文本」。 **Interfaces:** -- Consumes: `collect_violations(...)`（Task 1）· 各维度规则 -- Produces: 闸门按**规则族**分流（格式族：仅书信体；语法族：任何文本）+ `docs/plans` 里的**§4.3 解除判据表**（每条判据 + 实测值 + 是否满足） +- Consumes: `collect_violations(...)`（Task 1）· 各维度规则 · `polish_loop.run_polish_loop(system_prompt=...)`（本任务新增的可选参数） +- Produces（**可证伪签名，评审黄卡已补**）: `def violations_for(kind: str, verdict: dict[str, Any]) -> list[dict[str, Any]]`（`kind ∈ {"letter", "prose"}`：`letter` ⇒ 格式族 + 语法族全计；`prose` ⇒ **只计语法族**）+ `def pick_system_prompt(kind: str) -> str`（文本族 → 提示词；**业务知识住在产品层**）+ `docs/plans` 里的 **§4.3 解除判据表**（每条判据 + 实测值 + 是否满足） + +> **立论冲突的解法（评审黄卡 #2，选 b 而非 a）**：原立论"把循环的真实迭代价值面扩到任意德语文本"与内核里**逐字 A1 书信**的 `POLISH_LOOP_SYSTEM_PROMPT`（`polish_loop.py:144-152`）直接冲突 —— 对非书信体，它会**诱导模型加一个称呼语**，而格式族规则此时已被关掉 ⇒ 污染无守卫。故选 b：**提示词按文本族参数化**，由产品层（`main.py`）装配。这同时朝 `architecture.md` 登记的"业务知识上提"方向挪了一步（与日后 Pi 式重构同向、不冲突）。⚠️ 若执行中发现该参数化会破坏 `tests/test_ai_polish_loop.py` 里钉住提示词/契约的用例，按 Global Constraints 的裁决规则处理并逐条写明。 **Subagent Prompt Scaffold (for /dfs-exec):** > "收窄适用性闸门的范围。现状：`_a1_violations_if_letter` 因当时裁判只有书信格式规则而做成「称呼语不合法 ⇒ 零违规」；语法维度接线后**前提变了** —— 语法与题材无关。改法：闸门改按**规则族**分流 —— ① 格式/字数族（`a1_greeting_*` / `a1_valediction_*` / `a1_word_count`）仍仅对书信体生效；② 语法族（冠词-格一致 / 介词支配格 / 动词支配格 / 主谓一致 / V2）对**任意德语文本**生效。测试 MUST 覆盖：非书信体文本带语法错误 ⇒ **真被计数**（与今日"零违规"对比，这是行为变更）；书信体文本的格式规则语义不变。③ 同时在本计划文件里落一张 **§4.3 解除判据表**（维度数 / 官方正样本零误报 / 负样本 recall / 非书信文本可判 / 降级标记可见性 各条 + 实测值），**满足与否由用户拍板**，agent 不自行解禁。RUN：`python -m pytest tests/test_goethe_a1_writing.py tests/test_server.py tests/test_ai_polish_loop.py -q` + 全量。⚠️ 本任务会改变产品行为（非书信文本从"首轮即接受"变为"真迭代"），执行前 MUST 先跑一遍 `tests/test_server.py::test_ai_polish_diff_mocked` 系用例确认既有断言仍成立。" @@ -217,7 +229,46 @@ - [ ] Step 2: 跑并记录预期失败原文 - [ ] Step 3: 闸门按规则族分流（GREEN） - [ ] Step 4: 全量套件 + 契约闸 + §4.3 解除判据表落盘 -- [ ] Step 5: **HITL**：判据表交用户拍板（是否允许宣称"已实现"）+ 原子提交 +- [ ] Step 5: **改写 `tests/test_server.py::test_ai_polish_non_letter_text_is_not_rolled_back`**（评审黄卡③：它在"现状 / 仅接 nlp / 收窄闸门"**三态下都绿** ⇒ 已不守卫任何东西）为能区分行为的两条：① 非书信体 + 语法错（且桩模型不修）⇒ 断言语法违规**真被计数**；② 明确并钉住收窄后的产品语义（该修不动时是回退原文还是首轮即接受）—— 后者正是 ADR §10.3「功能忘了判就是报废」失败模式的重现，MUST 有断言，不许只留在 Fog of War。 +- [ ] Step 6: **HITL**：判据表交用户拍板（是否允许宣称"已实现"）+ 原子提交 + +--- + +### Task 8: 内核接缝加固（超时 / 线程 / 不可达分支） [Tier: 2-Standard] [Mode: AFK] [Role: TDD Builder] + +> **由来**：评审 RED#3 与模式 3 要点 4。**不是** Pi 式重构（那已暂缓）—— 本任务只在既有结构上补三处缝，不重画层。 + +**Files:** +- Modify: `delector/services/polish_loop.py`（`dispatch` 包超时；同步 `judge` 移出事件循环） +- Modify: `delector/routes/main.py`（删/修那个**不可达**的 `except LLMError` 分支；SSE 侧错误帧语义） +- Test: `tests/test_ai_polish_loop.py`、`tests/test_server.py` + +**Interfaces:** +- Consumes: `asyncio.wait_for(...)` · `asyncio.to_thread(...)` · 既有 `DEFAULT_PER_CALL_TIMEOUT_S` / 剩余 deadline 口径 +- Produces: ① `dispatch` 调用 MUST 受 `asyncio.wait_for(timeout=min(剩余 deadline, DEFAULT_PER_CALL_TIMEOUT_S))` 约束（超时 ⇒ errors-as-messages，不炸循环）；② 同步 `judge` MUST 经 `asyncio.to_thread`（否则 `task.cancel()` 掐不断它、且会阻塞同进程的 `/api/health` 与其他路由）；③ SSE 的 LLMError 语义：要么让 `_run_polish` 原样抛出、要么在流层捕获 `HTTPException` —— **不允许存在"永不命中的 except"** + +**Subagent Prompt Scaffold (for /dfs-exec):** +> "补三处接缝。① `polish_loop.py` 的 `dispatch`（:412）目前**无超时**：包 `asyncio.wait_for`，超时按 errors-as-messages 返回工具失败消息（不炸循环）；② 同步裁判 `judge`（:330/:439）直接跑在事件循环上 ⇒ 移 `asyncio.to_thread`，使 (a) `task.cancel()` 真能掐断、(b) 长裁判不阻塞 `/api/health` 与其他路由；用例钉住"取消时裁判线程不再被等待"/"裁判期间 health 仍可应答"（后者可用事件循环探针）。③ 修 `main.py` 的**不可达分支**：`_run_polish`（:2342-2344）已把 `LLMError` 转成 `HTTPException(502)`，而 `_polish_event_stream`（:2439-2442）写的是 `except llm_client.LLMError` ⇒ 该分支永不命中、流内 error 帧永不发出、用户拿到通用文案而非 `e.detail` 人话。断言：注入的 chat 在流中途抛 LLMError ⇒ 用户**看得到** `e.detail`（走 error 帧或明确的状态码，二选一并在注释写明为什么）。RUN：`python -m pytest tests/test_ai_polish_loop.py tests/test_server.py -q` + 全量。" + +**Step Breakdown:** +- [ ] Step 1: 写失败测试（RED：dispatch 无超时 / 同步裁判阻塞事件循环 / error 帧不可达） +- [ ] Step 2: 跑并记录预期失败原文 +- [ ] Step 3: 三处实现（GREEN） +- [ ] Step 4: 变异自证（抽掉 `wait_for` ⇒ 超时用例红；抽掉 `to_thread` ⇒ 阻塞探针红；把 except 改回 LLMError ⇒ error 帧用例红） +- [ ] Step 5: 全量 + ruff + mypy 四档 + 原子提交 + +--- + +## 📌 登记（进 backlog，**不**塞进本计划） + +> 评审发现、但属既有行为或与"抬 §4.3 门槛"无关 ⇒ 只登记，不在本计划动手。 + +| # | 事项 | 证据 | 为什么不现在做 | +| --- | --- | --- | --- | +| B1 | 润色入口对**用户输入**静默截断到 2000 字符，无提示、无标记 | `main.py:2465/:2481` `req.text[:2000]`；响应体无字段 | 既有行为，与裁判集无关；应配 UI 提示或 `input_truncated` 字段 | +| B2 | `truncate_evidence` 截断**不可见**、无逃生通道 | `polish_loop.py:222-237`（纯前缀裁剪、无标记、不落盘） | 与"零违规"叠加会放大假收敛；最小修法是尾部加确定性标记（"无标记 ⇒ 必未截断"），另立任务 | +| B3 | 循环级 token 闸**只累计 completion**，注入证据带来的 prompt 增长不在任何闸内 | `polish_loop.py:49-55`（自认）、`:357` | 今天有界性靠 `max_turns=3`；**若将来抬轮数 MUST 先把证据计入闸**（Fog Unknown C 的前置条件） | +| B4 | `services ⇄ tools` 双向包依赖；且 `polish_tools` 一被 import 就间接拉起白名单**明确排除**的 `tts`/`ingest`/`export` 三个模块 | `polish_tools.py:60` + `tools/__init__.py:11-27` | 属 Pi 式重构域（已暂缓）；差集守卫只挡"白名单加项"，挡不住"import 期拉起" | --- @@ -232,7 +283,7 @@ ## 🚫 Out of Scope - **不引入 LLM 裁判**（D1 / vault 规则）；Fog of War Unknown A 若将来要加，也只能是 advisory。 -- **不改循环内核**（`polish_loop.py` 的停止策略/预算/哨兵已定稿并有 25 条测试钉住）。 +- **不改循环内核结构**（`polish_loop.py` 的停止策略/预算/哨兵已定稿并有 25 条测试钉住）；**允许**经**注入缝 / 可选参数**改变裁判与提示词语义（Task 1 的 `judge=`、Task 7 的 `system_prompt=`）—— 这是评审三张 RED 的修复路径，也朝 `docs/agents/architecture.md` 登记的"业务知识上提"同向。 - **不做 B1/B2 评分维度**；不扩到口语/写作 Teil 1。 - **不改前端契约形状**（只可能新增一个 `judge_degraded` 布尔；不做新 UI）。 - **不动 `TOOL_REGISTRY` 与工具白名单**（Task 5 已定稿为恰好 3 项只读）。 From 33d6bb430081bdf95295630274f021f6fc8a9e80 Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 13:52:10 +0800 Subject: [PATCH 02/13] =?UTF-8?q?docs(plan):=20RED#2=20=E4=BF=AE=E6=B3=95?= =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E4=B8=BA=E5=88=86=E5=B1=82=E6=89=BF=E6=8B=85?= =?UTF-8?q?=EF=BC=88=E8=BF=90=E8=A1=8C=E6=9C=9F=20fail-open=20+=20?= =?UTF-8?q?=E5=A3=B0=E6=98=8E/=E9=97=A8=E7=A6=81=E5=B1=82=20fail-closed?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 实测依据：delector/nlp_engine/processor.py:192-198 —— Android 分支显式 nlp=None、不加载不下载 ⇒ 引擎恒 rules_only。若按评审原建议「降级即禁止收敛」，循环的 argmin 回退会返回原文 = ADR §10.3 记过的「用户点了润色拿回原文」回归（Android 上功能报废）。 故修正为：① 运行期 fail-open + judge_engine/judge_degraded 忠实透出 + 前端可见提示；② 声明/门禁层 fail-closed（判据表/发行说明在 judge_degraded==true 时不得当「全引擎零违规」的证据）。目标（没检查不得被当成检查通过）不变。 --- docs/plans/2026-10-15-a1-judge-expansion.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/docs/plans/2026-10-15-a1-judge-expansion.md b/docs/plans/2026-10-15-a1-judge-expansion.md index 32062b91..3b2adf6e 100644 --- a/docs/plans/2026-10-15-a1-judge-expansion.md +++ b/docs/plans/2026-10-15-a1-judge-expansion.md @@ -8,7 +8,10 @@ > - **误报（FP）是一等公民**：每条新规则 MUST 同时具备①正样本零误报 ②负样本能报 ③边界不报 三条用例；**官方 `A1_SCHREIBEN_TEIL2` 的 10 篇 `sample_email` 在扩后裁判下 `violations == 0` 是硬门**（连官方范文都报错 ⇒ 规则过严 ⇒ 循环永不可能收敛）。 > - **静默降级 = 静默假收敛（红线 1）**：`analyze_a1_email` 现为**纯规则、不依赖 spaCy**。接入语法维度后，若运行时无 spaCy ⇒ 语法违规会**静默消失**，裁判会判出「零违规」。故裁判输出 MUST 带引擎标记（如 `judge_engine` / `degraded`），且**端点 MISS 把降级状态带到返回体**（不得让"没检查"看起来像"检查通过"）。 > - **接线缝 MUST 显式登记（评审 RED#1）**：任何"裁判能力"的改动 MUST **同时指名"谁把它送进循环"**。本次固化 = 端点 `_run_polish` 注入 `judge=`（含 nlp 来源）。**禁止**只改 `writing.py` 就让 7 个任务的测试全绿 —— 那是 dead-green（生产路径上语法裁判恒不生效，而 §4.3 判据表还能被打勾解除）。 -> - **fail-closed（评审 RED#2）**：验收判据一句话 —— **`converged == true` MUST 蕴含「所有已接线的确定性层都真的跑过且无话可说」**。裁判降级（spaCy 缺席 / 引擎非 `rules+spacy`）时 **MUST NOT 返回"收敛成功"**，只加标记不够。⚠️ 禁止用"降级时塞一条人造 violation"实现 —— 那是把"没检查"伪装成"检测到错误"，同样违反不撒谎纪律。 +> - **降级态的诚实性（评审 RED#2 + 编排者修正）**：目标不变 —— **"没检查" MUST NOT 被当成"检查通过"**。但实现**分两层**，因为**运行期 fail-closed 会在 Android 上把功能打回原文**（实测依据：`delector/nlp_engine/processor.py:192-198` —— Android 分支**显式** `nlp=None`、不加载不下载 ⇒ 引擎恒 `rules_only`；此时若禁止收敛，循环的 `argmin` 回退会返回**原文** ⇒ 即 ADR §10.3 记过的「用户点了润色拿回原文」回归）： +> 1. **运行期 fail-open + 显式标记**：降级时循环照常收敛，但响应体 MUST 带 `judge_engine` / `judge_degraded`，前端 MUST 给出**可见提示**（不是 error toast，而是"语法检查未启用"一类）。 +> 2. **声明 / 门禁层 fail-closed**：**任何人（含 §4.3 解除判据表、发行说明、宣传文案）在 `judge_degraded == true` 时 MUST NOT 把该次运行当"全引擎零违规"的证据**；判据表 MUST 显式列出「降级运行时 `converged` 的语义边界」这一行。 +> ⚠️ 禁止用"降级时塞一条人造 violation"实现 —— 那是把"没检查"伪装成"检测到错误"，同样违反不撒谎纪律。 > - **既有断言冲突的裁决规则（本次新增）**：当"只增不改"与某条既有测试的 **pin 对象本身错误**（钉住的是默认值而非生产装配）冲突时，允许把该 pin **从默认值改为装配点** —— 属**强化**不是放宽，但 MUST 在提交信息里逐条写明"改的是哪条断言、为什么这是强化"。 > - **只增不改**：`analyze_a1_email` 既有的 `suggestions` 字段与 `detect_*` 既有返回形状逐字不动，新增统一形状的并列字段；`tests/test_writing_rules.py`（34 条）与 `tests/test_goethe_a1_writing.py` 既有断言不许放宽。 > - 测试**一律 stub**（真 `DEEPSEEK_API_KEY` 在门禁上恒 skip = 没有测试）；spaCy 相关用例沿用既有的 `nlp` fixture 惯例。 @@ -65,14 +68,14 @@ - Produces: `analyze_a1_email` 追加并列字段 `violations: list[dict]` 与 `judge_engine: str`（`"rules+spacy"` / `"rules_only"`），**既有键逐字不动** - Produces（端点侧）: `_PolishOutcome` 追加 `judge_engine: str`；响应体 `result` 追加 `judge_degraded: bool`（**只增不改**） - Produces（**接线缝，评审 RED#1 的闭环点**）: `def _make_judge(leitpunkte: list[str] | None, nlp: Any | None) -> Callable[[str], dict]`（端点侧装配器；**内部接住 verdict 的 `judge_engine` 交给 `_JudgeRecorder`**）+ `class _JudgeRecorder`（与既有 `_PolishReplyRecorder` 同形，`main.py:2238-2292`） -- Produces（**fail-closed，评审 RED#2 的闭环点**）: 上面的 `_make_judge` 在 `engine != "rules+spacy"` 时**不返回裁决**（返回非 dict 哨兵）⇒ 循环既有两条路径把它转成 `judge_unreliable`（`:454-457`）或 `judge_error`（`:333-335/:440-453`）⇒ `converged` 恒 `False`、`unconverged_reason` 有值 +- Produces（**降级诚实性，评审 RED#2 的闭环点，按 Global Constraints 的分层方案**）: `judge_engine` 由裁决**如实透出**（引擎可用 ⇒ `"rules+spacy"`；不可用 ⇒ `"rules_only"`）并经 `_JudgeRecorder` 进 `_PolishOutcome` ⇒ 响应体 `judge_degraded` 忠实；**运行期不禁止收敛**（见 Global Constraints 的 Android 证据），门禁层的 fail-closed 由 Task 7 的判据表承担 > ⚠️ 本任务只立**形状 + 接缝 + fail-closed**，**不加任何新规则**（新规则在 Task 2+）。 > ⚠️ **不允许**"只改 `writing.py` 就算完"：MUST 有一条**走端点**的用例证明语法违规真被计数且 `judge_degraded is False`（否则就是 dead-green）。 > ⚠️ **既有 pin 的处置**：`tests/test_ai_polish_loop.py::test_real_judge_is_wired_by_default` 逐字钉住「内核默认裁判 = `writing.analyze_a1_email`」。本任务按 Global Constraints 的裁决规则把它**从默认值改为装配点**（断言生产链路 `_run_polish` 装配的裁判是 A1 裁判 + nlp；不是放宽 —— 旧 pin 钉的是"内核自带业务"，新 pin 钉的是"业务在产品层装配"），并在提交信息里逐条写明。 **Subagent Prompt Scaffold (for /dfs-exec):** -> "统一 A1 裁判的违规形状并加引擎降级标记。现状：`analyze_a1_email` 出 `{suggestions:[{rule,level,message}]}`（纯规则），而 `detect_*` 出 `{severity,error_type,corrected_form,explanation_zh,start,end}`（spaCy span）—— 两套形状让端点层 `_a1_violations_if_letter` 只能认一套。① 在 `delector/services/writing.py` 加 `collect_violations(analysis)`：统一形状 `{rule,level,message,span}`，**新键 `violations` 优先、legacy `suggestions` 回退**，`level` 只认 `error`（warning 不阻止收敛 —— 这是 Task 4/5/6 已钉死的语义）；② `analyze_a1_email` **追加**并列字段 `violations` 与 `judge_engine`（`rules+spacy` / `rules_only`），既有键与既有断言逐字不动；③ 端点 `_a1_violations_if_letter` 改用 `collect_violations`，`_PolishOutcome`/响应体加 `judge_engine`/`judge_degraded`（只增不改，前端文案表不动）。TDD：先在 `tests/test_writing_rules.py` 写 RED（统一形状 + 回退 + level 过滤），再实现。**④（评审 RED#1，MUST）堵接缝**：`processor.py` 加只读 `get_loaded_nlp()`（不触发加载/下载）；`_run_polish` 改为**注入** `judge=_make_judge(leitpunkte, get_loaded_nlp())`；新增 `_JudgeRecorder` 接住 verdict 里的 `judge_engine`；在 `tests/test_server.py` 加**走端点**的用例（注入可用 nlp + 喂带语法错的非书信体文本 ⇒ 断言违规真被计数 且 `judge_degraded is False`）。**⑤（评审 RED#2，MUST）fail-closed**：`_make_judge` 在 `engine != "rules+spacy"` 时**不返回裁决**（非 dict 哨兵）⇒ 循环转 `judge_unreliable`/`judge_error` ⇒ `converged` 恒 False；用例断言降级态响应体**绝不出现** `converged: true`（禁止靠塞人造 violation 实现）。RUN：`python -m pytest tests/test_writing_rules.py tests/test_server.py tests/test_goethe_a1_writing.py tests/test_ai_polish_loop.py -q`（既有断言只许新增不许放宽；那条 pin 按裁决规则改造并在提交信息写明）。" +> "统一 A1 裁判的违规形状并加引擎降级标记。现状：`analyze_a1_email` 出 `{suggestions:[{rule,level,message}]}`（纯规则），而 `detect_*` 出 `{severity,error_type,corrected_form,explanation_zh,start,end}`（spaCy span）—— 两套形状让端点层 `_a1_violations_if_letter` 只能认一套。① 在 `delector/services/writing.py` 加 `collect_violations(analysis)`：统一形状 `{rule,level,message,span}`，**新键 `violations` 优先、legacy `suggestions` 回退**，`level` 只认 `error`（warning 不阻止收敛 —— 这是 Task 4/5/6 已钉死的语义）；② `analyze_a1_email` **追加**并列字段 `violations` 与 `judge_engine`（`rules+spacy` / `rules_only`），既有键与既有断言逐字不动；③ 端点 `_a1_violations_if_letter` 改用 `collect_violations`，`_PolishOutcome`/响应体加 `judge_engine`/`judge_degraded`（只增不改，前端文案表不动）。TDD：先在 `tests/test_writing_rules.py` 写 RED（统一形状 + 回退 + level 过滤），再实现。**④（评审 RED#1，MUST）堵接缝**：`processor.py` 加只读 `get_loaded_nlp()`（不触发加载/下载）；`_run_polish` 改为**注入** `judge=_make_judge(leitpunkte, get_loaded_nlp())`；新增 `_JudgeRecorder` 接住 verdict 里的 `judge_engine`；在 `tests/test_server.py` 加**走端点**的用例（注入可用 nlp + 喂带语法错的非书信体文本 ⇒ 断言违规真被计数 且 `judge_degraded is False`）。**⑤（评审 RED#2，MUST）降级诚实性**：`judge_engine` 如实透出（可用 ⇒ `rules+spacy`；不可用 ⇒ `rules_only`）并把 `judge_degraded` 送进响应体与前端提示；**运行期 fail-open**（Android `nlp=None`，fail-closed 会让 argmin 回退返回原文 = 功能报废）、**声明/门禁层 fail-closed**（Task 7 的判据表在 `judge_degraded==true` 时不得被用作"全引擎通过"的证据）。两条用例：引擎可用 ⇒ `judge_degraded is False`；引擎不可用 ⇒ `judge_degraded is True` 且 `converged` 的语义边界写进 docstring。禁止靠塞人造 violation 实现。RUN：`python -m pytest tests/test_writing_rules.py tests/test_server.py tests/test_goethe_a1_writing.py tests/test_ai_polish_loop.py -q`（既有断言只许新增不许放宽；那条 pin 按裁决规则改造并在提交信息写明）。" **Step Breakdown:** - [ ] Step 1: 写失败测试（RED：统一形状 / legacy 回退 / `level=warning` 不入违规 / **端点接线** / **降级态不返回 converged:true**） From 88856ab7d110cdabe8a93a9d68271a222fbdd02e Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 14:20:58 +0800 Subject: [PATCH 03/13] =?UTF-8?q?feat(judge):=20A1=20=E8=A3=81=E5=88=A4?= =?UTF-8?q?=E6=89=A9=E5=88=B0=E8=AF=AD=E6=B3=95=E5=B1=82=E5=B9=B6=E6=8A=8A?= =?UTF-8?q?=E8=83=BD=E5=8A=9B=E5=90=8C=E6=89=B9=E9=80=81=E8=BF=9B=E7=94=9F?= =?UTF-8?q?=E4=BA=A7=E9=93=BE=E8=B7=AF=EF=BC=88Task=201+2=20=E5=8E=9F?= =?UTF-8?q?=E5=AD=90=E5=8F=98=E6=9B=B4=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 计划 docs/plans/2026-10-15-a1-judge-expansion.md 的 Task 1+2 合并交付（评审 RED#1 的直接结论：只改 writing.py 而不同批接线 = dead-green）。 - writing.py：新增 collect_violations（统一形状；新键 violations 优先 / legacy suggestions 回退且只取 level==error）；analyze_a1_email 只增不改地追加 violations + judge_engine，并接线既有两件算力 detect_determiner_noun_agreement / detect_preposition_case（显式传 nlp，沿用 analyze_essay_text 惯例）。 - processor.py：新增只读 get_loaded_nlp() 与无下载 try_load_nlp_no_download()（逐个候选调 _load_spacy_model，绝不含 spacy.cli.download 兜底；成功写回既有缓存、失败不写任何全局）。 为什么需要第二个：只用只读版会让桌面首次润色也落在 rules_only（模型惰性加载，别处还未触发 ⇒ 引擎标记长期假降级）；直接调既有 _resolve_nlp_model() 会走 download（出网 + pip 子进程）。 - main.py：_run_polish 先只读、再在 asyncio.to_thread 内本地加载，经 _make_judge/_JudgeRecorder 真注入 judge=；_PolishOutcome 追加 judge_engine；两个 payload 末尾追加 judge_degraded（只增不改）。 - 降级诚实性按计划分层承担：运行期 fail-open（实测 processor.py:192-198 的 Android 分支 nlp=None；若禁止收敛，argmin 回退会返回原文 = ADR §10.3 的功能报废回归），声明/门禁层 fail-closed（由 Task 7 判据表承担）。 - 退回一处越界：maker 一度把 _a1_violations_if_letter 改成按规则族分流（非书信体保留语法族）—— 那属 Task 7 的 HITL 产品行为变更（语法违规开始计数后，模型修不动的作文会回退原文），已退回旧语义并新增一条钉子钉住「本批不改该行为」（钉子先断言语法错真实存在，非真空）。 - pin 裁决：test_real_judge_is_wired_by_default 由「内核默认裁判 = analyze_a1_email」改造为「生产链路在装配点注入 A1 裁判」，属强化（能拦 dead-green）而非放宽。 - 官方 A1_SCHREIBEN_TEIL2 10 篇 sample_email 零违规硬门落成用例（基线由编排者实测 0/10）。 门禁：406 passed（5 个套件）；ruff check . 全绿；mypy --strict delector 66 files 0；前端契约闸 PASS；CRLF。变异自证 5 组（含端点不传 judge= ⇒ 红、闸门改回分流 ⇒ 钉子红）。复核：CRV APPROVED（无红卡，4 黄卡不阻塞）。 --- delector/nlp_engine/processor.py | 49 ++++++++++++ delector/routes/main.py | 122 +++++++++++++++++++++++++----- delector/services/writing.py | 83 +++++++++++++++++++- tests/test_ai_polish_loop.py | 81 +++++++++++++++++--- tests/test_goethe_a1_writing.py | 37 ++++++++- tests/test_server.py | 126 +++++++++++++++++++++++++++++++ tests/test_writing_rules.py | 126 +++++++++++++++++++++++++++++++ 7 files changed, 593 insertions(+), 31 deletions(-) diff --git a/delector/nlp_engine/processor.py b/delector/nlp_engine/processor.py index 80fdbbea..76d11e86 100644 --- a/delector/nlp_engine/processor.py +++ b/delector/nlp_engine/processor.py @@ -167,6 +167,55 @@ def _resolve_nlp_model() -> Any: return _nlp_model +# ── 只读 / 无下载加载助手（Task 1：给产品层「拿一个可用的 nlp」但不付下载成本）──────── +# 说明：`_resolve_nlp_model()` 是「首用即加载」且**带 `spacy.cli.download` 兜底**（出网 + 起 pip +# 子进程、无时限）。产品层的润色循环不能付这个成本，于是拆成两件更窄的只读/无下载算力。 +def get_loaded_nlp() -> Any: + """只读**已加载**的 spaCy 模型：仅当此前成功解析过（`_nlp_resolved` 且 `_nlp_model` 非 None）才返回。 + + 绝不触发加载、绝不 `spacy.cli.download` —— 这是给产品层「先看有没有现成模型」的纯读探针。 + 与 `_resolve_nlp_model()` 的分工：后者是首用即加载（可能起下载），本函数是**零副作用读取**。 + """ + if _nlp_resolved and _nlp_model is not None: + return _nlp_model + return None + + +def try_load_nlp_no_download() -> Any: + """按 `SPACY_MODEL_CANDIDATES` **只做本地加载**：能装就装（写回既有缓存），装不上就返回 None。 + + **为什么需要这个中间态**（设计理由，勿删）： + - 只用 `get_loaded_nlp()` 会让**桌面首次润色**也落在 `rules_only`（模型是惰性加载的，别处 + 还没触发过）⇒ 生产上引擎标记长期假降级，与真实能力不符； + - 直接调 `_resolve_nlp_model()` 会走 `spacy.cli.download`（出网 + 起 pip 子进程，无时限）； + - 本函数取中间态：**本地能加载就加载、加载不上就诚实返回 None，绝不下载**。 + + 成功 ⇒ 写入既有缓存（`_nlp_model` / `_nlp_resolved=True`）并刷新 `NLP_ENGINE` / `NLP_ENGINE_DETAIL`； + 失败 ⇒ **不写任何全局**（不改 `_nlp_resolved` / `_nlp_error`），返回 None。 + + 同步函数（内部不 await），可在 `asyncio.to_thread` 里跑，避免阻塞事件循环。并发安全： + 沿用 `_model_lock` + 双检，保证与 `_resolve_nlp_model()` 共用同一份缓存、不重复加载。 + """ + global _nlp_model, _nlp_resolved, NLP_ENGINE, NLP_ENGINE_DETAIL + if _nlp_resolved and _nlp_model is not None: + return _nlp_model + with _model_lock: + if _nlp_resolved and _nlp_model is not None: + return _nlp_model + for candidate in SPACY_MODEL_CANDIDATES: + try: + model, how = _load_spacy_model(candidate) + except Exception: + # 该候选本地加载失败 ⇒ 试下一个；**绝不**退到 spacy.cli.download（见 docstring）。 + continue + _nlp_model = model + _nlp_resolved = True + NLP_ENGINE = "spacy" + NLP_ENGINE_DETAIL = f"spaCy {getattr(spacy, '__version__', 'unknown')} + {how}" + return _nlp_model + return None + + class _LazyNlp: """惰性 spaCy 模型代理：首次**调用**时才真正加载（ADR-0018 §7.6 O0）。 diff --git a/delector/routes/main.py b/delector/routes/main.py index aa1fa8d2..6f9ec77a 100644 --- a/delector/routes/main.py +++ b/delector/routes/main.py @@ -36,7 +36,7 @@ import threading import time from datetime import datetime, timedelta -from typing import Any, AsyncIterator, Dict, List, NamedTuple, Optional, Tuple +from typing import Any, AsyncIterator, Callable, Dict, List, NamedTuple, Optional, Tuple import httpx from fastapi import APIRouter, BackgroundTasks, HTTPException, Request @@ -134,6 +134,9 @@ from delector.services import llm_client, polish_loop from delector.services.polish_tools import POLISH_TOOL_ALLOWLIST, call_tool +# 统一违规抽取器（Task 1）：端点层与裁判层共用同一形状口径。取具名符号（纯函数，无循环依赖）。 +from delector.services.writing import analyze_a1_email, collect_violations + router = APIRouter() @@ -2201,22 +2204,29 @@ def api_syntax_analyze(req: SyntaxAnalyzeReq) -> Any: def _a1_violations_if_letter(verdict: Dict[str, Any]) -> List[Dict[str, Any]]: - """适用性闸门：**A1 书信规则只对书信体文本计数**（Unknown A 的边界）。 - - 今天唯一的确定性裁判是 `writing.analyze_a1_email`（歌德 A1 书信规则）；裁判集 - 扩充属 Unknown A，本计划不做。它对**非书信体**（普通作文）必然报 - `a1_greeting_missing`（level=error）—— 那是**题材差异**，不是错误。若照单全收： - `v_0 = 1`，而模型润色后仍然没有称呼语 ⇒ `v_1 >= v_0` ⇒ 循环判 `no_improvement` - 并回退 argmin = 原文 ⇒ 用户点了润色却拿回原文，功能报废。 - - 故：称呼语不合法 ⇒ 认定「这套规则对该文本不适用」⇒ 零违规。 - 注意这**不等于**「裁判判定无错」：手上的裁判对该文本**无话可说**，语义等价于 - 今天的一次性润色（首轮即接受），而不是「零违规」的证明。 + """适用性闸门（**旧语义**：非书信体 ⇒ 零违规）：A1 书信规则只对书信体计数。 + + 旧闸门的理由：手上这套裁判（`analyze_a1_email`）报的是**书信题材**的规则 —— 对**非书信体** + （普通作文）它必然报 `a1_greeting_missing`(error)，那是**题材差异**不是错误；照单全收会让 + `v_0 = 1`、`v_1 >= v_0` ⇒ `no_improvement` ⇒ 回退原文 ⇒ 用户点了润色拿回原文（功能报废）。 + 故非书信体（`greeting.valid` 为假）⇒ 返回 `[]`（闸门「无话可说」，语义等价于首轮即接受， + **不等于**「裁判判定无错」）。 + + 统一抽取器：走 `collect_violations`（新键 `violations` 优先、legacy `suggestions` 回退， + 且只取 `level == "error"`），与裁判层同口径。 + + ⚠️ 注记（**本批故意不落地**）：把闸门改成**按规则族分流**（格式/字数族只对书信体计数、 + 语法族对**任意德语文本**生效）属 **Task 7（HITL）** —— 那是**产品行为变更**（非书信文本从 + "首轮即接受"变成"真迭代"），且会让模型修不动的作文落到 `no_improvement` ⇒ argmin 回退原文 + （ADR §10.3 记过的「用户点了润色拿回原文」失败模式）⇒ MUST 由用户拍板、不能作为本批的副产品 + 落地。见 `docs/plans/2026-10-15-a1-judge-expansion.md` Task 7。 """ + violations = collect_violations(verdict) greeting = verdict.get("greeting") if isinstance(verdict, dict) else None - if not isinstance(greeting, dict) or not greeting.get("valid"): - return [] - return polish_loop.default_violations_of(verdict) + if isinstance(greeting, dict) and greeting.get("valid"): + return violations # 书信体：照常计数 + # 非书信体：整套 A1 书信规则不适用（题材差异）⇒ 闸门「无话可说」。 + return [] def _make_tool_audit_hook(seen: List[str]) -> Any: @@ -2292,14 +2302,65 @@ def _capture(self, reply: Any) -> None: self.error_count = count +def _make_judge(leitpunkte: Optional[List[str]], nlp: Any) -> Callable[[str], Dict[str, Any]]: + """装配生产链路用的 **A1 裁判**（带 nlp）：内部调 `analyze_a1_email(text, leitpunkte, nlp)`。 + + 为什么必须由**产品层**装配、而不能用内核默认裁判：内核默认裁判是 + `polish_loop._default_judge` = `analyze_a1_email(text, leitpunkte)`（**不带 nlp**）⇒ 语法族 + 恒不生效。能力必须在产品层装配，内核只保留「谁都能被注入」的缝（评审 RED#1 的闭环点）。 + + 降级语义边界（如实登记，勿删）：`nlp is None` 时本裁判只跑格式族、`judge_engine="rules_only"`； + 此时循环**照常收敛**（运行期 fail-open —— 禁止收敛会让 argmin 回退返回原文 = 功能报废）。 + “没检查语法”不等于“语法零违规”：声明层的诚实性由裁决体的 `judge_engine` 透出 + （`_JudgeRecorder` 捕获 → 响应体 `judge_degraded`），门禁层 fail-closed 由调用方承担。 + **禁止**靠塞一条人造 violation 来实现降级提示。 + """ + + def _judge(text: str) -> Dict[str, Any]: + return analyze_a1_email(text, leitpunkte, nlp) + + return _judge + + +class _JudgeRecorder: + """裁判的**录制包装**（与 `_PolishReplyRecorder` 同形）：记下每次裁决的 `judge_engine`， + 再原样返回裁决。 + + 为什么端点要自己录：`judge_engine` 住在裁决体里（`analyze_a1_email` 的并列字段），而循环 + 出口的 `LoopResult` 不带它 ⇒ 端点必须从裁判这一侧捕获，才能把降级状态如实透出到响应体 + （红线 1：不得让“没检查”看起来像“检查通过”）。 + + `__call__` 的第二参数兼容循环的 `judge_fn(text, leitpunkte)` 调用约定（leitpunkte 已由 + `_make_judge` 闭包绑定，这里忽略即可）。 + """ + + def __init__(self, judge_fn: Callable[[str], Dict[str, Any]]) -> None: + self._judge_fn = judge_fn + # 未被裁过时的保守默认：宁报降级（rules_only）不报可用，避免“没跑却标成已跑”。 + self.judge_engine: str = "rules_only" + + def __call__(self, text: str, leitpunkte: Optional[List[str]] = None) -> Dict[str, Any]: + verdict = self._judge_fn(text) + if isinstance(verdict, dict): + engine = verdict.get("judge_engine") + if isinstance(engine, str) and engine: + self.judge_engine = engine + return verdict + + class _PolishOutcome(NamedTuple): - """一次润色的出口（端点据此组装响应体，流式与非流式共用一份）。""" + """一次润色的出口（端点据此组装响应体，流式与非流式共用一份）。 + + `judge_engine`（追加，Task 1）：本次运行实际装配的裁判引擎（`"rules+spacy"` / `"rules_only"`）， + 端据此算出响应体 `judge_degraded`。 + """ text: str notes_zh: List[str] error_count: int converged: bool reason: Optional[str] + judge_engine: str def _no_key_outcome(text: str) -> _PolishOutcome: @@ -2313,6 +2374,8 @@ def _no_key_outcome(text: str) -> _PolishOutcome: error_count=0, converged=False, reason=REASON_NO_API_KEY, + # 循环没跑 ⇒ 裁判也未装配 ⇒ 保守记为降级（宁报降级不报可用）。 + judge_engine="rules_only", ) @@ -2323,17 +2386,30 @@ async def _run_polish( on_progress: Optional[Any] = None, should_stop: Optional[Any] = None, ) -> _PolishOutcome: - """跑一遍润色循环：Task 4 内核 + Task 5 白名单/钩子 + 适用性闸门。""" + """跑一遍润色循环：Task 4 内核 + Task 5 白名单/钩子 + 适用性闸门 + **语法裁判装配**。 + + 引擎来源（评审 RED#1 的闭环点）：先**只读**已加载模型（`get_loaded_nlp`，不触发加载/下载）； + 没有则在线程里尝试**仅本地**加载（`try_load_nlp_no_download` 绝不 `spacy.cli.download`， + 且同步函数放 `asyncio.to_thread` 里跑，不阻塞事件循环）。`nlp=None` ⇒ 裁判降级为 + `rules_only`、循环照常收敛，降级状态由 `judge_engine` 如实透出（响应体 `judge_degraded`）。 + """ import logging seen: List[str] = [] recorder = _PolishReplyRecorder(api_key, get_effective_api_base_url().rstrip("/")) + # 引擎解析：先只读 → 再线程内本地加载（无下载）。绝不阻塞事件循环、绝不触发出网。 + nlp = _nlp_processor.get_loaded_nlp() + if nlp is None: + nlp = await asyncio.to_thread(_nlp_processor.try_load_nlp_no_download) + judge_recorder = _JudgeRecorder(_make_judge(None, nlp)) try: loop = await polish_loop.run_polish_loop( text=text, tools=POLISH_TOOL_ALLOWLIST, dispatch=functools.partial(call_tool, hooks=(_make_tool_audit_hook(seen),)), violations_of=_a1_violations_if_letter, + # 必须真的注入（不能退回内核默认裁判）—— 否则生产上语法裁判恒不生效 = dead-green。 + judge=judge_recorder, chat=recorder, budget=polish_loop.Budget(), on_progress=on_progress, @@ -2358,22 +2434,29 @@ async def _run_polish( error_count=error_count, converged=loop.converged, reason=loop.reason, + judge_engine=judge_recorder.judge_engine, ) +def _judge_degraded(outcome: _PolishOutcome) -> bool: + """引擎降级标记（只增不改的响应字段）：`judge_engine != "rules+spacy"` ⇒ 语法族未启用。""" + return outcome.judge_engine != "rules+spacy" + + def _polish_payload(outcome: _PolishOutcome) -> Dict[str, Any]: - """`/api/writing/ai-polish` 的 `result`（**只增不改**：新增收敛两字段）。""" + """`/api/writing/ai-polish` 的 `result`（**只增不改**：追加 `judge_degraded`）。""" return { "corrected_text": outcome.text, "notes_zh": outcome.notes_zh, "error_count": outcome.error_count, "converged": outcome.converged, "unconverged_reason": None if outcome.converged else outcome.reason, + "judge_degraded": _judge_degraded(outcome), } def _polish_diff_payload(text: str, outcome: _PolishOutcome) -> Dict[str, Any]: - """`/api/writing/ai-polish/diff` 的 `result`（既有字段与顺序一律不动）。""" + """`/api/writing/ai-polish/diff` 的 `result`（既有字段与顺序一律不动，末尾追加 `judge_degraded`）。""" from delector.services.essay_diff import diff_sentences return { @@ -2384,6 +2467,7 @@ def _polish_diff_payload(text: str, outcome: _PolishOutcome) -> Dict[str, Any]: "error_count": outcome.error_count, "converged": outcome.converged, "unconverged_reason": None if outcome.converged else outcome.reason, + "judge_degraded": _judge_degraded(outcome), } diff --git a/delector/services/writing.py b/delector/services/writing.py index f2bb3a8d..1e524d69 100644 --- a/delector/services/writing.py +++ b/delector/services/writing.py @@ -604,7 +604,49 @@ def _normalize(s: str) -> str: return {"correct": False, "expected": expected_val, "user_answer": user_val} -def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None) -> Dict[str, Any]: +def collect_violations(analysis: Dict[str, Any]) -> List[Dict[str, Any]]: + """把一次裁判输出规整为**统一违规形状**，且只保留 `level == "error"`（阻止收敛的那一类）。 + + 统一形状：`{"rule": str, "level": "error"|"warning", "message": str, "span": tuple[int, int] | None}`。 + + 抽取顺序（Task 1 新增，`只增不改` 的落地）： + - **新键 `violations` 优先** —— `analyze_a1_email` 扩后的并列字段（格式族与语法族已按统一 + 形状并列其中）； + - 缺新键时回退 **legacy `suggestions`**（Task 4 起的旧形状），回退路径同样只取 + `level == "error"`。 + + 只取 error 的理由与 `polish_loop.default_violations_of` 一致：warning 是建议（字数偏短/ + 偏多、称呼语缺逗号…），不构成"不达标"；把 warning 也算违规 ⇒ 几乎所有 A1 短文永远 + `v > 0` ⇒ 循环永不收敛，那才是真正的静默失败。 + """ + if not isinstance(analysis, dict): + return [] + raw = analysis.get("violations") + if isinstance(raw, list): + source: List[Any] = raw + else: + legacy = analysis.get("suggestions") + source = legacy if isinstance(legacy, list) else [] + out: List[Dict[str, Any]] = [] + for item in source: + if not isinstance(item, dict) or item.get("level") != "error": + continue + span = item.get("span") + span_t: Optional[Tuple[int, int]] = None + if isinstance(span, (list, tuple)) and len(span) == 2: + span_t = (int(span[0]), int(span[1])) + out.append( + { + "rule": str(item.get("rule", "")), + "level": "error", + "message": str(item.get("message", "")), + "span": span_t, + } + ) + return out + + +def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None, nlp: Optional[Any] = None) -> Dict[str, Any]: """ Automated evaluation and diagnostics for Goethe A1 Teil 2 (ca. 30 Woerter E-Mail/Brief). Checks: @@ -613,6 +655,15 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None) -> Dict[ 3. Grussformel (Valediction) - presence, comma prohibition (NO comma after Viele Gruesse!). 4. Word count recommendation (25-35 words). 5. Leitpunkte coverage hints. + + 追加并列字段（Task 1/2，只增不改；既有键逐字不动）： + - `violations`：统一形状 `{rule, level, message, span}`（格式族 + 语法族并列）； + - `judge_engine`：`"rules+spacy"`（nlp 可用且语法族至少跑过一个检测器）/ `"rules_only"`（否则）。 + + **降级运行时 `converged` 的语义边界**（评审 RED#2 的诚实性，勿删）：`judge_engine == "rules_only"` + 时语法族**根本未检查**，此时「零违规 ⇒ 收敛」只代表**格式族**无阻塞性违规，**不等于**语法正确； + 任何人（判据表/发行说明/宣传文案）MUST NOT 把该次 `converged` 当作「全引擎零违规」的证据 + （运行期 fail-open，声明 / 门禁层 fail-closed）。 """ lines = [ln.strip() for ln in text.strip().split("\n") if ln.strip()] words = [w for w in re.findall(r"[a-zA-ZäöüÄÖÜß]+", text)] @@ -743,6 +794,34 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None) -> Dict[ leitpunkte_matches = sum(1 for r in leitpunkte_results if r["matched"]) + # ── 统一违规形状（Task 1 并列字段，只增不改）：格式族 + 语法族 ───────────── + # 既有 `suggestions` 逐字不动；这里只把它与语法族的 span 一并搬进统一的 + # {rule, level, message, span} 形状，供 `collect_violations` 与端点层同口径消费。 + violations: List[Dict[str, Any]] = [ + {"rule": s["rule"], "level": s["level"], "message": s["message"], "span": None} for s in suggestions + ] + judge_engine = "rules_only" + if nlp is not None and text and text.strip(): + # 沿用 `analyze_essay_text(text, nlp)` 的「显式传 nlp」惯例：不在模块内自读全局 nlp。 + doc = nlp(text) + for sent in doc.sents: + toks = list(sent) + if not toks: + continue + base = toks[0].idx + spans = detect_determiner_noun_agreement(toks, base) + detect_preposition_case(toks, base) + # 语法族至少跑过一个检测器（哪怕零违规）⇒ 引擎标记为 rules+spacy。 + judge_engine = "rules+spacy" + for sp in spans: + violations.append( + { + "rule": str(sp.get("error_type", "")), + "level": "error" if sp.get("severity") == "error" else "warning", + "message": str(sp.get("explanation_zh", "")), + "span": (int(sp["start"]), int(sp["end"])) if ("start" in sp and "end" in sp) else None, + } + ) + return { "word_count": word_count, "word_count_status": word_count_status, @@ -757,4 +836,6 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None) -> Dict[ "leitpunkte_matches": leitpunkte_matches, "leitpunkte_results": leitpunkte_results, "suggestions": suggestions, + "violations": violations, + "judge_engine": judge_engine, } diff --git a/tests/test_ai_polish_loop.py b/tests/test_ai_polish_loop.py index abea4076..abfad65c 100644 --- a/tests/test_ai_polish_loop.py +++ b/tests/test_ai_polish_loop.py @@ -535,18 +535,79 @@ def test_token_accounting_falls_back_to_estimate() -> None: assert completion_tokens_of({"x": sample}) == estimate_tokens(dump({"x": sample})) -def test_real_judge_is_wired_by_default() -> None: - """默认裁判 = `writing.analyze_a1_email`，默认抽取器只取 `level == 'error'`。""" - bad = "Liebe Maria,\nIch lade dich ein.\nViele Grüße,\nAnna" - good = "Liebe Maria,\nich lade dich ein.\nViele Grüße\nAnna" - rec = Recorder() +@pytest.fixture(scope="module") +def nlp() -> Any: + """真 spaCy 德语模型（沿用 `tests/test_writing_rules.py` 的 nlp fixture 惯例）；缺失 ⇒ skip。""" + import spacy - result = run(text=bad, chat=rec.chat([{"corrected_text": good}])) + try: + return spacy.load("de_core_news_sm") + except OSError: + pytest.skip("de_core_news_sm not installed") - assert result.converged is True, f"真实裁判下修好的文本 MUST 收敛：{result}" - assert result.reason == "ok" - assert result.text == good - # warning 级（如字数偏短）不构成违规 ⇒ 不得阻止收敛 + +def test_real_judge_is_wired_at_the_assembly_point(nlp: Any, monkeypatch: Any) -> None: + """**装配点**（旧 pin `test_real_judge_is_wired_by_default` 的裁决改造）。 + + 旧 pin 逐字钉住「内核默认裁判 == `writing.analyze_a1_email`」——那钉的是「业务住在机制 + 内核」。Task 1 的接缝方向相反：内核只留**可注入的缝**，业务由**产品层装配**。按计划 + Global Constraints 的裁决规则，把它从「默认值」改为「装配点」：断言生产链路 `_run_polish` + 传给 `run_polish_loop` 的 `judge=` 真是一个经 `analyze_a1_email(text, leitpunkte, nlp)` + 装配、且**带 nlp** 的裁判（证据 = 裁决体 `judge_engine == "rules+spacy"` 且语法违规出现）。 + + **这不是放宽**：旧 pin 钉「内核自带业务」，新 pin 钉「业务在产品层装配**且真送进循环**」 + —— 后者更强，能拦住「只改 `writing.py` 却没接到生产链路」的 dead-green。 + """ + from delector.nlp_engine import processor + from delector.routes.main import _run_polish + + captured: dict[str, Any] = {} + + async def _fake_loop(**kwargs: Any) -> Any: + captured.update(kwargs) + # 模拟循环至少裁一次原文 ⇒ 触发 `_JudgeRecorder` 记下 judge_engine。 + kwargs["judge"](kwargs["text"]) + return LoopResult(text=kwargs["text"], converged=True, reason="ok", rounds=0, violations=[]) + + monkeypatch.setattr("delector.services.polish_loop.run_polish_loop", _fake_loop) + monkeypatch.setattr("delector.routes.main.get_effective_api_base_url", lambda: "http://stub") + monkeypatch.setattr(processor, "get_loaded_nlp", lambda: nlp) + + outcome = asyncio.run(_run_polish("Ich habe ein Hund.", "sk-stub")) + + judge = captured.get("judge") + assert judge is not None, "端点 MUST 真的把 judge= 注入循环（否则生产上语法裁判恒不生效）" + verdict = judge("Ich habe ein Hund.") + assert verdict["judge_engine"] == "rules+spacy", "装配出的裁判 MUST 带 nlp" + assert any(v["rule"] == "artikel" for v in verdict["violations"]), "语法族 MUST 在装配出的裁判里生效" + assert outcome.judge_engine == "rules+spacy" + + +def test_endpoint_assembly_degrades_to_rules_only_when_no_nlp(monkeypatch: Any) -> None: + """装配点对照：nlp 来源不可用 ⇒ 装配出的裁判 `judge_engine == "rules_only"`（如实降级）。""" + from delector.nlp_engine import processor + from delector.routes.main import _run_polish + + captured: dict[str, Any] = {} + + async def _fake_loop(**kwargs: Any) -> Any: + captured.update(kwargs) + kwargs["judge"](kwargs["text"]) + return LoopResult(text=kwargs["text"], converged=True, reason="ok", rounds=0, violations=[]) + + monkeypatch.setattr("delector.services.polish_loop.run_polish_loop", _fake_loop) + monkeypatch.setattr("delector.routes.main.get_effective_api_base_url", lambda: "http://stub") + monkeypatch.setattr(processor, "get_loaded_nlp", lambda: None) + monkeypatch.setattr(processor, "try_load_nlp_no_download", lambda: None) + + outcome = asyncio.run(_run_polish("Ich habe ein Hund.", "sk-stub")) + + assert captured.get("judge") is not None + assert outcome.judge_engine == "rules_only" + + +def test_default_violations_extractor_ignores_warnings() -> None: + """默认抽取器只取 `level == 'error'`（warning 是建议，不阻止收敛）。""" assert default_violations_of({"suggestions": [{"rule": "a1_word_count", "level": "warning"}]}) == [] diff --git a/tests/test_goethe_a1_writing.py b/tests/test_goethe_a1_writing.py index 6ec0f30b..047a8cea 100644 --- a/tests/test_goethe_a1_writing.py +++ b/tests/test_goethe_a1_writing.py @@ -8,6 +8,7 @@ from pathlib import Path import pytest +import spacy os.environ.setdefault("DATABASE_PATH", "test_delector_goethe_a1_writing.db") from fastapi.testclient import TestClient @@ -16,7 +17,16 @@ from delector.routes.main import _a1_violations_if_letter from delector.server import app from delector.services.polish_loop import default_violations_of -from delector.services.writing import analyze_a1_email, check_a1_formular_answer +from delector.services.writing import analyze_a1_email, check_a1_formular_answer, collect_violations + + +@pytest.fixture(scope="module") +def nlp(): + """真 spaCy 模型（沿用 `tests/test_writing_rules.py` 的 nlp fixture 惯例）；缺失 ⇒ skip。""" + try: + return spacy.load("de_core_news_sm") + except OSError: + pytest.skip("de_core_news_sm not installed") def test_a1_writing_dict_dataset_integrity(): @@ -234,6 +244,31 @@ def test_a1_violations_gate_only_counts_when_text_is_a_letter(): assert len(_a1_violations_if_letter(verdict_letter)) >= 1 +def test_a1_violations_gate_does_not_count_grammar_for_non_letter_text(nlp): + """★ 本批「不改行为」的钉子：非书信体 + 语法错 ⇒ **MUST 仍不计数**。 + + 这是**故意钉住的当前行为**（语法族此刻**只对书信体生效**）—— **Task 7 会显式改写它** + （把闸门按规则族分流：格式/字数族只对书信体、语法族对**任意德语文本**生效）。钉在这里的 + **目的**：让「闸门被收窄」这件事**不可能被静默做掉** —— 谁把闸门改成按规则族分流，这条就红。 + + 判别力来源：先证语法错**真实存在**于裁决体（"ein Hund" ⇒ `artikel` 违规），再证闸门此刻 + **仍**对它返回 []（不是「没有违规可挡」的空转）。 + """ + verdict_essay = analyze_a1_email(_ESSAY_TEXT, nlp=nlp) + + # 前提①：非书信体（称呼语不合法 ⇒ 走旧闸门的「不适用」分支）。 + assert verdict_essay["greeting"]["valid"] is False + + # 前提②：语法族**确实**报出了违规（否则这条钉子就是空转 —— 挡了个不存在的东西）。 + essay_violations = collect_violations(verdict_essay) + assert any(v["rule"] == "artikel" for v in essay_violations), ( + f"冠词格错必须被语法族捕获（夹具失效？实际={essay_violations}）" + ) + + # 钉子：闸门**此刻故意**把非书信体的全部违规掐掉（含语法族）—— 语法族只对书信体生效。 + assert _a1_violations_if_letter(verdict_essay) == [] + + def test_ai_polish_endpoint_keeps_non_letter_polish(monkeypatch): """契约断言：非书信文本**不会**被回退成原文（端点级，走真链路）。 diff --git a/tests/test_server.py b/tests/test_server.py index ebacb895..9ab148b3 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -6674,6 +6674,132 @@ def test_ai_polish_letter_text_still_judged_by_a1_rules(client, monkeypatch): assert result["unconverged_reason"] == "no_improvement" +# ── Task 1/2 评审 RED#1 闭环：端点级接线回归 + 引擎降级诚实性 ────────────────── +# 书信体 + 冠词格错（"ein Hund" → "einen Hund"）的文本夹具。 +# 用**书信体**而非非书信体：RED#1 只要求"证明接缝是活的"，书信体已足够 —— +# 且能把本用例与 Task 7（HITL）的闸门收窄彻底解耦（非书信体的语法计数属 Task 7，此处不碰）。 +# 该文本无任何**格式/字数族 error**（称呼语合法、正文首词小写、结语无逗号） +# ⇒ 不接 nlp 时 v_0 == 0（这是本用例能判死"没接线"的前提）。 +_GRAMMAR_LETTER_TEXT = "Liebe Maria,\nich habe ein Hund.\nViele Grüße\nAnna" + + +def _real_nlp_or_skip() -> Any: + """加载真模型（沿用 `tests/test_writing_rules.py` 的 nlp fixture 惯例）；缺失 ⇒ skip。""" + import spacy + + try: + return spacy.load("de_core_news_sm") + except OSError: + pytest.skip("de_core_news_sm not installed") + + +def test_ai_polish_endpoint_counts_grammar_violations_on_letter_text(client, monkeypatch): + """★ 评审 RED#1 闭环点：端点级接线回归 —— 生产链路 MUST 把语法裁判真的送进循环。 + + 用**书信体 + 冠词格错**文本（书信体 ⇒ 闸门不豁免 ⇒ 语法违规照常计数）： + 桩模型**不修**该冠词错 ⇒ v_0 == v_1 == 1 ⇒ `no_improvement`（断言形态①：语法违规真被计数）。 + 若端点**不注入** `judge=`（退回内核默认裁判，不带 nlp）⇒ 语法违规静默消失，而该书信体文本 + 又无格式 error ⇒ v_0 == v_1 == 0 ⇒ **首轮即收敛** ⇒ 本用例 MUST 红（这就是 dead-green 的判别力）。 + """ + nlp = _real_nlp_or_skip() + _stub_api_key(monkeypatch) + # 桩模型只改结尾措辞、**不修**冠词错 ⇒ 裁判应判「改不动」 + chat = _ScriptedChat( + [{"corrected_text": "Liebe Maria,\nich habe ein Hund und freue mich.\nViele Grüße\nAnna", "notes_zh": ["x"]}] + ) + monkeypatch.setattr("delector.routes.main.llm_client.chat", chat) + monkeypatch.setattr("delector.nlp_engine.processor.get_loaded_nlp", lambda: nlp) + + result = client.post("/api/writing/ai-polish", json={"text": _GRAMMAR_LETTER_TEXT}).json()["result"] + + assert result["converged"] is False, "带冠词格错的书信体文本不该被判为已收敛" + assert result["unconverged_reason"] == "no_improvement", ( + "语法违规 MUST 被计数（否则端点没把语法裁判送进循环 = dead-green）" + ) + assert result["judge_degraded"] is False, "引擎可用 ⇒ judge_degraded 必须为 False" + + +def test_ai_polish_endpoint_reports_degraded_when_no_nlp(client, monkeypatch): + """引擎不可用 ⇒ 循环**照常收敛**（运行期 fail-open），但 `judge_degraded` MUST 如实为 True。 + + 红线 1：不得让「没检查」看起来像「检查通过」⇒ 声明层 fail-closed 靠这个布尔透出。 + """ + _stub_api_key(monkeypatch) + chat = _ScriptedChat([{"corrected_text": "Ich habe einen Hund. Er ist gut.", "notes_zh": ["x"]}]) + monkeypatch.setattr("delector.routes.main.llm_client.chat", chat) + monkeypatch.setattr("delector.nlp_engine.processor.get_loaded_nlp", lambda: None) + monkeypatch.setattr("delector.nlp_engine.processor.try_load_nlp_no_download", lambda: None) + + result = client.post("/api/writing/ai-polish", json={"text": _ESSAY_TEXT}).json()["result"] + + assert result["judge_degraded"] is True + # 降级不阻止收敛（fail-open）：非书信体 + 无语法裁判 ⇒ 首轮即接受 + assert result["converged"] is True + + +def test_get_loaded_nlp_is_read_only(monkeypatch): + """`get_loaded_nlp()` 只读已加载模型：未解析/加载失败 ⇒ None，且**绝不触发加载**。""" + from delector.nlp_engine import processor + + monkeypatch.setattr(processor, "_nlp_resolved", False) + monkeypatch.setattr(processor, "_nlp_model", None) + calls = {"n": 0} + + def _spy(name: str) -> Any: + calls["n"] += 1 + raise RuntimeError("不应被调用") + + monkeypatch.setattr(processor, "_load_spacy_model", _spy) + + assert processor.get_loaded_nlp() is None + assert calls["n"] == 0, "get_loaded_nlp 不得触发任何加载" + + sentinel = object() + monkeypatch.setattr(processor, "_nlp_resolved", True) + monkeypatch.setattr(processor, "_nlp_model", sentinel) + assert processor.get_loaded_nlp() is sentinel + + +def test_try_load_nlp_no_download_loads_locally(monkeypatch): + """本地能加载 ⇒ 写入既有缓存（`_nlp_model` / `_nlp_resolved=True`）并返回模型。""" + from delector.nlp_engine import processor + + sentinel = object() + monkeypatch.setattr(processor, "_nlp_resolved", False) + monkeypatch.setattr(processor, "_nlp_model", None) + monkeypatch.setattr(processor, "_load_spacy_model", lambda name: (sentinel, f"{name}(stub)")) + + assert processor.try_load_nlp_no_download() is sentinel + assert processor.get_loaded_nlp() is sentinel + + +def test_try_load_nlp_no_download_never_downloads(monkeypatch): + """★ 变异守卫：本地加载全失败 ⇒ MUST 返回 None，且**绝不**触发 `spacy.cli.download`。 + + 把 `try_load_nlp_no_download` 改成会走 download 的版本 ⇒ 本地加载既已失败，爆炸桩 + `spacy.cli.download` 会被命中 ⇒ 本用例红线。 + """ + from spacy import cli as spacy_cli + + from delector.nlp_engine import processor + + monkeypatch.setattr(processor, "_nlp_resolved", False) + monkeypatch.setattr(processor, "_nlp_model", None) + + def _boom(name: str) -> Any: + raise RuntimeError("no local model") + + monkeypatch.setattr(processor, "_load_spacy_model", _boom) + + def _bomb(*args: Any, **kwargs: Any) -> Any: + raise AssertionError("try_load_nlp_no_download 绝不能触发 spacy.cli.download（出网 + pip）") + + monkeypatch.setattr(spacy_cli, "download", _bomb) + + assert processor.try_load_nlp_no_download() is None, "本地失败 ⇒ 诚实返回 None（不抛、不下载）" + assert processor.get_loaded_nlp() is None, "失败 ⇒ 不写任何全局" + + def test_ai_polish_runs_tool_hooks_on_the_real_path(client, monkeypatch, caplog): """前置钩子链 MUST 在**真链路**上被跑过（不是只在单测里）：审计留痕 + 证据回喂。""" import logging diff --git a/tests/test_writing_rules.py b/tests/test_writing_rules.py index 79ccf3c5..f448fabd 100644 --- a/tests/test_writing_rules.py +++ b/tests/test_writing_rules.py @@ -351,3 +351,129 @@ def test_analyze_a1_email_capitalized_noun_exemption_and_expanded_valedictions() diag = analyze_a1_email(email) rules = [s["rule"] for s in diag["suggestions"]] assert "a1_valediction_missing" not in rules, f"{v} 应被识别为有效结语" + + +# ── Task 1/2：统一违规形状 + 引擎降级标记 + 接线既有语法算力 ────────────────── +# 统一违规形状：{"rule": str, "level": "error"|"warning", "message": str, "span": tuple|None} + + +def test_collect_violations_unified_shape_and_error_only(): + """`collect_violations` 只保留 `level=="error"` 并给出统一形状（warning 不阻止收敛）。""" + from delector.services.writing import collect_violations + + analysis = { + "violations": [ + {"rule": "a1_greeting_missing", "level": "error", "message": "缺称呼语", "span": None}, + {"rule": "a1_word_count", "level": "warning", "message": "字数偏短", "span": None}, + {"rule": "artikel", "level": "error", "message": "应为 einen", "span": (4, 13)}, + ] + } + out = collect_violations(analysis) + assert [v["rule"] for v in out] == ["a1_greeting_missing", "artikel"], "warning 不得入违规" + assert set(out[0].keys()) == {"rule", "level", "message", "span"} + assert out[1]["span"] == (4, 13) + + +def test_collect_violations_legacy_suggestions_fallback_error_only(): + """无新键 `violations` ⇒ 回退 legacy `suggestions`，且同样只取 `level=="error"`。""" + + from delector.services.writing import collect_violations + + analysis = { + "suggestions": [ + {"rule": "a1_greeting_missing", "level": "error", "message": "缺称呼语"}, + {"rule": "a1_word_count", "level": "warning", "message": "字数偏短"}, + ] + } + out = collect_violations(analysis) + assert [v["rule"] for v in out] == ["a1_greeting_missing"] + assert out[0]["span"] is None + + +def test_collect_violations_prefers_new_key_over_legacy(): + """新键 `violations` 存在时**优先**新键（legacy 不再被读）。""" + from delector.services.writing import collect_violations + + analysis = { + "violations": [{"rule": "kasus", "level": "error", "message": "m", "span": (0, 3)}], + "suggestions": [{"rule": "a1_greeting_missing", "level": "error", "message": "legacy"}], + } + assert [v["rule"] for v in collect_violations(analysis)] == ["kasus"] + + +def test_collect_violations_empty_analysis(): + from delector.services.writing import collect_violations + + assert collect_violations({}) == [] + assert collect_violations({"violations": []}) == [] + + +def test_analyze_a1_email_judge_engine_rules_only_without_nlp(): + """无 nlp ⇒ 只跑格式族，`judge_engine="rules_only"`（语法族不产违规）。""" + from delector.services.writing import analyze_a1_email + + diag = analyze_a1_email("Liebe Maria,\nich lade dich ein.\nViele Grüße,\nAnna") + assert diag["judge_engine"] == "rules_only" + assert all(v["rule"].startswith("a1_") for v in diag["violations"]), "无 nlp 时不应产语法违规" + + +def test_analyze_a1_email_judge_engine_rules_plus_spacy(nlp): + """nlp 可用且语法族跑过检测器 ⇒ `judge_engine="rules+spacy"`，语法违规并入 `violations`。""" + from delector.services.writing import analyze_a1_email + + diag = analyze_a1_email("Ich habe ein Hund.", nlp=nlp) + assert diag["judge_engine"] == "rules+spacy" + gram = [v for v in diag["violations"] if v["rule"] == "artikel"] + assert len(gram) == 1 + assert gram[0]["level"] == "error" + assert gram[0]["span"] == (9, 17) + assert "einen" in gram[0]["message"] + + +def test_analyze_a1_email_existing_keys_unchanged(nlp): + """只增不改：既有的 `suggestions` / `greeting` / `valediction` 等内容逐字不动。""" + from delector.services.writing import analyze_a1_email + + text = "Liebe Maria,\nich lade dich ein.\nViele Grüße,\nAnna" + diag = analyze_a1_email(text) + assert [(s["rule"], s["level"]) for s in diag["suggestions"]] == [ + ("a1_word_count", "warning"), + ("a1_valediction_comma", "error"), + ] + assert set(diag["suggestions"][0].keys()) == {"rule", "level", "message"} + assert diag["greeting"]["valid"] is True and diag["greeting"]["has_comma"] is True + assert diag["valediction"]["valid"] is True + assert diag["word_count"] == 9 and diag["word_count_status"] == "too_short" + # 并列新键：格式族进入统一形状（无 nlp ⇒ 只格式族；键集与建议一致地多一个 span） + assert [v["rule"] for v in diag["violations"]] == ["a1_word_count", "a1_valediction_comma"] + assert all(set(v.keys()) == {"rule", "level", "message", "span"} for v in diag["violations"]) + + +def test_analyze_a1_email_wires_grammar_and_preposition(nlp): + """负样本接线：冠词-名词一致 / 介词支配格 各报 1 条（经统一抽取器可见）。""" + from delector.services.writing import analyze_a1_email, collect_violations + + letter_bad_artikel = "Liebe Maria,\nich habe ein Hund.\nViele Grüße\nAnna" + v1 = collect_violations(analyze_a1_email(letter_bad_artikel, nlp=nlp)) + assert [v["rule"] for v in v1] == ["artikel"] and v1[0]["level"] == "error" + + letter_bad_kasus = "Liebe Maria,\nich fahre mit den Bus.\nViele Grüße\nAnna" + v2 = collect_violations(analyze_a1_email(letter_bad_kasus, nlp=nlp)) + assert [v["rule"] for v in v2] == ["kasus"] and v2[0]["level"] == "error" + + +def test_official_a1_samples_have_no_errors_under_wired_judge(nlp): + """硬门（D3）：官方 10 篇范文在接线后的裁判下 MUST 零**error** 级违规。 + + 连官方范文都报错 ⇒ 规则过严 ⇒ `v` 恒 > 0 ⇒ 循环永不收敛。故这是每加一条规则都要过的门。 + """ + from delector.data import a1_writing_dict + from delector.services.writing import analyze_a1_email, collect_violations + + samples = a1_writing_dict.A1_SCHREIBEN_TEIL2 + assert len(samples) >= 10 + for ex in samples: + diag = analyze_a1_email(ex["sample_email"], nlp=nlp) + got = collect_violations(diag) + assert got == [], f"官方范文被报违规（规则过严）: {ex['id']} -> {got}" + assert diag["judge_engine"] == "rules+spacy" From 37294b5484495b85bf717a1d91f2fb756d8453e6 Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 14:21:05 +0800 Subject: [PATCH 04/13] =?UTF-8?q?docs(plan):=20=E8=A1=A5=20Task=207=20?= =?UTF-8?q?=E7=9A=84=E5=89=8D=E7=AB=AF=E9=99=8D=E7=BA=A7=E6=8F=90=E7=A4=BA?= =?UTF-8?q?=E7=94=9F=E4=BA=A7=E8=80=85=20+=20Fog=20Unknown=20F=EF=BC=88And?= =?UTF-8?q?roid=20=E6=9C=AC=E5=9C=B0=E5=8A=A0=E8=BD=BD=E6=9C=AA=E9=AA=8C?= =?UTF-8?q?=E8=AF=81=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 评审黄卡：Global Constraints 要求「前端 MUST 给出可见提示」，但此前没有任何任务的 Files 覆盖 static/ ⇒ 该 MUST 无生产者；现挂到 Task 7 的 Files（非阻断提示，不是 error toast）。 Fog Unknown F：try_load_nlp_no_townload 不读 _android_runtime，Android 上模型缺失会每次重试本地加载（无记忆）；且若 _load_spacy_model 的路径回退命中，Android 反而能拿到 rules+spacy —— 真机未验证，归属已暂缓的点检。 --- docs/plans/2026-10-15-a1-judge-expansion.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/plans/2026-10-15-a1-judge-expansion.md b/docs/plans/2026-10-15-a1-judge-expansion.md index 3b2adf6e..383b05ce 100644 --- a/docs/plans/2026-10-15-a1-judge-expansion.md +++ b/docs/plans/2026-10-15-a1-judge-expansion.md @@ -212,6 +212,7 @@ **Files:** - Modify: `delector/routes/main.py`（`_a1_violations_if_letter` 的闸门范围 + **文本族感知的系统提示词装配**） +- Modify: `static/js/writer.js`（**降级可见提示的生产者** —— 评审黄卡：Global Constraints 要求"前端 MUST 给出可见提示"，但此前**没有任何任务的 Files 覆盖 `static/`** ⇒ 该 MUST 无生产者。实现：`judge_degraded === true` 时给一句**非阻断**提示（如"语法检查未启用：本机未加载德语模型，本次仅做格式/字数检查"），不是 error toast） - Modify: `delector/services/polish_loop.py`（**只加一个可选参数** `system_prompt: str | None = None`（None ⇒ 用现有 A1 默认值，向后兼容）；业务提示词由产品层传入 —— 见下方"立论冲突的解法"） - Modify: `docs/plans/2026-10-15-a1-judge-expansion.md`（本文件：记录解除判据与实测值） - Test: `tests/test_goethe_a1_writing.py` + **`tests/test_server.py`（评审黄卡：该文件此前未列入 ⇒ 会让一条既有回归闸变成 dead-green，见 scaffold ③）** @@ -281,6 +282,7 @@ - **[Unknown B] 官方评分维度的口径**：vault 内**没有**歌德 A1 Schreiben 官方评分表（已搜，零命中）⇒ 本计划以 ADR §4.3 点名的四项 + 实测可判性为准。若日后拿到官方评分表，维度优先级需重排（可能新增"语用/语域得体"）。 - **[Unknown C] 裁判变严对收敛率的影响**：error 级违规变多后，**官方范文仍必须 `v == 0`**（Task 2 起的硬门）；但真实用户文本的 `v` 分布会整体上移 ⇒ `max_turns=3` 是否够、`no_improvement` 是否会变成常态，须在有 Key 后回测（与 ADR §6 Unknown 2 同一笔账）。 - **[Unknown D] B1/B2 维度**：本计划只做 A1。跨等级复用（`syntax_score` 的 7 维难度 / `detect_*` 是否可参数化到 B1）不在此评估。 +- **[Unknown F] Android 上 `try_load_nlp_no_download()` 到底能不能加载成功（真机未验证）**：`processor.py:192-198` 的**导入期** Android 分支显式 `nlp=None`，但新助手走的是 `_load_spacy_model()` 的**路径回退**（glob `{name}-*`，`processor.py:61-72`）—— 而 Android 的模型正是"裸源码目录拷进 Chaquopy"。⇒ **若回退命中，Android 也能拿到 `rules+spacy`（比预期更好）；若失败，则 `rules_only` + 可见提示**。② 已知副作用（评审黄卡）：该助手**不读** `_android_runtime`，失败时也不写全局 ⇒ Android 上模型缺失会**每次润色都重试本地加载**（无记忆、重复耗时）。**验证归属**：Android 真机点检（用户 2026-10-15 指示暂缓）；若届时确认恒失败，再决定是"加 `if _android_runtime: return None`"还是"加进程内失败记忆"。 - **[Unknown E] Pi 式分层重构（已拍板：日后单独做，本计划不做）**：目标形态 = ① **层间类型三态递进**（`Tool` 名片 → `AgentTool extends Tool` 工人 → `ToolDefinition` 产品组件，**只加不改**）；② **依赖单向**（消掉实测到的两组双向耦合：`core ⇄ nlp_engine`、`services ⇄ tools`）；③ **层序声明**（当前仓内**零处**声明，导致 `LAYERED-ARCHITECTURE §1` 连"违规"都无法判定）；④ 把业务知识（A1 提示词 / 默认裁判）从机制内核提到产品层。**判据来源**：`01-Rules/LAYERED-ARCHITECTURE.md`（实证对象 = Pi-Agent 的 `pi-ai`/`pi-agent-core`/`pi-coding-agent`）+ 2026-10-15 双席位评审（code-reviewer/layering + sre-resilience）。**为什么现在不做**：三态递进需先有「第二个实现」才有内容（现只有一个工具面、一个裁判）——提前定接口正是 §2 反模式；且本子计划的目标是抬 §4.3 门槛，与分层重构正交。**将来启动时的前置**：先落层序声明，再做 ①②③④（顺序见评审报告）。 ## 🚫 Out of Scope From 5ddd1cceb40dc668701e8a924e828eaec85c6b3e Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 14:21:16 +0800 Subject: [PATCH 05/13] =?UTF-8?q?docs(plan):=20=E5=8B=BE=E9=80=89=20Task?= =?UTF-8?q?=201/2=20=E7=9A=84=20Step=20Breakdown=EF=BC=88=E9=9A=8F?= =?UTF-8?q?=E5=8F=B0=E8=B4=A6=20complete=20=E5=90=8C=E6=AD=A5=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/plans/2026-10-15-a1-judge-expansion.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/plans/2026-10-15-a1-judge-expansion.md b/docs/plans/2026-10-15-a1-judge-expansion.md index 383b05ce..fb65fe80 100644 --- a/docs/plans/2026-10-15-a1-judge-expansion.md +++ b/docs/plans/2026-10-15-a1-judge-expansion.md @@ -78,11 +78,11 @@ > "统一 A1 裁判的违规形状并加引擎降级标记。现状：`analyze_a1_email` 出 `{suggestions:[{rule,level,message}]}`（纯规则），而 `detect_*` 出 `{severity,error_type,corrected_form,explanation_zh,start,end}`（spaCy span）—— 两套形状让端点层 `_a1_violations_if_letter` 只能认一套。① 在 `delector/services/writing.py` 加 `collect_violations(analysis)`：统一形状 `{rule,level,message,span}`，**新键 `violations` 优先、legacy `suggestions` 回退**，`level` 只认 `error`（warning 不阻止收敛 —— 这是 Task 4/5/6 已钉死的语义）；② `analyze_a1_email` **追加**并列字段 `violations` 与 `judge_engine`（`rules+spacy` / `rules_only`），既有键与既有断言逐字不动；③ 端点 `_a1_violations_if_letter` 改用 `collect_violations`，`_PolishOutcome`/响应体加 `judge_engine`/`judge_degraded`（只增不改，前端文案表不动）。TDD：先在 `tests/test_writing_rules.py` 写 RED（统一形状 + 回退 + level 过滤），再实现。**④（评审 RED#1，MUST）堵接缝**：`processor.py` 加只读 `get_loaded_nlp()`（不触发加载/下载）；`_run_polish` 改为**注入** `judge=_make_judge(leitpunkte, get_loaded_nlp())`；新增 `_JudgeRecorder` 接住 verdict 里的 `judge_engine`；在 `tests/test_server.py` 加**走端点**的用例（注入可用 nlp + 喂带语法错的非书信体文本 ⇒ 断言违规真被计数 且 `judge_degraded is False`）。**⑤（评审 RED#2，MUST）降级诚实性**：`judge_engine` 如实透出（可用 ⇒ `rules+spacy`；不可用 ⇒ `rules_only`）并把 `judge_degraded` 送进响应体与前端提示；**运行期 fail-open**（Android `nlp=None`，fail-closed 会让 argmin 回退返回原文 = 功能报废）、**声明/门禁层 fail-closed**（Task 7 的判据表在 `judge_degraded==true` 时不得被用作"全引擎通过"的证据）。两条用例：引擎可用 ⇒ `judge_degraded is False`；引擎不可用 ⇒ `judge_degraded is True` 且 `converged` 的语义边界写进 docstring。禁止靠塞人造 violation 实现。RUN：`python -m pytest tests/test_writing_rules.py tests/test_server.py tests/test_goethe_a1_writing.py tests/test_ai_polish_loop.py -q`（既有断言只许新增不许放宽；那条 pin 按裁决规则改造并在提交信息写明）。" **Step Breakdown:** -- [ ] Step 1: 写失败测试（RED：统一形状 / legacy 回退 / `level=warning` 不入违规 / **端点接线** / **降级态不返回 converged:true**） -- [ ] Step 2: 跑并记录预期失败原文（**注意 RED 的形态是"报 0"或"字段缺失"，不是报错**） -- [ ] Step 3: 实现 `collect_violations` + `violations`/`judge_engine` 并列字段 + `get_loaded_nlp()` + `_make_judge`/`_JudgeRecorder` + 端点注入与 `judge_degraded` 透出（GREEN） -- [ ] Step 4: 变异自证（① 删回退分支 ⇒ 红；② 删 `level` 过滤 ⇒ warning 入违规 ⇒ 红；③ **端点不注入 judge（退回内核默认）⇒ 端点接线用例 MUST 红**；④ **`_make_judge` 去掉 fail-closed ⇒ 降级态用例 MUST 红**） -- [ ] Step 5: 关联套件 + `ruff` + mypy 四档 + 原子提交（提交信息逐条写明那条 pin 的改造理由） +- [x] Step 1: 写失败测试（RED：统一形状 / legacy 回退 / `level=warning` 不入违规 / **端点接线** / **降级态不返回 converged:true**） +- [x] Step 2: 跑并记录预期失败原文（**注意 RED 的形态是"报 0"或"字段缺失"，不是报错**） +- [x] Step 3: 实现 `collect_violations` + `violations`/`judge_engine` 并列字段 + `get_loaded_nlp()` + `_make_judge`/`_JudgeRecorder` + 端点注入与 `judge_degraded` 透出（GREEN） +- [x] Step 4: 变异自证（① 删回退分支 ⇒ 红；② 删 `level` 过滤 ⇒ warning 入违规 ⇒ 红；③ **端点不注入 judge（退回内核默认）⇒ 端点接线用例 MUST 红**；④ **`_make_judge` 去掉 fail-closed ⇒ 降级态用例 MUST 红**） +- [x] Step 5: 关联套件 + `ruff` + mypy 四档 + 原子提交（提交信息逐条写明那条 pin 的改造理由） --- @@ -103,11 +103,11 @@ **Step Breakdown:** - [x] **Step 0（✅ 2026-10-15 已跑，评审黄卡已消）**：官方 `A1_SCHREIBEN_TEIL2` 10 篇 `sample_email` 在两件既有算力下 **误报 0/10**（逐篇 `det=0 prep=0`；评审点名的高危句 `für Ihre 2-Zimmer-Wohnung` / `vom 15. bis 18. August` / `im Preis enthalten` 均不误报）⇒ **本任务是"接线"而非"修规则"**，硬门基线绿。执行时把这条基线**落成用例**（不是再跑一次人眼）。 -- [ ] Step 1: 写失败测试（RED：负样本两例报违规 + 官方 10 篇零违规门） -- [ ] Step 2: 跑并记录预期失败原文（**红色是"报 0"，不是"报错"**） -- [ ] Step 3: 实现接线（GREEN） -- [ ] Step 4: 变异自证（关掉一致性检查 ⇒ 负样本用例红；把双格介词豁免删掉 ⇒ 官方范文门红） -- [ ] Step 5: 关联套件 + ruff + mypy 四档 + 原子提交 +- [x] Step 1: 写失败测试（RED：负样本两例报违规 + 官方 10 篇零违规门） +- [x] Step 2: 跑并记录预期失败原文（**红色是"报 0"，不是"报错"**） +- [x] Step 3: 实现接线（GREEN） +- [x] Step 4: 变异自证（关掉一致性检查 ⇒ 负样本用例红；把双格介词豁免删掉 ⇒ 官方范文门红） +- [x] Step 5: 关联套件 + ruff + mypy 四档 + 原子提交 --- From deede44de6ce203935faa0f59d06400eb47d70be Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 16:22:52 +0800 Subject: [PATCH 06/13] =?UTF-8?q?feat(loop):=20=E5=86=85=E6=A0=B8=E6=8E=A5?= =?UTF-8?q?=E7=BC=9D=E5=8A=A0=E5=9B=BA=20=E2=80=94=E2=80=94=20dispatch=20?= =?UTF-8?q?=E8=B6=85=E6=97=B6=20+=20=E5=90=8C=E6=AD=A5=E8=A3=81=E5=88=A4?= =?UTF-8?q?=E7=A7=BB=E5=87=BA=E4=BA=8B=E4=BB=B6=E5=BE=AA=E7=8E=AF=20+=20?= =?UTF-8?q?=E4=BF=AE=E4=B8=8D=E5=8F=AF=E8=BE=BE=20except=EF=BC=88Task=208?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 由来：双席位评审的 RED#3 与 AGENT-SDK-PATTERNS 模式 3 要点 4。**不改**循环的停止策略/预算/收敛归属（Task 4 的 27 条断言原样），只补三处缝： ① dispatch 超时（polish_loop.py）：remaining_now 在调用前**重算**（不复用轮首那个——本轮 chat 已花时间），timeout = min(DEFAULT_PER_CALL_TIMEOUT_S, max(remaining_now, 0))；asyncio.TimeoutError ⇒ errors-as-messages 喂回模型（不炸循环、不冒泡），收口仍由轮首预算前置检查给原因码。注意 3.11+ 里 asyncio.TimeoutError is TimeoutError，故工具自抛 TimeoutError 也会被归为执行超时—— wait_for 方案的固有代价，已接受并注释。 ② 同步裁判移出事件循环：新增 _call_judge，两处调用点（v_0 基线 + 每轮收尾候选）都走它；iscoroutinefunction 为真则直接 await（否则 to_thread 会把 coroutine 对象当返回值 ⇒ 静默假收敛）。收益：长裁判不再阻塞同进程 /api/health 与其它路由；task.cancel() 掐得断等待（线程本身掐不断是 asyncio 既有语义，docstring 已如实写明）。 ③ 修 main.py 的不可达分支：_run_polish 早把 LLMError 转成 HTTPException(502, detail=…)，而 _polish_event_stream 写的 except llm_client.LLMError 永不命中 ⇒ error 帧永不发出、用户只拿到前端通用文案。选 (b) 流层捕 HTTPException 并发 detail 帧（理由：_run_polish 的失败契约对两种调用方保持同一形状；流已开头改不了状态码，error 帧是唯一能送达人话的通道；前端 writer.js 早已按 ev.event==='error'/ev.detail 消费）。 测试：+5 条（dispatch 超时喂回 / 心跳不被阻塞 / 取消可掐断在途裁判 / async 裁判须 await / SSE error 帧带 detail）。反挂死红线：所有 sleep 均有 wait_for/固定次数兜底，无 join、无无界 while；实测耗时 1.52/0.60/0.50/<0.005/0.04s。 评审 RED 卡的处理：CRV APPROVED（无红卡），其 1 条 flaky 黄卡已修（心跳窗口改跨调用取 max，余量从 ~0 提到 ~10 tick）并 20 连跑 PASS=20/20 + 变异自证（把 to_thread 改回同步直调 ⇒ 该用例红）。 门禁：411 passed（5 套件）；ruff check . 全绿；mypy --strict delector 66 files 0；契约闸 PASS；CRLF。 编排者注：本批两次派单被基础设施掐掉（10003/10101），flaky 那条 1 行修理由编排者按 CRV 开方直接改并自证（偏离 maker-checker，已如实记录）。 --- delector/routes/main.py | 14 ++- delector/services/polish_loop.py | 51 ++++++++- tests/test_ai_polish_loop.py | 186 +++++++++++++++++++++++++++++++ tests/test_server.py | 33 ++++++ 4 files changed, 279 insertions(+), 5 deletions(-) diff --git a/delector/routes/main.py b/delector/routes/main.py index 6f9ec77a..ad84c642 100644 --- a/delector/routes/main.py +++ b/delector/routes/main.py @@ -2520,8 +2520,20 @@ async def _runner() -> _PolishOutcome: try: outcome = await task - except llm_client.LLMError as e: + except HTTPException as e: # 流已经开了头（状态行已发出），改不了状态码 ⇒ 用一条 error 帧交代人话。 + # + # 为什么捕 `HTTPException` 而不是 `llm_client.LLMError`（接缝③）： + # `_run_polish` 早就把 `LLMError` 转成 `HTTPException(502, detail=e.detail)`， + # 这里写 `except llm_client.LLMError` **永不命中** ⇒ 异常裸抛到 + # StreamingResponse 外层 ⇒ starlette 抛 + # "Caught handled exception, but response already started" ⇒ 用户既拿不到 + # 状态码也拿不到 error 帧，只剩前端那句通用文案。 + # 选 (b) 而不是 (a)（让 `_run_polish` 在流式路径原样抛 LLMError）的理由： + # `_run_polish` 的失败契约对两种调用方 MUST 同一形状（都是 502 + 人话 + # detail），不该随「谁调它」变形；且流已开头、状态码改不了，error 帧是 + # 唯一能把 `e.detail` 送到用户面前的通道（前端 writer.js 已按 + # `ev.event === 'error'` / `ev.detail` 消费）。 yield _sse_frame({"event": "error", "detail": e.detail}) return payload = _polish_diff_payload(text, outcome) if with_diff else _polish_payload(outcome) diff --git a/delector/services/polish_loop.py b/delector/services/polish_loop.py index ebfb3e67..6498f9b1 100644 --- a/delector/services/polish_loop.py +++ b/delector/services/polish_loop.py @@ -58,7 +58,14 @@ - `converged=True ⇒ reason == "ok"`；未收敛 MUST 带原因码（零静默失败）； - 收尾候选 MUST 有**本轮新鲜裁判裁决**（D3），否则驳回并强制补跑一次裁判； -- 每轮开始**之前**先查 `max_tokens_total` 与 `deadline_s`，超支即带原因码退出。 +- 每轮开始**之前**先查 `max_tokens_total` 与 `deadline_s`，超支即带原因码退出； +- **每次 `dispatch` 都受超时约束**（Task 8 接缝①）：`min(DEFAULT_PER_CALL_TIMEOUT_S, 剩余 deadline)`， + 剩余 deadline 在调用前**重算**；`asyncio.TimeoutError` ⇒ errors-as-messages（喂回模型）， + **不炸循环、不冒泡** —— 收口仍由轮首的预算前置检查给原因码； +- **同步裁判 MUST 移出事件循环**（Task 8 接缝②）：经 `asyncio.to_thread` 跑 + ⇒ 长裁判不阻塞同进程其它路由，且 `task.cancel()` 掐得断在途裁判 + （线程本身掐不断，但循环不再等待它）；注入 async 裁判时直接 `await` + （否则 `to_thread` 会把 coroutine 对象当返回值 ⇒ 静默假收敛）。 ## 刻意不做 @@ -68,6 +75,8 @@ - `on_progress` 回调抛异常同样**原样冒泡**（UI 回调不该被静默吞掉）。 """ +import asyncio +import inspect import json import math import time @@ -265,6 +274,31 @@ def _default_judge(text: str, leitpunkte: list[str] | None) -> dict[str, Any]: return analyze_a1_email(text, leitpunkte) +async def _call_judge( + fn: Callable[[str, list[str] | None], Any], + text: str, + leitpunkte: list[str] | None, +) -> Any: + """调一次裁判：**同步裁判移出事件循环**（Task 8 接缝②）。 + + 为什么必须绕这一层（两处调用点都走它）： + + 1. **长裁判不阻塞同进程其它路由**：`analyze_a1_email` 是同步 CPU/IO 活，直接跑在 + 事件循环上会把 `/api/health` 与其它路由一起按在地上（实测单次可达数百 ms）； + 2. **取消可掐断**：跑在事件循环上时 `task.cancel()` 递不进去（取消要等协程让出 + 控制权，而同步函数不让）⇒ Task 6 的取消按钮对「在途裁判」无效。 + `asyncio.to_thread` 的等待点可取消：任务立刻收到 `CancelledError`， + 循环**不再等待**那个线程（线程本身掐不断，这是 asyncio 的既有语义）。 + + `iscoroutinefunction` 那一支**必须有**：注入方给了 async 裁判时，`to_thread` + 只会把 **coroutine 对象**当返回值交回来 ⇒ 上层拿到「没有裁决」⇒ 违规数恒 0 + ⇒ 循环静默假收敛（最危险的失败形态）。 + """ + if inspect.iscoroutinefunction(fn): + return await fn(text, leitpunkte) + return await asyncio.to_thread(fn, text, leitpunkte) + + def _make_default_dispatch( tools_map: Mapping[str, Callable[..., Awaitable[dict[str, Any]]]], ) -> Callable[[str, dict[str, Any]], Awaitable[dict[str, Any]]]: @@ -327,7 +361,7 @@ async def run_polish_loop( # v_0：先裁一次原文，给停止策略一个可比较的基线（裁判异常 ⇒ 单轮降级，不冒泡）。 try: - baseline_violations = violations_fn(judge_fn(text, leitpunkte)) + baseline_violations = violations_fn(await _call_judge(judge_fn, text, leitpunkte)) prev_v = len(baseline_violations) history.append((text, prev_v, baseline_violations)) except Exception as exc: # 宽捕是刻意的：errors-as-messages，任何裁判异常都不得冒泡 @@ -408,8 +442,17 @@ async def run_polish_loop( ) continue # 工具自身抛异常同样 errors-as-messages（不炸循环） + # 接缝①：dispatch 也 MUST 有超时。剩余 deadline 在**调用前重算**（不能复用 + # 轮首那个：本轮的 chat 已经花掉时间），口径与 chat 完全一致 —— + # min(每轮默认超时, 剩余 deadline)。剩余 ≤0 ⇒ timeout=0 ⇒ `wait_for` 立刻 + # 超时，同样喂回模型；下一轮轮首的预算前置检查会以 `deadline` 原因码收口。 + remaining_now = budget.deadline_s - (clock() - t0) + dispatch_timeout = min(DEFAULT_PER_CALL_TIMEOUT_S, max(remaining_now, 0.0)) try: - result = await dispatch_fn(name, payload) + result = await asyncio.wait_for(dispatch_fn(name, payload), timeout=dispatch_timeout) + except asyncio.TimeoutError: + # 超时是"证据"不是异常：喂回模型让它换招，循环不炸、不冒泡。 + result = {"error": f"工具 '{name}' 执行超时（>{dispatch_timeout:.1f}s）"} except Exception as exc: # 宽捕是刻意的：工具失败是"证据"，不是 500 result = {"error": f"工具 '{name}' 执行失败: {_brief(exc)}"} evidence = truncate_evidence(_render_evidence(result)) @@ -436,7 +479,7 @@ async def run_polish_loop( # 删掉这个守卫 ⇒ 裁判被跳过 ⇒ v_n 恒 0 ⇒ 循环**静默假收敛**（最危险的失败形态）。 if verdict_this_round is None: try: - verdict_this_round = judge_fn(candidate, leitpunkte) + verdict_this_round = await _call_judge(judge_fn, candidate, leitpunkte) except Exception as exc: # 宽捕是刻意的：Unknown D 按"会抛"设计 ⇒ 单轮降级 degraded = REASON_JUDGE_ERROR messages.append({"role": "user", "content": f"[裁判异常] {_brief(exc)}"}) diff --git a/tests/test_ai_polish_loop.py b/tests/test_ai_polish_loop.py index abfad65c..3ca28d77 100644 --- a/tests/test_ai_polish_loop.py +++ b/tests/test_ai_polish_loop.py @@ -17,6 +17,7 @@ import math import os import re +import time from typing import Any, Callable import pytest @@ -724,3 +725,188 @@ def test_truncate_evidence_is_pure_and_both_limits_are_independent() -> None: cut_bytes = truncate_evidence(one_huge_line) assert len(cut_bytes.splitlines()) == 1 assert len(cut_bytes.encode("utf-8")) <= EVIDENCE_MAX_BYTES + + +# ── Task 8 接缝加固：dispatch 超时 / 裁判移出事件循环 ────────────────────────── +# 反挂死红线：本区块每条用例都同时满足 +# 1) 所有 sleep 都有 `asyncio.wait_for` / 固定次数上限兜底（绝无无界 while）； +# 2) 取消语义只用 `task.cancel()` + `wait_for(..., timeout=...)`，**禁止 join 线程** +# （线程掐不断，join 会让整轮门禁挂死）。 +def test_tool_dispatch_timeout_is_fed_back_not_raised() -> None: + """接缝①：`dispatch` MUST 受 `min(剩余 deadline, DEFAULT_PER_CALL_TIMEOUT_S)` 约束。 + + 超时是**证据**（errors-as-messages），不是异常、不是 500：循环照常走到下一轮， + 由轮首的预算前置检查以 `deadline` 原因码收口（零静默失败）。 + `remaining` 在调用前**重算**（不能复用轮首那个：本轮 chat 已花掉时间）。 + + 时钟用**可推进的桩**（沿用本文件 `test_deadline_breaks_loop_...` 的惯例）：每次工具 + 超时只记 0.5s 墙钟，而真实等待是 1.0s ⇒ 第一次超时后仍有剩余 ⇒ 循环能多跑一轮， + 「超时作为证据喂回模型」这件事才**观测得到**（否则第 2 轮轮首就 deadline 退出， + 证据消息根本没机会进任何一次 chat 的 messages）。 + """ + rec = Recorder() + state = {"t": 0.0} + + def _clock() -> float: + return state["t"] + + def _advance() -> None: + state["t"] += 0.5 + + async def _slow_hang(name: str, payload: dict[str, Any]) -> dict[str, Any]: + _advance() # 假装这次工具调用烧掉了 0.5s 墙钟（真实等待是 1.0s） + await asyncio.sleep(30) + return {"never": True} + + async def _drive() -> Any: + # 外层 5s 兜底：实现侧 wait_for 被抽掉时本用例必须红（dispatch 会睡 30s）。 + return await asyncio.wait_for( + run_polish_loop( + text="T0", + tools={"known": echo_tool({"ok": True})}, + dispatch=_slow_hang, + chat=rec.chat([TOOL_CALL]), + judge=make_judge({"T0": 1}), + budget=Budget(deadline_s=1.0), + clock=_clock, + ), + timeout=5.0, + ) + + result = asyncio.run(_drive()) + + assert result.converged is False + assert result.reason == "deadline", f"超时只是证据，收口 MUST 是预算原因码：{result.reason}" + assert result.rounds == 2, f"第 3 轮轮首剩余 ≤0 ⇒ 直接退出：{result.rounds}" + assert any("执行超时" in c for c in rec.all_contents()), "工具超时 MUST 作为证据喂回模型（不是 500、不冒泡）" + assert len(rec.calls) == 2, f"两轮各调一次 chat（第 2 轮才带着证据上线）：{len(rec.calls)}" + + +def test_sync_judge_does_not_block_the_event_loop() -> None: + """接缝②：同步裁判 MUST 经 `asyncio.to_thread` —— 长裁判不阻塞同进程其它协程。 + + 探针是**有界**心跳协程（固定 20 次 × 0.02s 后自停，`finally` 里收尸），断言的是 + **裁判执行期间**心跳被推进的次数：裁判若直接同步跑在事件循环上，这 0.3s 内心跳 + 一次都跑不了（探针只观察行为，不耦合「用了线程」这个实现细节）。 + + 窗口取**跨调用最大值**（评审黄卡的修正）：循环会调两次裁判（v_0 基线 + 收尾候选）， + 而心跳寿命只有 ≈0.40s —— 若每次调用覆写 `window`，被测值就落在**第二次**窗口上 + （只剩约 5 tick，余量趋近零 ⇒ 精确计时平台会误红）。取 max 后基线那次窗口 + （≈15 tick）成为被测值，阈值 5 的余量 ≈10 tick。 + """ + ticks: list[int] = [] + window = {"during": 0} + + def _slow_judge(text: str, leitpunkte: list[str] | None = None) -> dict: + before = len(ticks) + time.sleep(0.3) # 长裁判（0.3s 有界；下方 wait_for 兜底，绝不挂死门禁） + window["during"] = max(window["during"], len(ticks) - before) + return {"suggestions": [{"rule": "r", "level": "error", "message": "m"}]} + + async def _drive() -> int: + async def _heartbeat() -> None: + # 有界：固定 20 次 × 0.02s = 0.4s 后自停（**禁止**无界 while 轮询）。 + for _ in range(20): + await asyncio.sleep(0.02) + ticks.append(1) + + hb = asyncio.ensure_future(_heartbeat()) + try: + await asyncio.wait_for( + run_polish_loop( + text="T0", + chat=Recorder().chat([{"corrected_text": "T1"}]), + judge=_slow_judge, + ), + timeout=5.0, + ) + finally: + # 心跳本身有界（0.4s）；这里再兜底 2s，本用例最坏耗时因此有上界。 + try: + await asyncio.wait_for(hb, timeout=2.0) + except asyncio.TimeoutError: + pass + return window["during"] + + during = asyncio.run(_drive()) + + assert during >= 5, f"裁判执行期间事件循环 MUST 仍能推进（实测 tick {during} 次）" + + +def test_cancel_interrupts_the_in_flight_sync_judge() -> None: + """接缝②：`task.cancel()` MUST 掐断在途同步裁判（修好前它跑在事件循环上，掐不断）。 + + 线程掐不断是事实，但循环**不再等待**它 ⇒ 取消在毫秒级返回。禁止 `join` 线程 + （那会把门禁挂死且语义也不对：我们断言的是「不再被等待」）。 + + 为什么必须同时断言**耗时**：裁判同步跑在事件循环上时，`await asyncio.sleep(0.1)` + 本身就被推迟到裁判跑完之后 ⇒ `task.cancel()` 也随之推迟 ⇒ `wait_for` 的 0.3s + 超时根本来不及触发（循环被占着）⇒ 只看「有没有超时」会**假绿**。故补一条 + 「取消 MUST 立刻返回」的耗时断言（修好后是毫秒级，没修好是 0.5s 级）。 + """ + def _slow_judge(text: str, leitpunkte: list[str] | None = None) -> dict: + time.sleep(0.5) # 有界：0.5s，由下方 cancel + wait_for(0.3) 兜底 + return {"suggestions": []} + + async def _drive() -> dict[str, Any]: + task = asyncio.ensure_future( + run_polish_loop( + text="T0", + chat=Recorder().chat([{"corrected_text": "T1"}]), + judge=_slow_judge, + ) + ) + # 等它进裁判：0.5s 的裁判此刻正在途（基线裁判在循环最前面，无需等太久）。 + await asyncio.sleep(0.1) + task.cancel() + started = time.perf_counter() + outcome = "returned" + try: + await asyncio.wait_for(task, timeout=0.3) + except asyncio.TimeoutError: + outcome = "timeout" + except asyncio.CancelledError: + outcome = "cancelled" + return {"outcome": outcome, "took": time.perf_counter() - started} + + snap = asyncio.run(_drive()) + + assert snap["outcome"] != "timeout", "取消未在 0.3s 内完成 ⇒ 在途裁判仍在阻塞等待" + assert snap["outcome"] == "cancelled", f"取消 MUST 真正传导到循环任务（实测 {snap['outcome']}）" + assert snap["took"] < 0.25, ( + f"取消 MUST 在裁判在途时立刻返回（实测 {snap['took']:.2f}s）" + " ⇒ 裁判仍在阻塞事件循环（连 cancel() 本身都被推迟到它跑完）" + ) + + +def test_async_judge_verdict_is_awaited_not_a_coroutine_object() -> None: + """接缝②：注入 `async def` 裁判 ⇒ 循环 MUST await 它，而不是把 coroutine 当裁决。 + + 判别力（删掉 `iscoroutinefunction` 那支 ⇒ 本用例红）：`to_thread` 会把 coroutine + **对象**当返回值交给 `violations_of` ⇒ 那不是 dict ⇒ 违规数恒 0 ⇒ 循环**静默假收敛**。 + 这里把 v_0（原文）= 0、v_1（候选）= 1 摆成「不降即停」： + - 正确：`no_improvement` + 回退原文； + - 退化：假收敛 + 把候选当答案返回。 + """ + seen: list[Any] = [] + + async def _async_judge(text: str, leitpunkte: list[str] | None = None) -> dict: + n = 0 if text == "T0" else 1 + return {"suggestions": [{"rule": f"r{i}", "level": "error", "message": f"v{i}"} for i in range(n)]} + + def _spy(verdict: Any) -> list[dict[str, Any]]: + seen.append(verdict) + return default_violations_of(verdict) + + result = run( + text="T0", + chat=Recorder().chat([{"corrected_text": "T1"}]), + judge=_async_judge, + violations_of=_spy, + ) + + assert len(seen) == 2, f"原文与收尾候选都要过裁判：{len(seen)}" + assert all(isinstance(v, dict) for v in seen), f"裁判交给循环的 MUST 是真裁决对象：{seen}" + assert result.converged is False, "async 裁判给候选判了 1 条违规，不得静默判成收敛" + assert result.reason == "no_improvement" + assert result.text == "T0" diff --git a/tests/test_server.py b/tests/test_server.py index 9ab148b3..1b3a5faa 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -7055,6 +7055,39 @@ async def send(message: Dict[str, Any]) -> None: assert all(e.get("event") != "result" for e in snap["frames"]), "已断开就不该再产出完整 result" +def test_ai_polish_stream_error_frame_carries_llm_detail(client, monkeypatch): + """接缝③：流已开头 ⇒ 上游 LLMError MUST 以 **error 帧**抵达用户（`e.detail` 人话）。 + + 事实链：`_run_polish` 捕获 `llm_client.LLMError` 后 `raise HTTPException(502, detail=e.detail)` + ⇒ 流层原本写的 `except llm_client.LLMError` **永不命中** ⇒ error 帧永不发出 ⇒ 用户只拿到 + 前端那句通用「润色流结束但没有返回结果」。修法选 **(b) 流层捕获 `HTTPException`**： + `_run_polish` 的契约对两种调用方保持同一形状（失败 ⇒ HTTPException(502)），流已经开了头 + 改不了状态码，只能在流内用 error 帧把人话送出去；前端 `writer.js` 也早已按 + `ev.event === 'error'` / `ev.detail` 消费。 + """ + from delector.services import llm_client + + _stub_api_key(monkeypatch) + # 裁判引擎 deliberately 置为不可用：本条只关心「错误怎么抵达用户」， + # 让 chat 第一轮就抛，别把时间花在加载真 spaCy 模型上。 + monkeypatch.setattr("delector.nlp_engine.processor.get_loaded_nlp", lambda: None) + monkeypatch.setattr("delector.nlp_engine.processor.try_load_nlp_no_download", lambda: None) + + async def _chat(**kwargs: Any) -> Dict[str, Any]: + raise llm_client.LLMError("DeepSeek 服务暂时不可用 (503)") + + monkeypatch.setattr("delector.routes.main.llm_client.chat", _chat) + + res = client.post("/api/writing/ai-polish/diff", json={"text": _ESSAY_TEXT, "stream": True}) + + assert res.status_code == 200 + events = _parse_sse(res.text) + errors = [e for e in events if e.get("event") == "error"] + assert errors, f"上游失败 MUST 以 error 帧抵达用户，实际帧：{events}" + assert "DeepSeek 服务暂时不可用 (503)" in errors[0]["detail"], f"error 帧 MUST 带 e.detail 人话：{errors[0]}" + assert all(e.get("event") != "result" for e in events), "失败路径不该再产出 result 帧" + + def test_frontend_polish_reason_copy_covers_every_reason_code(): """writer.js 的中文文案 MUST 覆盖 `polish_loop.REASONS` 全部成员 + 端点层 no_api_key。 From 55e9090909be7cef9ff70eac08408f533a050fde Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 16:23:42 +0800 Subject: [PATCH 07/13] =?UTF-8?q?docs(workmemory):=20=E8=A3=81=E5=88=A4?= =?UTF-8?q?=E9=9B=86=E6=89=A9=E5=85=85=E8=AE=A1=E5=88=92=E6=8E=A8=E8=BF=9B?= =?UTF-8?q?=E8=87=B3=203/8=20+=20=E5=8F=8C=E5=B8=AD=E4=BD=8D=E8=AF=84?= =?UTF-8?q?=E5=AE=A1=E7=BB=93=E8=AE=BA=E4=B8=8E=E4=B8=A4=E6=AC=A1=E5=8F=8D?= =?UTF-8?q?=E8=A3=81=E5=86=B3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- WORKMEMORY/work.log | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/WORKMEMORY/work.log b/WORKMEMORY/work.log index 9679058d..1944c778 100644 --- a/WORKMEMORY/work.log +++ b/WORKMEMORY/work.log @@ -519,3 +519,13 @@ Caps: filesystem-read, filesystem-write, shell-exec - **Why 现在不做**：三态递进需先有「第二个实现」才有内容（现仅一个工具面、一个裁判）——提前定接口正是 §2 反模式；且与本子计划（抬 §4.3 门槛）正交。 - **已登记**：写进新计划 `docs/plans/2026-10-15-a1-judge-expansion.md` 的 `Out of Scope`（本计划一切改动 MUST NOT 依赖该重构）+ `Fog of War [Unknown E]`（含四个子目标与将来启动的前置顺序）。 - **不阻塞**：三张 RED（接线缝 / fail-closed / 同步调用超时）**均可走"端点注入缝"修复，不需要这次重构**（这正是两个席位给出的"不改内核结构、允许经注入缝改变裁判语义"路径）。 + +### 2026-10-15 15:10 | codebuddy | NOTE +Caps: filesystem-read, filesystem-write, shell-exec +事件：ADR-0023 §4.3 续作（A1 裁判集扩充，计划 `docs/plans/2026-10-15-a1-judge-expansion.md`，8 任务）在分支 `feat/a1-judge-expansion` 上推进到 **3/8**（Task 1+2 合并交付 `88856ab`；Task 8 `deede44`）。 +- **开工前的双席位评审**（用户指示，按 `01-Rules/LAYERED-ARCHITECTURE` + `AGENT-SDK-PATTERNS`）：两席位均判「局部偏离」，核心是 **RED#1 接线缝缺失** —— 计划 7 个任务没写"谁把 `nlp` 交给裁判"，而 `_run_polish` 从不传 `judge=`、Out-of-Scope 又禁改内核 ⇒ **语法裁判在生产恒不生效而 7 任务测试可全绿**（dead-green），§4.3 判据表还能被打勾解除。据此把 Task 1/2 合并为**原子变更**（能力与接缝同批落地）。 +- **我对评审的两处反裁决（都有实测依据，已写进计划）**：① RED#2 的"降级即禁止收敛"**不采用** —— 实测 `processor.py:192-198` Android 显式 `nlp=None`，若禁止收敛则 `argmin` 回退返回**原文** = ADR §10.3 的功能报废回归；改为**运行期 fail-open + 显式标记 / 声明门禁层 fail-closed**。② maker 一度把 `_a1_violations_if_letter` 提前改成按规则族分流 —— 那是 **Task 7 的 HITL 行为变更**（语法违规开始计数后，模型修不动的作文会回退原文），已退回并加一条**非真空钉子**钉住「本批不改该行为」。 +- **Task 8（接缝加固）**：dispatch 加 `min(per-call, 剩余 deadline)` 超时（调用前重算剩余）、同步 `judge` 移 `asyncio.to_thread`（否则长裁判阻塞 `/api/health` 且 `task.cancel()` 掐不断）、修 `_polish_event_stream` 那个**永不命中**的 `except llm_client.LLMError`（`_run_polish` 早已把它转成 HTTPException）⇒ 改为捕 HTTPException 发 error 帧，`e.detail` 人话才到得了用户。 +- **基础设施坑（两次）**：两次 subagent 派单被掐（10003 / 10101），第一次留了半成品 + 一条取消用例跑不完（备份 `/tmp/task8-partial.diff` 后丢弃、重派成功）。**教训：给 maker 的反挂死纪律必须写进 prompt**（所有 sleep 要有 wait_for/固定次数兜底、禁 join 线程、禁无界 while、每条用例贴实测耗时）。Task 8 的 flaky 黄卡（心跳窗口余量趋零）由我按 CRV 开方改 1 行（跨调用取 max）并 20 连跑自证 —— 偏离 maker-checker，已如实记录在提交信息。 +- **门禁**：5 套件 411 passed；`ruff check .` 全绿；`mypy --strict delector` 66 files 0；契约闸 PASS；CRLF。 +- **未做**：Task 3/4/5（三个新维度规则）、Task 6（FP 标定，HITL）、Task 7（闸门收窄 + §4.3 判据表，HITL，含前端降级提示）。**Pi 式分层重构已由用户拍板暂缓**（`docs/agents/architecture.md` 已登记）。 From 39e6d79d66b5e3756bc7c616a6a64f9138164540 Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 18:13:19 +0800 Subject: [PATCH 08/13] =?UTF-8?q?feat(judge):=20=E4=B8=89=E4=B8=AA?= =?UTF-8?q?=E6=96=B0=E8=AF=AD=E6=B3=95=E7=BB=B4=E5=BA=A6=EF=BC=88=E4=B8=BB?= =?UTF-8?q?=E8=B0=93=E4=B8=80=E8=87=B4/=E5=8A=A8=E8=AF=8D=E6=94=AF?= =?UTF-8?q?=E9=85=8D=E6=A0=BC/=E4=B8=BB=E5=8F=A5=20V2=EF=BC=89+=20?= =?UTF-8?q?=E5=8A=A0=E5=AE=BD=E5=90=8E=E7=9A=84=E6=B0=B8=E4=B9=85=E7=A1=AC?= =?UTF-8?q?=E9=97=A8=EF=BC=88Task=203+4+5=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 新增三个确定性检测器并**同批接线**进 analyze_a1_email 的语法族分支（评审 RED#1 的教训：能力与接缝同批落地，否则 dead-green）： - detect_subject_verb_agreement（numerus）：只判「复数主语 + 单数动词」单向（反向第三人称单数形式不规则、corrected_form 不可靠 ⇒ 宁漏不误，docstring 已写明）。 - delector/data/a1_verb_case.py（29 条人工登记：Dat 7 / Acc 14 / Dat+Acc 8，禁 LLM 生成，逐分组来源注释）+ detect_verb_case_government（rektion）：比对表面形式 vs 目标格（直判 morph.Case 会因同形歧义误报），且**只检查被支配的格位**（Acc 动词只看 oa 宾语 ⇒ 自由第三格合法句不报）。 - detect_verb_second_position（wortstellung）：主句 V2 + 八条豁免（从句/疑问/祈使/并列/引语/无主语-多主语/逗号插入/换行 Vorfeld），主语 NP 内部修饰沿 head 链豁免（含焦点小词封闭词表：Auch/Nur/Sogar…；时间副词 MUST NOT 入表，否则负样本漏报）。 永久硬门加宽（两轮返工的产物）：官方 10 篇 sample_email 门之外，新增 COMMON_CORRECT_SENTENCES（47 句）逐句断言语法族零违规 + judge_engine=='rules+spacy'（防降级假绿），清单上方附**类覆盖清单**（NP 内修饰/焦点小词/自由第三格/及物不及物两可/前置状语/从句前置/疑问祈使）。 返工记录（评审 + 编排者实跑各抓出一类误报，全部先写用例跑红再修）： ① öffnen/bezahlen/schmeckt 移入 Dat+Acc 且改写不成立的 Acc 组断言； ② V2 把主语 NP 内部的副词修饰当独立前置成分（Meine sehr große Familie wohnt in Berlin.）； ③ V2 漏豁免焦点小词（Auch meine Familie wohnt…/Nur mein Bruder kommt…）+ rektion 把自由第三格当违规（Ich lese meinem Bruder das Buch.）。 编排者另做 30 句常见正确德语广度扫雷（零误报）后定稿。 打包面：polish_loop/polish_tools 之后，a1_verb_case 也登记进 package_windows.py + build-release.yml 两块 + tests/test_server.py 的 data_dict_modules（守卫集合是硬编码的，不登记即永久失明）。 门禁：97 passed（本面四套件）+ 打包面守卫 6 passed；ruff 全绿；mypy --strict delector 67 files 0；CRLF。 --- .github/workflows/build-release.yml | 2 + delector/data/a1_verb_case.py | 63 ++++ delector/services/writing.py | 470 +++++++++++++++++++++++++- package_windows.py | 1 + tests/test_a1_verb_case_data.py | 35 ++ tests/test_server.py | 2 + tests/test_writing_rules.py | 497 ++++++++++++++++++++++++++++ 7 files changed, 1069 insertions(+), 1 deletion(-) create mode 100644 delector/data/a1_verb_case.py create mode 100644 tests/test_a1_verb_case_data.py diff --git a/.github/workflows/build-release.yml b/.github/workflows/build-release.yml index 87131233..8682de68 100644 --- a/.github/workflows/build-release.yml +++ b/.github/workflows/build-release.yml @@ -120,6 +120,7 @@ jobs: --hidden-import=delector.data.core_dict_ext \ --hidden-import=delector.data.prep_dict \ --hidden-import=delector.data.a1_dict \ + --hidden-import=delector.data.a1_verb_case \ --hidden-import=delector.data.a1_writing_dict \ --hidden-import=delector.data.a1_hoeren_dict \ --hidden-import=delector.data.a1_lesen_dict \ @@ -218,6 +219,7 @@ jobs: --hidden-import=delector.data.core_dict_ext \ --hidden-import=delector.data.prep_dict \ --hidden-import=delector.data.a1_dict \ + --hidden-import=delector.data.a1_verb_case \ --hidden-import=delector.data.a1_writing_dict \ --hidden-import=delector.data.a1_hoeren_dict \ --hidden-import=delector.data.a1_lesen_dict \ diff --git a/delector/data/a1_verb_case.py b/delector/data/a1_verb_case.py new file mode 100644 index 00000000..83c6f425 --- /dev/null +++ b/delector/data/a1_verb_case.py @@ -0,0 +1,63 @@ +# -*- coding: utf-8 -*- +"""A1 高频动词 → 支配格（Rektion）**人工登记表**。 + +**这是事实数据，不是生成物**：每条都按「歌德 A1 词表（`delector/data/a1_dict.py::GOETHE_A1_VOCAB`） +＋ 教科书级支配格常识」逐条确认，禁止用 LLM 批量生成。收录标准 = **少而准**（FP 是敌人）： + +- 只收**严格单格**支配的动词（`Dat` 或 `Acc`）——检测器仅在「有冠词的宾语 NP ＋ 单数」时才报； +- 标 `Dat+Acc` 的动词（人三格物四格 / 自由第三格 freier Dativ / 格支配两可）**登记但不判** + —— 这些动词的宾语格位依句式而定，硬判必误报； +- 可分前缀动词（an|rufen）/ 反身动词（sich freuen）/ 名词化动词一律**不入表** + （检测器另有守卫，见 `delector/services/writing.py::detect_verb_case_government` 的 docstring）； +- 动词同时可接介词搭配（如 `helfen bei`、`danken für`）不影响本表 —— 那是 + `detect_preposition_case` / 固定搭配表的领域。 + +来源注释（按组给出，每组均为教科书级支配格常识 + 歌德 A1 词表在册动词）： +- `Dat` 组：`jemandem helfen / danken / gratulieren`（人三格）、`Das gefällt / gehört / + passt / fehlt mir`（A1 教材固定搭配）。 +- `Acc` 组：A1 教科书典型句式中只接四格宾语的及物动词（`etwas sehen / brauchen / suchen / + finden / lieben / grüßen / kennen / lesen / trinken / essen / hören / verstehen / + wiederholen / unterschreiben`）。**凡 A1 教科书级出现自由第三格（人三格附加宾）或双宾 + 用法的动词一律不进本组**：`jdm. die Tür öffnen` / `jdm. etw. bezahlen` 是 A1 教科书级 + 搭配 ⇒ `öffnen` / `bezahlen` 移入 `Dat+Acc`；`schmecken` 两可（`Das schmeckt mir.` + 三格 / `Ich schmecke den Wein.` 四格）⇒ 同样移入 `Dat+Acc`。 +- `Dat+Acc` 组（不判）：双宾「人三物四」（`jemandem etwas geben / bringen / zeigen / + schreiben / kaufen`）＋ 自由第三格（`jdm. die Tür öffnen` / `jdm. etw. bezahlen`）＋ + 两可支配（`schmecken`）。 +""" + +A1_VERB_CASES: dict[str, str] = { + # ── Dat（严格三格；`helfen / danken / gratulieren` = 人三格，A1 教材固定搭配）──────── + "helfen": "Dat", + "danken": "Dat", + "gratulieren": "Dat", + # Dat（`Das gefällt / gehört / passt / fehlt mir.` 句式）───────────────────────────── + "gefallen": "Dat", + "gehören": "Dat", + "passen": "Dat", + "fehlen": "Dat", + # ── Acc（严格四格；A1 教材典型句式只接四格宾语的及物动词）────────────────────────── + "sehen": "Acc", + "brauchen": "Acc", + "suchen": "Acc", + "finden": "Acc", + "lieben": "Acc", + "grüßen": "Acc", + "kennen": "Acc", + "lesen": "Acc", + "trinken": "Acc", + "essen": "Acc", + "hören": "Acc", + "verstehen": "Acc", + "wiederholen": "Acc", + "unterschreiben": "Acc", + # ── Dat+Acc（双宾 / 自由第三格 / 两可支配 ⇒ 登记但**不判**）──────────────────────── + "geben": "Dat+Acc", + "bringen": "Dat+Acc", + "zeigen": "Dat+Acc", + "schreiben": "Dat+Acc", + "kaufen": "Dat+Acc", + "öffnen": "Dat+Acc", + "bezahlen": "Dat+Acc", + "schmecken": "Dat+Acc", +} diff --git a/delector/services/writing.py b/delector/services/writing.py index 1e524d69..ff23ab6a 100644 --- a/delector/services/writing.py +++ b/delector/services/writing.py @@ -9,6 +9,7 @@ from typing import Any, Dict, List, Optional, Tuple from delector.core.lexicon import lookup_core_vocab +from delector.data.a1_verb_case import A1_VERB_CASES # 双格介词整组跳过（静动态依语境决定，纯规则极易误报） _TWO_WAY_PREPS = {"in", "an", "auf", "über", "unter", "vor", "hinter", "neben", "zwischen"} @@ -438,6 +439,467 @@ def detect_preposition_case(tokens: List[Any], base: int) -> List[Dict[str, Any] return spans +# ── 规则 C：主谓一致（Number 一致）──────────────────────────────────────────── +# FP 守卫③清单：Number 语义不可靠的形式/不定/指示代词作主语（spaCy 实测： +# 「Das sind meine Eltern.」里 das=Sing 而 sind=Plur —— 这是合法句 ⇒ 一律不判）。 +_NUMBER_UNRELIABLE_SUBJECTS = { + "man", + "es", + "das", + "dies", + "jemand", + "niemand", + "irgendwer", + "wer", + "was", + "etwas", + "nichts", + "alles", + "alle", + "jeder", + "manche", + "mehrere", + "viele", + "einige", +} + +# FP 守卫②清单：集合名词（语法格为单数，但常见误标/语义漂移风险）⇒ 不判。 +_COLLECTIVE_NOUNS = { + "familie", + "gruppe", + "team", + "klasse", + "mannschaft", + "gesellschaft", + "publikum", + "polizei", + "verein", + "firma", +} + +# 现在时第三人称复数与不定式同形（通则），唯一例外： +_IRREG_PLURAL_VERB_FORMS = {"sein": "sind"} + + +def _is_plural(num: Optional[str]) -> bool: + return (num or "").lower() in ("plur", "plural") + + +def _subject_is_coordinated(subj: Any, verb: Any) -> bool: + """FP 守卫①：主语含并列（sb 只代表第一个并列项，Number 属整个并列短语 ⇒ 不判）。 + + 实测结构：`Anna und Tom spielen` ⇒ sb=Anna(Sing)，`und`(CCONJ) 是 Anna 的孩子。 + """ + if subj.dep_ in ("cj", "cd"): + return True + if any(c.pos_ == "CCONJ" for c in subj.children): + return True + return any(c.dep_ in ("cj", "cd") and c.pos_ in ("NOUN", "PROPN", "PRON") for c in verb.children) + + +def _plural_verb_form(tok: Any) -> Optional[str]: + """生成现在时第三人称复数形式；不确定 ⇒ None（调用方跳过 —— 宁漏不误）。""" + if _first_morph(tok.morph.get("Tense")) != "Pres": + return None + lemma = (tok.lemma_ or "").lower().strip() + if not lemma: + return None + return _IRREG_PLURAL_VERB_FORMS.get(lemma, lemma) + + +def detect_subject_verb_agreement(tokens: List[Any], base: int) -> List[Dict[str, Any]]: + """规则 C：主语（`dep=="sb"`）的 Number 与定式动词的 Number 不一致。 + + 只报「复数主语 + 单数定式动词」这一个方向（实测锚点：`Die Kinder spielt im Garten.`）； + 反向（单数主语 + 复数动词）不判 —— 单数第三人称形式不规则面大（hilft/liest/isst…）， + 生成 `corrected_form` 不可靠 ⇒ 宁漏不误。 + + FP 守卫（逐条实测标定；②—⑦ 缺一条就会在真实文本上大批误报，唯 ① 例外 —— 当前单向 + 判据下它不可达/防御性、只会造成漏报、勿当有效拦截器）： + ① 并列主语（`Anna und Tom spielen` —— sb 只挂第一个并列项；「复数主语＋单数动词」单向 + 判定下此类句子的动词天然是复数、根本不进判定 ⇒ 该守卫当前不可达）； + ② 集合名词（`die Familie`）； + ③ `man` / 不定代词 / 形式主语（`Das sind meine Eltern.` 实测是合法句）； + ④ 复合时态（`hat ... gemacht`：句含过去分词 ⇒ 整句不判，Number 落在助动词上）； + ⑤ 数量词主语（`Zwei Stunden ist genug.` 实测是合法句 ⇒ 不判）； + ⑥ 不定式/动词短语主语（`Bücher lesen ist schön.` ⇒ Number 不适用）； + ⑦ 主语缺失（祈使句 / `es gibt` / 无 `sb` 的句子 ⇒ 天然零输出）。 + """ + spans: List[Dict[str, Any]] = [] + # FP 守卫④：句内存在过去分词（复合时态/被动）⇒ 整句不判。 + if any(_first_morph(t.morph.get("VerbForm")) == "Part" for t in tokens): + return spans + + for subj in tokens: + if subj.dep_ != "sb": + continue + verb = subj.head + if verb is None or verb.pos_ not in ("VERB", "AUX"): + continue + if _first_morph(verb.morph.get("VerbForm")) != "Fin": + continue + # FP 守卫③：形式/不定代词主语 + if subj.text.lower() in _NUMBER_UNRELIABLE_SUBJECTS: + continue + if subj.lemma_ and subj.lemma_.lower() in _NUMBER_UNRELIABLE_SUBJECTS: + continue + # FP 守卫②：集合名词主语 + if subj.pos_ in ("NOUN", "PROPN") and subj.lemma_.lower() in _COLLECTIVE_NOUNS: + continue + # FP 守卫⑤：主语是数量词短语（实测 `Zwei Stunden ist genug.` 是合法句 —— + # sb=Stunden(Plur) + ist(Sing)，德语里量词主语接单数动词是常见合法用法）。 + if any(c.pos_ == "NUM" for c in subj.children): + continue + # FP 守卫⑥：主语为不定式/动词短语（`Bücher lesen ist schön.`）⇒ Number 不适用。 + if subj.pos_ in ("VERB", "AUX") or _first_morph(subj.morph.get("VerbForm")) == "Inf": + continue + # FP 守卫①：并列主语 + if _subject_is_coordinated(subj, verb): + continue + + s_num = _first_morph(subj.morph.get("Number")) + if not s_num and subj.pos_ == "NOUN": + det = _np_det(subj) + s_num = _first_morph(det.morph.get("Number")) if det is not None else None + v_num = _first_morph(verb.morph.get("Number")) + if not s_num or not v_num: + continue + # 只报「复数主语 + 单数动词」方向（宁漏不误，见 docstring）。 + if not _is_plural(s_num) or _is_plural(v_num): + continue + + correct = _plural_verb_form(verb) + if not correct or correct.lower() == verb.text.lower(): + continue + start, end = _tok_off(verb, base) + spans.append( + { + "severity": "error", + "error_type": "numerus", + "corrected_form": correct, + "explanation_zh": ( + f"主语「{subj.text}」是复数，定式动词「{verb.text}」却是单数形式，应为「{correct}」。" + ), + "start": start, + "end": end, + } + ) + return spans + + +# ── 规则 D：动词支配格（Rektion）────────────────────────────────────────────── +# 词表是人工登记的事实数据（逐条来源注释见 delector/data/a1_verb_case.py）。 +_CASE_LABEL_ZH = {"Dat": "三格（Dativ）", "Acc": "四格（Akkusativ）"} + + +def detect_verb_case_government(tokens: List[Any], base: int) -> List[Dict[str, Any]]: + """规则 D：词表动词的支配格 vs 其宾语 NP 的实际格。 + + 实测锚点：`Ich helfe meinen Bruder.`（helfen 支配三格）⇒ 报 `meinem Bruder`； + `Ich helfe meinem Bruder.` ⇒ 0 条。 + + 实现要点（FP 是敌人 ⇒ 宁漏不误）： + - 只报**有冠词且单数**的宾语 NP：零冠词（`Ich danke dir.`）与复数宾语（Dat Plur 名词 + 还需 -n 词尾，只换冠词会给出半对纠正）一律跳过； + - 比对**表面形式 vs 目标格形式**（`decline_determiner`），不直判 `morph.Case` —— 实测 + `Ich helfe meiner Schwester.` 里 spaCy 把 Fem Dat 的 `meiner` 标成 `Gen`（同形歧义）， + 直判 morph 会误报合法句； + - 词表内标 `Dat+Acc` 的双宾动词（geben 等）不判； + - **只比对「占用被支配格位」的宾语**（如实跑标定，见守卫⑧）：目标格 = `Acc` 时，动词四格位 + （`oa` 孩子）**已被占用**的情况下，`da` 宾语是**自由第三格**（`jdm. etw.` 构造，与 + `Ich öffne jdm. die Tür.` 同类）⇒ MUST 不判。 + + FP 守卫：① 动词不在词表；② 反身（宾语是反身代词）；③ 可分前缀（`svp` 分裂前缀）； + ④ 名词化（动词 token 带限定词孩子 / pos 非 VERB）；⑤ `Dat+Acc`；⑥ 代词/零冠词宾语； + ⑦ 复数宾语；⑧ **自由第三格**（严格 `Acc` 动词 + 已有 `oa` 宾语时的 `da` 宾语）。 + + 守卫⑧ 的实跑锚点与取舍：`Ich lese meinem Bruder das Buch.` / `Ich suche meinem Bruder + die Schuhe.` 里 spaCy 给 `Bruder` 打 `da`、给 `Buch`/`Schuhe` 打 `oa` —— 旧实现把所有 + `oa`/`da` 宾语都拿去比对 Acc 目标格 ⇒ 合法句被报 `meinen Bruder`。自由第三格是 A1 教材级 + 普遍构造（`Ich öffne / wasche / lese / suche jdm. etw.`），故判据取「四格位已被 `oa` 占用时 + `da` 不判」；**代价（明知而接受）**：漏掉「本该 Dat 却写成 Acc 的双宾句」（人三物四里把三格 + 写成 `meinen Bruder`）—— 宁漏不误。反证据 `Ich verstehe der Frage.`（`da` 宾语、无 `oa` + 兄弟 = 真实格错）MUST 仍报，用例见 tests/test_writing_rules.py。 + """ + spans: List[Dict[str, Any]] = [] + for tok in tokens: + if tok.pos_ not in ("VERB", "AUX"): + continue + target = A1_VERB_CASES.get(tok.lemma_.lower()) + if target is None or target == "Dat+Acc": + continue + # 守卫③：可分前缀动词（`Ich rufe meine Mutter an.` —— an 的 dep=svp 且 head 是动词） + if any(c.dep_ == "svp" for c in tok.children): + continue + # 守卫②：反身（`Ich freue mich ...` —— mich 的 pos=PRF / Reflex=Yes） + if any(c.pos_ == "PRF" or _first_morph(c.morph.get("Reflex")) == "Yes" for c in tok.children): + continue + # 守卫④：名词化（`Das Lesen ...` —— 动词 token 带限定词孩子） + if any(c.pos_ == "DET" for c in tok.children): + continue + + # 守卫⑧（结构性 FP，实跑标定）：`oa` 孩子 = 该动词四格位已被占用的信号 —— + # 严格 Acc 动词只有在四格位**空着**时，`da` 宾语才可能是「四格被写成三格」的错句 + # （`Ich verstehe der Frage.` ⇒ 实测 `da`、无 `oa` ⇒ 仍报）；四格位被占用时，`da` 宾语 + # 是自由第三格（`Ich lese/suche jdm. etw.`）⇒ MUST 不判。取舍见 docstring（宁漏不误）。 + has_accusative_object = any(c.dep_ == "oa" for c in tok.children) + for obj in tok.children: + if obj.pos_ != "NOUN" or obj.dep_ not in ("oa", "da"): + continue + if target == "Acc" and obj.dep_ == "da" and has_accusative_object: + continue + det = _np_det(obj) + if det is None: + continue # 守卫⑥：零冠词 / 代词宾语 + number = _first_morph(obj.morph.get("Number")) or _first_morph(det.morph.get("Number")) + if not number or _is_plural(number): + continue # 守卫⑦：复数宾语 + dict_info = lookup_core_vocab(obj.lemma_) or lookup_core_vocab(obj.text) + real_gender = ( + (dict_info.get("gender") if dict_info else None) + or _first_morph(obj.morph.get("Gender")) + or _first_morph(det.morph.get("Gender")) + ) + form = decline_determiner(det.lemma_, real_gender, number, target) + if form is None or form.lower() == det.text.lower(): + continue # 表面形式已是目标格 ⇒ 判定通过 + start = min(det.idx, obj.idx) - base + end = max(det.idx + len(det.text), obj.idx + len(obj.text)) - base + spans.append( + { + "severity": "error", + "error_type": "rektion", + "corrected_form": f"{form} {obj.text}", + "explanation_zh": ( + f"动词「{tok.lemma_}」支配{_CASE_LABEL_ZH.get(target, target)}，" + f"「{obj.text}」前应为「{form}」而非「{det.text}」。" + ), + "start": start, + "end": end, + } + ) + return spans + + +# ── 规则 E：主句动词位置（V2）──────────────────────────────────────────────── +_FINITE_MOODS = {"Ind", "Imp", "Sub"} +# 非主句分句标记（德语 TIGER 依存标签，全部实测）：mo=从句谓词（`weil ich krank bin` 的 bin） +# · oc=宾语从句/引语内（`"Ich komme morgen."` 的 komme）· cp=从属连词提升 · cs=从属连词 +# · cj/cd/cc=并列分句（`... und mein Bruder isst.` 的 isst）· rc/re=关系从句 · mnr/par=附加语。 +_SUBORDINATE_DEPS = {"mo", "oc", "cp", "cs", "rc", "re", "mnr", "par", "cj", "cd", "cc"} +# 主语同一 NP 内部的依存标记（不算"额外前置成分"）。 +_NP_INTERNAL_DEPS = {"det", "nk", "pnc", "ag", "app", "pn", "cc", "cd", "cj"} +_QUOTE_CHARS = {'"', "„", "“", "”", "«", "»", "‚", "‘", "’"} + + +def _is_finite_verb(tok: Any) -> bool: + if tok.pos_ not in ("VERB", "AUX"): + return False + if _first_morph(tok.morph.get("VerbForm")) == "Fin": + return True + return _first_morph(tok.morph.get("Mood")) in _FINITE_MOODS + + +def _np_family_text(subj: Any, tokens: List[Any]) -> str: + """主语 NP 的完整文本（含限定词/定语/并列项；用于生成 corrected_form）。""" + members: Dict[int, Any] = {subj.i: subj} + for _ in range(4): + grew = False + for t in tokens: + if t.i in members or t.dep_ not in _NP_INTERNAL_DEPS: + continue + if t.head is not None and t.head.i in members: + members[t.i] = t + grew = True + if not grew: + break + return " ".join(members[k].text for k in sorted(members)) + + +# 焦点小词（Fokuspartikeln）—— **封闭词表**，只收「焦点标记」用法：语义上依附其后的成分 +# （`Auch meine Familie ...` / `Nur mein Bruder ...`），A1 教材级普遍构造。 +# MUST NOT 收：时间/频率/程度副词（`gestern / heute / morgen / jetzt / dann / sehr / oft` …）—— +# 实测两者在 spaCy 里**同形**（dep=`mo`、head 直挂主语），一旦混入就会让错误语序负样本 +# `Gestern ich habe gearbeitet.` 被豁免（V2 规则对 A1 最高频语序错永久失明，见用例 +# `test_v2_focus_particles_closed_list_excludes_time_adverbs`）。 +# 同理 MUST NOT 收 `erst / schon`：其主导用法是时间性状语（Vorfeld 位 ⇒ 正常 V2）， +# 与焦点用法不可区分 ⇒ 宁漏不误。 +_FOCUS_PARTICLES = frozenset( + { + "auch", + "nur", + "sogar", + "eben", + "genau", + "gerade", + "bloß", + "allein", + "insbesondere", + "wenigstens", + "zumindest", + "ausgerechnet", + "besonders", + "lediglich", + "speziell", + "mindestens", + "hauptsächlich", + } +) + + +def _is_focus_particle_in_subject_np(tok: Any, subj: Any) -> bool: + """tok 是否为**落在主语 NP 内部**的焦点小词（1~2 步进入主语名词或其限定词）。 + + 实测锚点（第三类 FP）：`Auch meine Familie wohnt in Berlin.` 的链 `Auch → Familie(sb)`（1 步）、 + `Nur mein Bruder kommt heute.` 的链 `Nur → mein(DET/`nk`) → Bruder(sb)`（2 步）—— 两条链上 + **都没有 ADJ**，故只靠「经过 ADJ」的判据整类漏掉 ⇒ 合法句被报 `Auch wohnt meine Familie`。 + 中间节点 MUST 是主语 NP 内部成分（`_NP_INTERNAL_DEPS`：det/nk/…），否则不算 NP 内部。 + """ + if tok.text.lower() not in _FOCUS_PARTICLES: + return False + node = tok + for _ in range(2): + parent = node.head + if parent is None or parent.i == node.i: + return False + if parent.i == subj.i: + return True + node = parent + if node.dep_ not in _NP_INTERNAL_DEPS: + return False + return False + + +def _is_inside_subject_np(tok: Any, subj: Any) -> bool: + """沿 head 链判定 tok 是否落在主语 NP 内部（主语 NP 的修饰链 / 焦点小词）。 + + 判据（逐条实测标定）： + ① **焦点小词**（封闭词表 `_FOCUS_PARTICLES`）：head 链 1~2 步进入主语 NP ⇒ 参与构成主语 NP + （`Auch meine Familie ...` / `Nur mein Bruder ...`，实测链上没有 ADJ ⇒ ② 覆盖不到）； + ② 其余词：head 链回溯可达主语，**且路径上经过形容词（ADJ）**。 + - 实测锚点（B 类 FP）：`Meine sehr große Familie wohnt in Berlin.` 里 `sehr` 的链 + `sehr(ADV, mo) → große(ADJ, nk) → Familie(sb)` 经过 ADJ ⇒ 是主语 NP 内部修饰语、豁免； + - 反例（MUST 继续报）：错误语序 `Gestern ich habe gearbeitet.` 里 spaCy 把状语 + `Gestern` 直接挂到主语 `ich` 上（`Gestern(ADV, mo) → ich(sb)`，实测），链上无 ADJ + ⇒ 不算 NP 内部成分 —— 「链可达主语」单独使用会漏报该负样本（实测踩坑后收紧）；该反例也是 + ① 只能用**封闭词表**而不能用「形态相同即豁免」的原因（`Gestern` 与 `Auch` 的解析形态一致）。 + 限步回溯，防解析异常成环。 + """ + if _is_focus_particle_in_subject_np(tok, subj): + return True + saw_adj = False + node = tok + for _ in range(8): + parent = node.head + if parent is None or parent.i == node.i: + return False # 抵达 ROOT（自环）仍未经过主语 ⇒ 不在主语 NP 内 + if node.pos_ == "ADJ": + saw_adj = True + if parent.i == subj.i: + return saw_adj + node = parent + return False + + +def detect_verb_second_position(tokens: List[Any], base: int) -> List[Dict[str, Any]]: + """规则 E：主句定式动词 MUST 落在第二位置（V2）。 + + 实测锚点：`Gestern habe ich gearbeitet.` ⇒ 0 条；`Gestern ich habe gearbeitet.` ⇒ 报 1 条。 + + 主句判定**优先用 dep 而不是标点**：候选定式动词的 head 链上出现从句/并列标记 + （`mo`/`oc`/`cp`/`cj`/`cd`…）即非主句 ⇒ 不判 —— 实测 `weil ich krank bin` 里 `bin` 的 + dep=`mo`、引语内 `komme` 的 dep=`oc`、并列分句 `isst` 的 dep=`cj`。 + + 豁免面（逐条用例见 tests/test_writing_rules.py）： + ① 从句 / ② 疑问句（含 `?` 或句首动词 V1）/ ③ 祈使句（Mood=Imp 或句首动词）/ + ④ 并列句第二分句 / ⑤ 直接引语（引号奇偶） / ⑥ 标题式片段（无主语 / 多主语 ⇒ 天然零输出）/ + ⑦ 主语与动词之间有逗号（称呼语 `Sehr geehrter Herr ...`、插入语）⇒ 宁漏不误； + ⑧ 动词前出现换行（称呼语/行边界被并进同一句）⇒ Vorfeld 不跨行 ⇒ 宁漏不误。 + + 判据本体：主语在定式动词**之后**（Vorfeld 是别的成分）⇒ 天然合法，不判；主语在动词之前时， + 仅当主语左侧还有**独立于该主语 NP 的成分**才报 —— 故「Vorfeld = 多 token 短语」 + （`Gestern Abend habe ich gearbeitet.` / `Am Montag habe ich Zeit.`）不会误报。 + + 「独立于主语 NP」MUST 沿 head 链判定（判据本体见 `_is_inside_subject_np`，实测锚点 + `Meine sehr große Familie wohnt in Berlin.`：`sehr` 的 dep=`mo`、head 链 + `sehr → große(ADJ) → Familie（主语）` —— 只按 dep 白名单会把 `sehr` 当独立 Vorfeld 成分 + ⇒ 误报；豁免仅当链可达主语**且经过 ADJ** —— 否则错误语序句 `Gestern ich habe gearbeitet.` + 会被漏报，此为收紧后的实测行为）。 + + 第三类实跑 FP 与补丁：**焦点小词**（`Auch meine Familie wohnt in Berlin.` / `Nur mein Bruder + kommt heute.`）的 head 链同样直挂主语 NP，但链上**没有 ADJ** ⇒ 上面那条判据整类漏掉、合法句被 + 报。故豁免面增补：词 ∈ **封闭**焦点小词表 `_FOCUS_PARTICLES` 且 head 链 1~2 步进入主语 NP。 + 时间/频率副词 MUST NOT 进表（`Gestern` 与 `Auch` 的解析形态实测一致，只能靠封闭词表区分）。 + """ + spans: List[Dict[str, Any]] = [] + if any(t.text == "?" for t in tokens): + return spans # 豁免②：疑问句（标点信号） + for v in tokens: + if not _is_finite_verb(v): + continue + if _first_morph(v.morph.get("Mood")) == "Imp": + continue # 豁免③：祈使句（形态信号） + if v.i == 0: + continue # 豁免②③：句首动词（V1 疑问 / 祈使 / 片段） + # 主句判定：head 链上出现从句/并列标记 ⇒ 该候选是子句谓词（豁免①④）。 + in_main = True + node = v + for _ in range(6): + if node.dep_ in _SUBORDINATE_DEPS or node.pos_ == "SCONJ": + in_main = False + break + parent = node.head + if parent is None or parent.i == node.i: + break # 到达 ROOT 且链上无从句标记 + node = parent + if not in_main: + continue + # 豁免⑤：直接引语（动词落在奇数个引号之后 ⇒ 处于引号对内）。 + if sum(1 for t in tokens if t.i < v.i and t.text in _QUOTE_CHARS) % 2 == 1: + continue + # 豁免⑥：无主语 / 多主语（含无人称被动、标题式片段）⇒ 天然零输出。 + # 多 sb 是解析不确定的信号：实测书信称呼语 `Sehr geehrter Herr Becker, ich interessiere ...` + # 会给动词挂上两个 sb（`Herr` 与 `ich`）⇒ 必须跳过，否则官方范文被误报。 + subj_children = [c for c in v.children if c.dep_ == "sb"] + if len(subj_children) != 1: + continue + subj = subj_children[0] + # 豁免⑦：主语与动词之间有逗号（称呼语 / 插入语 `Ich, ehrlich gesagt, habe ...`）⇒ 宁漏不误。 + if any(t.pos_ == "PUNCT" and subj.i < t.i < v.i for t in tokens): + continue + # 主语在动词之后 ⇒ Vorfeld 已被别的成分占据，语序合法。 + if subj.i > v.i: + continue + # 豁免⑧：Vorfeld 不跨行 —— 定式动词之前出现换行（称呼语/行边界吸收进同一句）⇒ 该 + # "前置成分"只是上一行残留（实测官方范文 `Liebe Sarah,\n\nes tut mir leid ...` 被并句）。 + if any("\n" in t.text for t in tokens if t.i < v.i): + continue + # 主语左侧的 token（排除标点与空白）：只有“独立于主语 NP 的成分”才算额外前置成分。 + left = [t for t in tokens if t.i < v.i and t.i < subj.i and t.pos_ not in ("PUNCT", "SPACE")] + if any(t.pos_ == "CCONJ" for t in left): + continue # 并列结构（解析复杂）⇒ 宁漏不误 + indep = [t for t in left if t.dep_ not in _NP_INTERNAL_DEPS and not _is_inside_subject_np(t, subj)] + if not indep: + continue # 主语左侧只有它自己的 NP 内部成分（`Meine Eltern ...`）⇒ 合法 V2 + vorfeld = " ".join(t.text for t in sorted(indep, key=lambda x: x.i)) + corrected = f"{vorfeld} {v.text} {_np_family_text(subj, tokens)}" + start, end = _tok_off(v, base) + spans.append( + { + "severity": "error", + "error_type": "wortstellung", + "corrected_form": corrected, + "explanation_zh": ( + f"德语主句定式动词必须占第二位（V2）：动词「{v.text}」之前已有前置成分「{vorfeld}」，" + f"主语「{subj.text}」不应再插在动词前（应为「{corrected}」）。" + ), + "start": start, + "end": end, + } + ) + return spans + + def _collect_prep_hints(tokens: List[Any], base: int) -> List[Dict[str, Any]]: """收集介词支配格内联提示。""" hints = [] @@ -809,7 +1271,13 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None, nlp: Opt if not toks: continue base = toks[0].idx - spans = detect_determiner_noun_agreement(toks, base) + detect_preposition_case(toks, base) + spans = ( + detect_determiner_noun_agreement(toks, base) + + detect_preposition_case(toks, base) + + detect_subject_verb_agreement(toks, base) + + detect_verb_case_government(toks, base) + + detect_verb_second_position(toks, base) + ) # 语法族至少跑过一个检测器（哪怕零违规）⇒ 引擎标记为 rules+spacy。 judge_engine = "rules+spacy" for sp in spans: diff --git a/package_windows.py b/package_windows.py index 8eb61d4e..da132440 100644 --- a/package_windows.py +++ b/package_windows.py @@ -340,6 +340,7 @@ def build_windows() -> None: "--hidden-import=delector.data.core_dict_ext", "--hidden-import=delector.data.prep_dict", "--hidden-import=delector.data.a1_dict", + "--hidden-import=delector.data.a1_verb_case", "--hidden-import=delector.data.a1_writing_dict", "--hidden-import=delector.data.a1_hoeren_dict", "--hidden-import=delector.data.a1_lesen_dict", diff --git a/tests/test_a1_verb_case_data.py b/tests/test_a1_verb_case_data.py new file mode 100644 index 00000000..a1d8edc5 --- /dev/null +++ b/tests/test_a1_verb_case_data.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +"""`A1_VERB_CASES` 数据自检（Task 4）。 + +词表是**人工登记的事实数据**（歌德 A1 词表 + 教科书级支配格常识），不是生成物 —— +这些用例是它的可证伪边界：键越界 / 值非法 / 空键 / 条目过少都会红。 +""" + +from delector.data.a1_dict import GOETHE_A1_VOCAB +from delector.data.a1_verb_case import A1_VERB_CASES + + +def _a1_lemma_set(): + lemmas = set() + for key, entry in GOETHE_A1_VOCAB.items(): + lemma = entry.get("lemma") if isinstance(entry, dict) else None + lemmas.add(str(lemma or key).strip().lower()) + return lemmas + + +def test_verb_cases_keys_are_a1_lemmas(): + """键 MUST ⊆ 歌德 A1 词表的 lemma 集（不许登记课外动词）。""" + lemmas = _a1_lemma_set() + unknown = sorted(k for k in A1_VERB_CASES if k.strip().lower() not in lemmas) + assert unknown == [], f"词表键必须在歌德 A1 词表内，未知键={unknown}" + + +def test_verb_cases_values_are_valid(): + """值 MUST ∈ {Dat, Acc, Dat+Acc}（第三种 = 两可支配 ⇒ 检测器不判）。""" + assert set(A1_VERB_CASES.values()) <= {"Dat", "Acc", "Dat+Acc"} + + +def test_verb_cases_min_size_and_no_empty_keys(): + """条目数 ≥ 5，且无空键（少而准是设计目标，但空数据不算数据）。""" + assert len(A1_VERB_CASES) >= 5 + assert all(k.strip() for k in A1_VERB_CASES) diff --git a/tests/test_server.py b/tests/test_server.py index 1b3a5faa..7934d8f8 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -4606,6 +4606,8 @@ def test_all_backend_modules_registered_in_all_packaging_targets(): "official_vocab_rich", "a1_fragments", "a1_sidecar", + # Task 4（rektion）：a1_verb_case 被 services/writing.py 静态导入 —— 漏登记 = 打包后 ModuleNotFoundError。 + "a1_verb_case", } # Phase 1 Task 4：8 个 routes_*.py 收进 delector.routes/ 子包，`routes_` 前缀由 # 包路径取代（delector.routes_a1 → delector.routes.a1）。漏改打包清单 = diff --git a/tests/test_writing_rules.py b/tests/test_writing_rules.py index f448fabd..7feac379 100644 --- a/tests/test_writing_rules.py +++ b/tests/test_writing_rules.py @@ -477,3 +477,500 @@ def test_official_a1_samples_have_no_errors_under_wired_judge(nlp): got = collect_violations(diag) assert got == [], f"官方范文被报违规（规则过严）: {ex['id']} -> {got}" assert diag["judge_engine"] == "rules+spacy" + + +# ── Task 3：主谓一致（Number 一致）─────────────────────────────────────────── + + +def _sent_spans(text, nlp, fn): + """按句切分、逐句调用检测器（与 analyze_essay_text / analyze_a1_email 的 base 口径一致）。""" + doc = nlp(text) + spans = [] + for sent in doc.sents: + toks = list(sent) + if not toks: + continue + spans.extend(fn(toks, toks[0].idx)) + return spans + + +def _numerus(text, nlp): + from delector.services.writing import detect_subject_verb_agreement + + return _sent_spans(text, nlp, detect_subject_verb_agreement) + + +def test_numerus_wrong_number_flagged(nlp): + """负样本：复数主语 + 单数定式动词 MUST 报 1 条（error_type=numerus）。""" + spans = _numerus("Die Kinder spielt im Garten.", nlp) + assert len(spans) == 1 + sp = spans[0] + assert set(sp.keys()) == {"severity", "error_type", "corrected_form", "explanation_zh", "start", "end"} + assert sp["severity"] == "error" + assert sp["error_type"] == "numerus" + assert "spielen" in sp["corrected_form"] + assert (sp["start"], sp["end"]) == (11, 17), "span 应指向出错的定式动词 spielt" + assert "Kinder" in sp["explanation_zh"] + + +def test_numerus_correct_number_clean(nlp): + """正样本：数一致 MUST 零误报。""" + assert _numerus("Die Kinder spielen im Garten.", nlp) == [] + + +def test_numerus_coordinated_subject_guard(nlp): + """FP 守卫①（防御性）：并列主语（sb 只挂第一个并列项，Number 是整个并列短语的属性）⇒ 不报。 + + 注意：当前「只报复数主语＋单数动词」判据下**该守卫不可达/防御性**（`Anna und Tom spielen` + 的动词天然是复数，本就不会进判定）—— 勿当有效拦截器；此用例仅锁行为不退化，将来放开 + 反向判定（单数主语＋复数动词）时该守卫才可能成为真实拦截。 + """ + assert _numerus("Anna und Tom spielen im Garten.", nlp) == [] + assert _numerus("Ich und du sind Freunde.", nlp) == [] + + +def test_numerus_collective_noun_guard(nlp): + """FP 守卫②：集合名词（die Familie）在语法上是单数 ⇒ 不报。""" + assert _numerus("Meine Familie ist groß.", nlp) == [] + assert _numerus("Die Familie meiner Frau wohnt in Berlin.", nlp) == [] + + +def test_numerus_indefinite_pronoun_guard(nlp): + """FP 守卫③：man / 不定代词 / 形式主语 das 的 Number 语义不可靠 ⇒ 不报（宁漏不误）。""" + assert _numerus("Man spielt im Garten.", nlp) == [] + assert _numerus("Das sind meine Eltern.", nlp) == [] + assert _numerus("Niemand kennt den Mann.", nlp) == [] + + +def test_numerus_perfect_tense_guard(nlp): + """FP 守卫④：复合时态（hat ... gemacht，Number 落在助动词上）⇒ 不报。""" + assert _numerus("Die Kinder haben im Garten gespielt.", nlp) == [] + assert _numerus("Meine Eltern sind gestern angekommen.", nlp) == [] + + +def test_numerus_quantity_phrase_guard(nlp): + """FP 守卫⑤：数量词短语作主语（`Zwei Stunden ist genug.` 实测是合法句）⇒ 不报。""" + assert _numerus("Zwei Stunden ist genug.", nlp) == [] + assert _numerus("Zehn Euro ist zu viel.", nlp) == [] + + +def test_numerus_infinitive_subject_guard(nlp): + """FP 守卫⑥：不定式/动词短语作主语（`Bücher lesen ist schön.`）⇒ 不报。""" + assert _numerus("Bücher lesen ist schön.", nlp) == [] + assert _numerus("Sport machen ist wichtig.", nlp) == [] + + +def test_numerus_missing_subject_guard(nlp): + """FP 守卫⑦：主语缺失（祈使句 / es gibt / 无 sb 的句子）⇒ 不报。""" + assert _numerus("Hilf mir bitte!", nlp) == [] + assert _numerus("Es gibt viele Leute in der Stadt.", nlp) == [] + assert _numerus("Heute ist es warm.", nlp) == [] + + +def test_numerus_wired_into_a1_judge(nlp): + """接线缝（RED#1 教训）：numerus 违规 MUST 经 analyze_a1_email 进统一违规形状。""" + from delector.services.writing import analyze_a1_email, collect_violations + + got = collect_violations(analyze_a1_email("Die Kinder spielt im Garten.", nlp=nlp)) + numerus_spans = [v for v in got if v["rule"] == "numerus"] + assert len(numerus_spans) == 1 + assert numerus_spans[0]["level"] == "error" + assert numerus_spans[0]["span"] is not None + + +# ── Task 4：动词支配格（Rektion）+ 人工词表 A1_VERB_CASES ───────────────────── + + +def _rektion(text, nlp): + from delector.services.writing import detect_verb_case_government + + return _sent_spans(text, nlp, detect_verb_case_government) + + +def test_rektion_dative_verb_with_accusative_object_flagged(nlp): + """负样本：helfen 支配三格，宾语却是四格形态 ⇒ 报 1 条（实测锚点）。""" + spans = _rektion("Ich helfe meinen Bruder.", nlp) + assert len(spans) == 1 + sp = spans[0] + assert set(sp.keys()) == {"severity", "error_type", "corrected_form", "explanation_zh", "start", "end"} + assert sp["severity"] == "error" + assert sp["error_type"] == "rektion" + assert sp["corrected_form"] == "meinem Bruder" + assert "helfen" in sp["explanation_zh"] + + +def test_rektion_dative_verb_with_dative_object_clean(nlp): + """正样本：helfen + 三格 ⇒ 0 条。 + + 含 `meiner Schwester` 这个关键 FP 样本：spaCy 把 Fem Dat 的 `meiner` 标成 Gen + （同形歧义）—— 该守卫按**表面形式 vs 目标格形式**比对，不依赖 morph.Case 直判。 + """ + assert _rektion("Ich helfe meinem Bruder.", nlp) == [] + assert _rektion("Ich helfe meiner Schwester.", nlp) == [] + + +def test_rektion_accusative_verb_flags_dative_object(nlp): + """负样本：verstehen 支配四格，宾语却是三格 ⇒ 报。""" + spans = _rektion("Ich verstehe der Frage.", nlp) + assert len(spans) == 1 + assert spans[0]["error_type"] == "rektion" + assert spans[0]["corrected_form"] == "die Frage" + + +def test_rektion_accusative_verb_with_accusative_object_clean(nlp): + """正样本：四格动词 + 四格宾语 ⇒ 0 条。""" + assert _rektion("Ich sehe den Mann.", nlp) == [] + assert _rektion("Ich lese den Brief.", nlp) == [] + + +def test_rektion_unknown_verb_guard(nlp): + """FP 守卫①：动词不在词表（besuchen）⇒ 不判。""" + assert _rektion("Ich besuche meinen Bruder.", nlp) == [] + + +def test_rektion_reflexive_guard(nlp): + """FP 守卫②：反身结构（sich freuen）⇒ 不判。""" + assert _rektion("Ich freue mich auf das Wochenende.", nlp) == [] + + +def test_rektion_separable_prefix_guard(nlp): + """FP 守卫③：可分前缀动词（an|rufen，分裂前缀 dep=svp）⇒ 不判。""" + assert _rektion("Ich rufe meine Mutter an.", nlp) == [] + + +def test_rektion_nominalized_verb_guard(nlp): + """FP 守卫④：名词化动词（das Lesen）⇒ 不判。""" + assert _rektion("Das Lesen ist wichtig.", nlp) == [] + + +def test_rektion_ambiguous_two_case_verbs_skipped(nlp): + """FP 守卫⑤：词表内标 `Dat+Acc` 的动词（geben/kaufen 等两可支配）⇒ 不判。""" + assert _rektion("Ich gebe dem Kind ein Buch.", nlp) == [] + assert _rektion("Ich kaufe den Mann ein Buch.", nlp) == [] + + +def test_rektion_pronoun_object_skipped(nlp): + """FP 守卫⑥：代词宾语（dir/ihm，无冠词）⇒ 不判。""" + assert _rektion("Ich danke dir.", nlp) == [] + assert _rektion("Ich helfe ihm.", nlp) == [] + + +def test_rektion_plural_object_skipped(nlp): + """宁漏不误：复数宾语跳过（Dat Plur 名词还需 -n 词尾，只换冠词给出半对纠正）。""" + assert _rektion("Ich helfe den Kindern.", nlp) == [] + assert _rektion("Ich helfe die Kinder.", nlp) == [] + + +def test_rektion_free_dative_and_ambiguous_verbs_skipped(nlp): + """A 类 FP（评审实跑锚点）：登记进 `Dat+Acc` 的动词 MUST 不判 —— + + 自由第三格（`jdm. die Tür öffnen` / `jdm. etw. bezahlen`）与两可支配（`schmecken`： + `Das schmeckt mir.` 三格 与 `Ich schmecke den Wein.` 四格都合法）硬判必误报。 + """ + assert _rektion("Ich öffne meinem Bruder die Tür.", nlp) == [] + assert _rektion("Ich bezahle meinem Vater das Essen.", nlp) == [] + assert _rektion("Ich schmecke den Wein.", nlp) == [] + + +def test_rektion_free_dative_with_strict_accusative_verb_skipped(nlp): + """第三类 FP（评审探针实跑锚点）：**严格 Acc 动词 + 自由第三格**（`jdm. etw.`）MUST 不报。 + + 实测：`Ich lese meinem Bruder das Buch.` / `Ich suche meinem Bruder die Schuhe.` 里 spaCy 给 + `Bruder` 打 `da`、给四格宾语 `Buch` / `Schuhe` 打 `oa` —— 旧实现把所有 `oa`/`da` 宾语都拿去 + 和 Acc 目标格比对 ⇒ 合法句被报 `corrected_form='meinen Bruder'`。自由第三格是 A1 教材级 + 普遍构造（`Ich öffne / lese / suche jdm. etw.`），故：四格位已被 `oa` 宾语占用的 `da` 宾语 + MUST 不判（判据本体与取舍见 `detect_verb_case_government` docstring）。 + """ + for text in [ + "Ich lese meinem Bruder das Buch.", + "Ich suche meinem Bruder die Schuhe.", + "Ich lese meinem Bruder die Zeitung.", + "Ich suche meiner Schwester den Regenschirm.", + ]: + assert _rektion(text, nlp) == [], f"自由第三格被误报: {text} -> {_rektion(text, nlp)}" + + +def test_rektion_accusative_verb_single_dative_shaped_object_still_flagged(nlp): + """反证据（防上一豁免过宽）：四格位**无人占用**时，`da` 宾语 MUST 仍按「格写错」报 1 条。 + + 实测（探针）：`Ich verstehe der Frage.` 里 spaCy 把宾语打成 `da`（无 `oa` 兄弟）—— 该句是 + **真实格错**（应为 `die Frage`，既有用例 `test_rektion_accusative_verb_flags_dative_object` + 已钉死）；`Ich brauche dem Buch.` 同理（应为 `das Buch`）。豁免若按「da 一律不判」实现就会把 + 这两句一起漏掉，本条锁死「只有四格位被 `oa` 占用时，`da` 才是自由第三格」这条判据。 + """ + sp = _rektion("Ich verstehe der Frage.", nlp) + assert len(sp) == 1 and sp[0]["corrected_form"] == "die Frage" + sp2 = _rektion("Ich brauche dem Buch.", nlp) + assert len(sp2) == 1 and sp2[0]["corrected_form"] == "das Buch" + + +def test_rektion_wired_into_a1_judge(nlp): + """接线缝（RED#1 教训）：rektion 违规 MUST 经 analyze_a1_email 进统一违规形状。""" + from delector.services.writing import analyze_a1_email, collect_violations + + got = collect_violations(analyze_a1_email("Ich helfe meinen Bruder.", nlp=nlp)) + rektion_spans = [v for v in got if v["rule"] == "rektion"] + assert len(rektion_spans) == 1 + assert rektion_spans[0]["level"] == "error" + assert rektion_spans[0]["span"] is not None + + +# ── Task 5：主句动词位置（V2）──────────────────────────────────────────────── + + +def _v2(text, nlp): + from delector.services.writing import detect_verb_second_position + + return _sent_spans(text, nlp, detect_verb_second_position) + + +def test_v2_wrong_position_flagged(nlp): + """负样本（实测锚点）：主语插在 Vorfeld 与定式动词之间 ⇒ 报 1 条。""" + spans = _v2("Gestern ich habe gearbeitet.", nlp) + assert len(spans) == 1 + sp = spans[0] + assert set(sp.keys()) == {"severity", "error_type", "corrected_form", "explanation_zh", "start", "end"} + assert sp["severity"] == "error" + assert sp["error_type"] == "wortstellung" + assert sp["corrected_form"] == "Gestern habe ich" + assert "habe" in sp["explanation_zh"] or "V2" in sp["explanation_zh"] + + +def test_v2_correct_position_clean(nlp): + """正样本（实测锚点）：单 token / 多 token Vorfeld（PP、ADV+名词）⇒ 0 条。 + + `Gestern Abend habe ich gearbeitet.` 与 `Am Montag habe ich Zeit.` 是多 token 前置短语 —— + 按 token index 硬判会误报，本实现按「主语是否在动词前 + 其左侧有无独立成分」判定。 + """ + assert _v2("Gestern habe ich gearbeitet.", nlp) == [] + assert _v2("Am Montag habe ich Zeit.", nlp) == [] + assert _v2("Gestern Abend habe ich gearbeitet.", nlp) == [] + assert _v2("Die Kinder spielen im Garten.", nlp) == [] + assert _v2("Ich habe Hunger.", nlp) == [] + assert _v2("Meine Eltern haben mir ein Buch gekauft.", nlp) == [] + + +def test_v2_subject_np_internal_modifier_exempt(nlp): + """B 类 FP（评审补充实跑锚点）：主语 NP **内部**的副词修饰不算独立 Vorfeld 成分 ⇒ 0 条。 + + 实测链：`Meine sehr große Familie wohnt in Berlin.` 里 `sehr`（dep=`mo`）→ `große`（ADJ） + → `Familie`（主语）—— 只按 dep 白名单会把 `sehr` 当独立前置成分 ⇒ 误报。 + """ + for text in [ + "Meine sehr große Familie wohnt in Berlin.", + "Ein wirklich guter Film läuft heute.", + "Meine sehr nette Nachbarin hilft mir oft.", + "Zwei sehr schöne Blumen blühen.", + "Sehr guter Kaffee kommt aus Brasilien.", + ]: + assert _v2(text, nlp) == [], f"NP 内部修饰误报: {text} -> {_v2(text, nlp)}" + + +def test_v2_focus_particle_inside_subject_np_exempt(nlp): + """第三类 FP（评审探针实跑锚点）：**焦点小词**挂在主语 NP 上 ⇒ 不算独立 Vorfeld 成分 ⇒ 0 条。 + + 实测链：`Auch → Familie`（1 步到主语）、`Nur → mein(DET) → Bruder`（2 步）—— 两条链上**都没有 + ADJ**，故旧判据（「必须经过 ADJ」）整类漏掉，把 `Auch` / `Nur` 当独立前置成分 ⇒ 合法句被报 + `Auch wohnt meine Familie`。豁免判据 = 该词是**封闭焦点小词表**（`_FOCUS_PARTICLES`）成员且 + head 链 1~2 步进入主语 NP；时间副词 MUST NOT 进表（见下一条用例）。 + """ + for text in [ + "Auch meine Familie wohnt in Berlin.", + "Nur mein Bruder kommt heute.", + "Auch mein Bruder arbeitet in Berlin.", + "Nur meine Schwester wohnt hier.", + "Sogar mein Vater kocht heute.", + "Auch meine Eltern arbeiten hier.", + "Gerade mein Bruder hilft mir oft.", + ]: + assert _v2(text, nlp) == [], f"焦点小词误报: {text} -> {_v2(text, nlp)}" + + +def test_v2_focus_particles_closed_list_excludes_time_adverbs(nlp): + """防退化（焦点小词豁免的边界，MUST NOT 松）：时间副词**不得**进 `_FOCUS_PARTICLES`。 + + 理由（实测）：错误语序 `Gestern ich habe gearbeitet.` 里 `Gestern` 的 dep=`mo`、head 直挂主语 + —— 与 `Auch meine Familie ...` 的 `Auch` 在 spaCy 里**形态相同**，两者只能靠封闭词表区分。 + 词表一旦混入时间副词，V2 规则对「状语 + 主语 + 定式动词」这类错误（A1 最高频语序错）永久 + 失明。本条钉死词表成员口径；行为侧由下方真前置状语负样本锁住。 + """ + from delector.services.writing import _FOCUS_PARTICLES + + for adv in ("gestern", "heute", "morgen", "jetzt", "dann", "später", "abends", "früher", "oft"): + assert adv not in _FOCUS_PARTICLES, f"时间/频率副词「{adv}」不得进焦点小词表" + + +def test_v2_fronted_adverbial_still_flagged_after_np_guard(nlp): + """反证据（防豁免过宽）：错误语序里真前置状语（head 链到主语/动词、链上无 ADJ）⇒ MUST 仍报。 + + 实测坑：`Gestern ich habe gearbeitet.` 里 spaCy 把 `Gestern` 直接挂到主语 `ich` 上 + （`Gestern → ich`）—— 「head 链可达主语」单独使用会把它误豁免 ⇒ 豁免因此额外要求 + 链上经过 ADJ（`sehr → große(ADJ) → Familie`），本条锁死该收紧不回退。 + """ + for text in [ + "Gestern ich habe gearbeitet.", + "Heute meine Familie wohnt in Berlin.", + "Jetzt ich gehe nach Hause.", + "Am Montag ich habe Zeit.", + "Sehr ich habe mich gefreut.", + "In Berlin meine Familie wohnt.", + # 焦点小词豁免（F2）落地后追加：时间副词前置 + 主语插在动词前 = A1 最高频语序错， + # 与焦点小词在 spaCy 里同形（head 直挂主语）⇒ MUST 仍全部报（防豁免过宽）。 + "Morgen ich fahre nach Berlin.", + "Heute ich trinke Kaffee.", + ]: + assert len(_v2(text, nlp)) == 1, f"真前置成分被漏报: {text} -> {_v2(text, nlp)}" + + +def test_v2_subordinate_clause_exempt(nlp): + """豁免①从句：从属连词引导的分句里 V2 不成立（实测 `bin`/`regnet` 的 dep=mo）⇒ 0 条。""" + assert _v2("Ich bleibe zu Hause, weil ich krank bin.", nlp) == [] + assert _v2("Wenn es regnet, bleibe ich zu Hause.", nlp) == [] + + +def test_v2_question_exempt(nlp): + """豁免②疑问句：V1/疑问语序 ⇒ 0 条。""" + assert _v2("Hast du Zeit?", nlp) == [] + assert _v2("Warum hast du keine Zeit?", nlp) == [] + + +def test_v2_imperative_exempt(nlp): + """豁免③祈使句 ⇒ 0 条。""" + assert _v2("Komm bitte her!", nlp) == [] + assert _v2("Machen Sie bitte das Fenster zu!", nlp) == [] + + +def test_v2_coordinated_clause_exempt(nlp): + """豁免④并列句：第二分句（`isst` 的 dep=cj）与并列主语 ⇒ 0 条。""" + assert _v2("Ich koche Kaffee, und mein Bruder isst Kuchen.", nlp) == [] + assert _v2("Mein Bruder und ich gehen ins Kino.", nlp) == [] + + +def test_v2_quoted_speech_exempt(nlp): + """豁免⑤直接引语：引号内的句子（实测 `komme` 的 dep=oc + 引号奇偶双保险）⇒ 0 条。""" + assert _v2('Er sagt: "Ich komme morgen."', nlp) == [] + + +def test_v2_fragment_exempt(nlp): + """豁免⑥标题式片段 / 无主语句（含无人称被动）⇒ 0 条。""" + assert _v2("Viele Grüße aus Berlin.", nlp) == [] + assert _v2("Heute wird viel gearbeitet.", nlp) == [] + + +def test_v2_salutation_line_break_not_flagged(nlp): + """实测 FP 源（官方范文 email_03/email_06）：称呼语被 spaCy 并进正文句 —— + `Herr` 会成为第二个 sb（豁免⑥多主语）、或跨行 Vorfeld（豁免⑧换行）⇒ 不报。""" + assert _v2("Sehr geehrter Herr Becker,\n\nich interessiere mich sehr für Ihre Wohnung.", nlp) == [] + assert _v2("Liebe Sarah,\n\nes tut mir leid, aber ich muss am Freitag arbeiten.", nlp) == [] + + +def test_v2_wired_into_a1_judge(nlp): + """接线缝（RED#1 教训）：wortstellung 违规 MUST 经 analyze_a1_email 进统一违规形状。""" + from delector.services.writing import analyze_a1_email, collect_violations + + got = collect_violations(analyze_a1_email("Gestern ich habe gearbeitet.", nlp=nlp)) + v2_spans = [v for v in got if v["rule"] == "wortstellung"] + assert len(v2_spans) == 1 + assert v2_spans[0]["level"] == "error" + assert v2_spans[0]["span"] is not None + + +# ── 永久硬门（D）：≥20 句合法德语 MUST 零（语法族）违规 ──────────────────────── +# 背景：官方 10 篇范文门（test_official_a1_samples_have_no_errors_under_wired_judge）放过 +# 三类实跑误报 —— ① 主语 NP 内副词修饰（`Meine sehr große Familie...` 报 wortstellung） +# ② 自由第三格/两可动词（`Ich öffne meinem Bruder die Tür.` 报 rektion） +# ③ 焦点小词（`Auch meine Familie wohnt in Berlin.` 报 wortstellung）—— 范文里没有这些句式 +# ⇒ 单靠范文门不足以防 FP。本清单为**永久硬门**：每句都实跑确认零语法族违规后才登记。 +# +# **类覆盖清单（加句子前 MUST 逐类过一遍 —— 只加句子不检类，门会再次变窄，本轮就是这么漏的）**： +# ① 主语 NP 内部修饰：副词（`sehr`）/ 形容词（`guter`）/ **分词**（`von mir gekaufte`）/ +# **介词短语**（`im blauen Hemd`） +# ② 焦点小词（Fokuspartikeln，封闭词表 `_FOCUS_PARTICLES` / `writing.py::_is_inside_subject_np`） +# ③ 自由第三格 `jdm. etw.`（严格 Acc 动词 + 三格宾语）+ 人三物四（`Dat+Acc` 登记不判） +# ④ 及物 / 不及物两可（`schmecken`：`Das schmeckt mir.` 与 `Ich schmecke den Wein.`） +# ⑤ 前置状语 / 介词短语后的正常 V2 +# ⑥ 从句前置的主从复合 +# ⑦ 疑问句 / 祈使句（V1、`?`、Mood=Imp） +# 新增句子时逐类核对：任一类句式若无在册句子 ⇒ 该类对 FP 失明（本门的真实失败模式）。 +COMMON_CORRECT_SENTENCES: list[str] = [ + # ① 主语 NP 内修饰 —— 副词/形容词（B 类 FP 覆盖） + "Meine sehr große Familie wohnt in Berlin.", + "Ein wirklich guter Film läuft heute.", + "Meine sehr nette Nachbarin hilft mir oft.", + "Zwei sehr schöne Blumen blühen.", + "Sehr guter Kaffee kommt aus Brasilien.", + "Ganz besonders gute Ideen sind wichtig.", + # ① 主语 NP 内修饰 —— 分词 / 介词短语（CRV 指出此前无任何用例的句式） + "Die von mir gekaufte Uhr funktioniert.", + "Der Mann im blauen Hemd arbeitet hier.", + # ② 焦点小词（Fokuspartikeln）—— `Auch` / `Nur` 的 head 直挂主语 NP，链上无 ADJ + "Auch meine Familie wohnt in Berlin.", + "Nur mein Bruder kommt heute.", + "Auch mein Bruder arbeitet in Berlin.", + "Nur meine Schwester wohnt hier.", + "Sogar mein Vater kocht heute.", + "Auch meine Eltern arbeiten hier.", + "Gerade mein Bruder hilft mir oft.", + # ③ 自由第三格 `jdm. etw.`（严格 Acc 动词 lesen/suchen + 三格宾语）/ 人三物四 + "Ich öffne meinem Bruder die Tür.", + "Ich bezahle meinem Vater das Essen.", + "Ich gebe dem Kind ein Buch.", + "Ich zeige meiner Freundin die Fotos.", + "Ich kaufe meinem Mann ein Buch.", + "Ich lese meinem Bruder das Buch.", + "Ich suche meinem Bruder die Schuhe.", + "Ich lese meinem Bruder die Zeitung.", + "Ich suche meiner Schwester den Regenschirm.", + # ④ 及物/不及物两可的动词 + "Ich schmecke den Wein.", + "Das schmeckt mir gut.", + "Die Suppe schmeckt sehr gut.", + "Ich öffne die Tür.", + # ⑤ 前置介词短语 / 时间状语后 V2 正常语序 + "Am Montag habe ich Zeit.", + "Gestern Abend habe ich gearbeitet.", + "Am Wochenende fahre ich nach Berlin.", + "Heute Morgen trinke ich Kaffee.", + # ⑥ 从句在前的主从复合 + "Weil ich müde bin, gehe ich schlafen.", + "Wenn es regnet, bleibe ich zu Hause.", + "Wenn ich Zeit habe, komme ich zu dir.", + "Obwohl es kalt ist, gehe ich spazieren.", + # ⑦ 疑问句 / 祈使句 + "Kannst du mir die Tür öffnen?", + "Kochst du heute Kaffee?", + "Öffne bitte die Tür!", + # 常见 A1 基础句（回归护栏） + "Ich lerne jeden Tag Deutsch.", + "Meine Eltern wohnen in Hamburg.", + "Der Mann liest ein Buch.", + "Die Kinder spielen im Garten.", + "Ich trinke morgens Kaffee.", + "Sie liest die Zeitung.", + "Wir sehen einen Film.", + "Er braucht eine Pause.", + "Der Film ist wirklich gut.", + "Mein Bruder arbeitet in einer Firma.", + "Heute ist das Wetter schön.", + "Im Sommer fahren wir ans Meer.", +] + + +def test_common_correct_sentences_grammar_gate(nlp): + """永久硬门：`COMMON_CORRECT_SENTENCES` 每句 MUST 零**语法族**违规（nlp fixture 下）。 + + 判据口径（对任务原话的客观修正，非放水）：清单是裸句（非邮件），格式族 + `a1_greeting_missing` 对任何无称呼语输入**必然**报 error —— 与语法误报无关 ⇒ 门只断言 + 语法族（rule 不以 `a1_` 开头），并以 `judge_engine == "rules+spacy"` 证明语法族真跑过 + （防门空转：将来若接线断开、语法族不跑，本门 MUST 红）。 + """ + from delector.services.writing import analyze_a1_email, collect_violations + + # 防静默缩水（变异自证③）：清单**只增不减** —— 抽掉任一句（含本轮新增 16 句）即红。需要删句时 + # MUST 在 diff 里写明「该句本身不合法」的理由，并同步下调此下限（删句唯一正当理由）。 + assert len(COMMON_CORRECT_SENTENCES) >= 51, "硬门清单只增不减（上一轮 35 句 → 本轮 51 句，覆盖七类句式）" + for s in COMMON_CORRECT_SENTENCES: + diag = analyze_a1_email(s, nlp=nlp) + assert diag["judge_engine"] == "rules+spacy", f"语法族未跑（门空转）: {s}" + got = [v for v in collect_violations(diag) if not v["rule"].startswith("a1_")] + assert got == [], f"合法句被语法族误报: {s} -> {got}" From 209cc24bcb83c1b807e4bb4d520bc5b99c1eeb75 Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 18:13:41 +0800 Subject: [PATCH 09/13] =?UTF-8?q?test(judge):=20FP=20=E6=A0=87=E5=AE=9A?= =?UTF-8?q?=E5=B7=A5=E5=85=B7=EF=BC=88=E6=83=85=E6=80=81=E6=A1=86=E6=9E=B6?= =?UTF-8?q?=E8=AF=AD=E5=BA=8F=20/=20=E8=BF=87=E5=8E=BB=E9=94=9A=E6=97=B6?= =?UTF-8?q?=E6=80=81=E4=B8=80=E8=87=B4=E6=80=A7=EF=BC=89=E2=80=94=E2=80=94?= =?UTF-8?q?=20Task=206=20=E7=9A=84=20AFK=20=E5=8D=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 新增 tools/bench_judge_fp.py + tests/test_judge_fp_bench.py：可复跑的确定性标定实验（只标定不接线、不裁决）。 - 正样本 = 官方 A1_SCHREIBEN_TEIL2 的 10 篇 sample_email（逐句 35 句）；负样本 = 两维各 >=5 句手工定向错误句 + 正确对照组，逐句标注期望（否则 FP/FN 不可分）。 - 输出含误报/漏报样例全文（只报比例无法证伪判据）；退出码 0=标定完成 / 1=样本集无效 / 2=环境不可用（import spacy 移入受护区 + probe_environment 单一归口，有测试钉住）。 - 实测数据：正样本两维 FP 均 0/35；A 维（情态框架）负样本 7 报 6 漏 1（漏的那句是「Ich weiß, dass ich muss heute arbeiten.」—— 实词夹在情态动词与末位动词之间的整族不可见，是该探测的结构性边界）；B 维（过去锚+时态）7/7 全报、对照 0/6。按脚本阈值：A 维 error 档不成立、warning 档成疑；B 维两档均成立。 - 诚实性修正两轮：① 探测函数 _detect_modal_frame_order 原 docstring 称「逗号并列主句不会报」与实测相反，已如实分列漏报族/误报族；② 样本外追加实测的 3 句逗号并列正确句（实测报 True）原先只住 docstring，按评审要求搬进产物：verdict 文本（text 与 --json 同源）+ 独立区块「样本外追补（不入计数）」+ 模块常量落盘（原文可检索）；并写明「真实文本 FP 不得以本表 0 外推；若计入对照组则 warning 档亦不成立」。冻结计数与阈值常量未动。 门禁：tests 10 passed；ruff 全绿；mypy --strict tools/bench_judge_fp.py 与 --follow-imports=skip 均 0；CRLF。 裁决（接线为 error / 降级 warning / 不做）属 Task 6 的 HITL 步骤，待用户拍板。 注：本条消息曾因 shell 反引号替换丢失两处正文，已就地重建（本地未推送提交，仅改消息）。 --- tests/test_judge_fp_bench.py | 288 +++++++++++++ tools/bench_judge_fp.py | 765 +++++++++++++++++++++++++++++++++++ 2 files changed, 1053 insertions(+) create mode 100644 tests/test_judge_fp_bench.py create mode 100644 tools/bench_judge_fp.py diff --git a/tests/test_judge_fp_bench.py b/tests/test_judge_fp_bench.py new file mode 100644 index 00000000..682d28c9 --- /dev/null +++ b/tests/test_judge_fp_bench.py @@ -0,0 +1,288 @@ +# -*- coding: utf-8 -*- +"""`tools/bench_judge_fp.py` 的行为契约测试（Task 6 的 AFK 半）。 + +钉住什么（为什么这些断言不是恒真） +-------------------------------- +1. **样本集有效性判据**：标注缺失 / 空样本 ⇒ ``validate_samples`` 非空、 + ``measure_candidates`` 抛 ValueError、CLI 退出码 1（"样本集自身无效"的语义锚）。 +2. **计数的可证伪性**：用两个方向相反的桩探测（永不报 / 永远报）喂同一批样本， + 断言 FP/FN 计数在两端都正确 —— 只断言"永不报 ⇒ FP=0"是恒真死断言 + （实现写坏时 0 == 0 照样成立），必须配"永远报 ⇒ FP=全部期望不报句"的反向断言。 +3. **Report 形状**：``fp_samples`` / ``fn_samples`` 键必须存在，且装载误报/漏报句 + 全文（带来源前缀、顺序确定）—— "只报比例无法证伪判据"是本任务的红线。 +4. **确定性**：同输入两次测量输出逐字节一致（"可复跑"的硬条件）。 +5. **内置样本集自洽**：10 篇官方范文 + 每维 ≥5 定向错误句 + ≥5 正确对照组、 + 标注齐全（防后续有人删样本让标定失真）。 +6. **环境不可用 = 退出码 2**：spaCy 缺失（ImportError 原始形态）/ 模型加载失败 + （RuntimeError）都归口 ``probe_environment`` 映射为 2，不与"样本集无效 = 1" + 撞语义（注入桩 loader，不真删包、不真坏环境）。 +7. **样本外追补必须出现在产物**：A 维 3 句样本外误报的原文 + 实测结果必须在 + verdict（text 与 ``--json`` 同源）与 CLI 区块可寻，且**不得**混入冻结样本集 + —— 防退化成"只住 docstring"的系统性乐观（评审 RED）。 + +反挂死纪律：本文件无 sleep / 无线程 / 无循环等待；唯一的子进程调用带固定 +timeout（防挂死防线，实测 ~1.5s）。 +""" + +import importlib.util +import json +import os +import subprocess +import sys +import types +from pathlib import Path +from typing import Any + +_ROOT = Path(__file__).resolve().parent.parent +_SCRIPT = _ROOT / "tools" / "bench_judge_fp.py" + +# 桩探测的触发标记（样本句里含它就被"报"）。 +_MARKER = "FALSCH" + + +def _load_bench_module() -> types.ModuleType: + """按路径加载 ``tools/bench_judge_fp.py``（tools/ 不是 package，同 tests/test_audit_official_vocab.py 模式）。 + + 注意 MUST 先注册 ``sys.modules``：被测脚本用 ``from __future__ import annotations``， + dataclasses 在 exec 期会查 ``sys.modules[cls.__module__]`` 解析字符串注解 —— + 不注册时动态加载直接 AttributeError（2026-10-15 实测踩坑，别再省这一步）。 + """ + spec = importlib.util.spec_from_file_location("bench_judge_fp_under_test", _SCRIPT) + assert spec is not None and spec.loader is not None + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +bench = _load_bench_module() + + +def _stub(name: str, reports: bool) -> Any: + """构造桩候选：``reports=True`` ⇒ 永远报；False ⇒ 永不报。""" + return bench.Candidate(name=name, description=f"stub(always={reports})", detect=lambda _s: reports) + + +def _stub_by_marker() -> Any: + """构造桩候选：句含 ``FALSCH`` 才报（用来钉"定向错误句被报"）。""" + return bench.Candidate(name="stub", description="含 FALSCH 才报", detect=lambda s: _MARKER in s) + + +def test_missing_label_invalidates_samples() -> None: + """标注缺失（expected=None）⇒ 样本集无效：validate 报错 + measure 抛 ValueError。""" + candidates = [_stub("stub", reports=False)] + negatives = {"stub": [bench.LabeledSentence("Ein Satz ohne Label.", None, "nolabel")]} + errors = bench.validate_samples(candidates, ["Ein korrekter Satz."], negatives) + assert errors, "缺标注必须被 validate_samples 判为无效" + assert any("缺标注" in e for e in errors) + try: + bench.measure_candidates(candidates, ["Ein korrekter Satz."], negatives) + except ValueError as exc: + assert "样本集无效" in str(exc) + else: # pragma: no cover - 防御：不抛就是契约破坏 + raise AssertionError("measure_candidates 对缺标注样本集必须抛 ValueError") + + +def test_empty_samples_invalidate() -> None: + """空正样本 / 空负样本维度 ⇒ validate 非空（"空样本"一类的退出码 1 锚点）。""" + candidates = [_stub("stub", reports=False)] + ok_neg = {"stub": [bench.LabeledSentence("Ein Satz.", False, "ctrl")]} + assert bench.validate_samples(candidates, [], ok_neg), "空正样本必须被判无效" + assert bench.validate_samples(candidates, ["Ein Satz."], {}), "空负样本集必须被判无效" + assert bench.validate_samples(candidates, ["Ein Satz."], {"stub": []}), "空的负样本维度必须被判无效" + + +def test_cli_missing_label_exits_nonzero(tmp_path: Path) -> None: + """CLI 层：--negatives 指向缺 expected 的 JSON ⇒ 退出码 1（非零 = 标定未完成）。""" + bad = tmp_path / "bad_negatives.json" + bad.write_text( + json.dumps( + { + "a_modal_frame_order": [{"text": "Ich muss gehen heute nach Hause.", "note": "nolabel"}], + "b_past_anchor_tense_conflict": [{"text": "Gestern gehe ich zur Schule.", "expected": True}], + }, + ensure_ascii=False, + ), + encoding="utf-8", + ) + env = dict(os.environ) + env["PYTHONIOENCODING"] = "utf-8" + proc = subprocess.run( + [sys.executable, str(_SCRIPT), "--negatives", str(bad)], + capture_output=True, + text=True, + encoding="utf-8", + timeout=15, + env=env, + cwd=str(_ROOT), + ) + assert proc.returncode == 1, f"缺标注必须退出码 1（实际 {proc.returncode}）\nstderr={proc.stderr}" + assert "样本集无效" in proc.stderr + + +def test_all_correct_samples_zero_fp() -> None: + """全部正确样本（期望不报）⇒ FP 计数 0 —— 并配"永远报"的反向断言防恒真。""" + positives = ["Ein voellig korrekter Satz."] + negatives = {"stub": [bench.LabeledSentence("Noch ein korrekter Satz.", False, "ctrl1")]} + + never = bench.measure_candidates([_stub("stub", reports=False)], positives, negatives) + entry = never["per_candidate"][0] + assert entry["fp"] == 0 + assert entry["fn"] == 0 + assert entry["fp_samples"] == [] + assert entry["fn_samples"] == [] + + # 反向对照（防恒真）：同一批全正确样本，"永远报"必须把每句都记成 FP。 + always = bench.measure_candidates([_stub("stub", reports=True)], positives, negatives) + entry_always = always["per_candidate"][0] + assert entry_always["fp"] == 2, "1 句正样本 + 1 句对照组，全部应为 FP" + assert len(entry_always["fp_samples"]) == 2 + + +def test_targeted_wrong_samples_zero_fn() -> None: + """定向错误样本（期望报）⇒ 被正确报出时 FN 计数 0；配"永不报"的反向断言。""" + positives = ["Ein korrekter Satz."] + negatives = { + "stub": [ + bench.LabeledSentence("FALSCH Satz eins.", True, "err1"), + bench.LabeledSentence("FALSCH Satz zwei.", True, "err2"), + ] + } + always = bench.measure_candidates([_stub("stub", reports=True)], positives, negatives) + entry = always["per_candidate"][0] + assert entry["fn"] == 0 + assert entry["fn_samples"] == [] + + never = bench.measure_candidates([_stub("stub", reports=False)], positives, negatives) + entry_never = never["per_candidate"][0] + assert entry_never["fn"] == 2, "两句定向错误句全部漏报" + assert len(entry_never["fn_samples"]) == 2 + + +def test_report_contains_sample_keys_with_full_text() -> None: + """Report 形状契约：per_candidate 键集合 + 样例行 = 带来源前缀的句全文（顺序确定）。""" + positives = ["Ein Satz."] + negatives = { + "stub": [ + bench.LabeledSentence("Zwei Satz.", False, "ctrl"), + bench.LabeledSentence("Drei Satz.", True, "err"), + ] + } + always = bench.measure_candidates([_stub("stub", reports=True)], positives, negatives) + entry = always["per_candidate"][0] + assert set(entry.keys()) == {"name", "fp", "fn", "fp_samples", "fn_samples"} + assert entry["name"] == "stub" + # 误报样例 = 正样本句 + 对照组句（各带来源前缀；顺序 = 正样本在前、负样本按输入序）。 + assert entry["fp_samples"] == ["[positive#1] Ein Satz.", "[ctrl] Zwei Satz."] + # 定向错误句被报 ⇒ 不进 fn_samples。 + assert entry["fn_samples"] == [] + # verdict 是 dict[str, str]（只含量与阈值对照）。 + assert isinstance(always["verdict"], dict) + assert isinstance(always["verdict"]["stub"], str) + assert "阈值" in always["verdict"]["stub"] + + # 反向：永"不漏"的另一端 —— 永不报时 fn_samples 装载的是漏报句全文。 + never = bench.measure_candidates([_stub("stub", reports=False)], positives, negatives) + entry_never = never["per_candidate"][0] + assert entry_never["fn_samples"] == ["[err] Drei Satz."] + assert entry_never["fp_samples"] == [] + + +def test_determinism_same_input_same_output() -> None: + """同输入两次测量，输出必须逐字节一致（可复跑纪律）。""" + candidate = _stub_by_marker() + positives = ["Ein korrekter Satz. Und FALSCH ein zweiter."] + negatives = { + "stub": [ + bench.LabeledSentence("FALSCH hier.", True, "err1"), + bench.LabeledSentence("Alles gut.", False, "ctrl1"), + ] + } + first = bench.measure_candidates([candidate], positives, negatives) + second = bench.measure_candidates([candidate], positives, negatives) + assert json.dumps(first, ensure_ascii=False) == json.dumps(second, ensure_ascii=False) + + +def test_default_dataset_is_valid_and_meets_min_size() -> None: + """内置样本集自洽：10 篇范文 + 每维 ≥5 定向错误 + ≥5 对照组、标注齐全。""" + pairs = bench.load_positives() + assert len(pairs) == 10, "正样本 = A1_SCHREIBEN_TEIL2 全部 10 篇" + assert all(entry_id and text for entry_id, text in pairs) + texts = [text for _, text in pairs] + assert bench.validate_samples(bench.CANDIDATES, texts, bench.NEGATIVES) == [] + for name in ("a_modal_frame_order", "b_past_anchor_tense_conflict"): + items = bench.NEGATIVES[name] + errs = [it for it in items if it.expected is True] + ctrls = [it for it in items if it.expected is False] + assert len(errs) >= 5, f"{name} 的定向错误句不足 5 条" + assert len(ctrls) >= 5, f"{name} 的正确对照组不足 5 条" + + +def _raiser(exc: BaseException) -> Any: + """构造"调用即抛指定异常"的桩 loader（注入环境探测，不真删包、不真坏环境）。""" + + def _raise() -> Any: + raise exc + + return _raise + + +def test_environment_unavailable_maps_to_exit_code_2(monkeypatch: Any, capsys: Any) -> None: + """环境不可用 ⇒ 退出码 2（与"样本集无效 = 1"分语义）；注入桩，不真删包/不真坏环境。""" + # 1) 探测函数是"rc=2"的单一归口：可用 ⇒ None；两类环境故障都返回原因文本。 + assert bench.probe_environment(lambda: object()) is None, "环境可用时探测必须返回 None" + import_err = bench.probe_environment(_raiser(ImportError("No module named 'spacy'"))) + assert import_err is not None and "spacy" in import_err + runtime_err = bench.probe_environment(_raiser(RuntimeError("德语模型加载失败"))) + assert runtime_err is not None and "德语模型加载失败" in runtime_err + + # 2) CLI 主路径：spaCy 缺失的原始形态（ImportError 直接外泄）必须被转成 2， + # 而不是未捕获异常（rc=1，与"样本集无效"撞语义）。 + monkeypatch.setattr(bench, "_load_nlp", _raiser(ImportError("No module named 'spacy'"))) + rc = bench.main([]) + assert rc == 2, f"环境不可用必须退出码 2（实际 {rc}）" + captured = capsys.readouterr() + assert "环境不可用" in captured.err + + +def test_out_of_sample_supplement_is_in_product(monkeypatch: Any, capsys: Any) -> None: + """RED 修复钉：A 维样本外追补的原文+结果必须进产物，且**不得**混入冻结样本集。 + + 无模型依赖：verdict 走合成输入、CLI 区块注入桩结果（不真跑 spaCy）。 + """ + # 1) 追补集形状：3 句、第 1 句 = 评审记录句、逐句非空、与冻结样本集**零重叠** + # （混入会改动 fp/fn 计数，破坏"计数冻结"纪律）。 + assert len(bench.OUT_OF_SAMPLE_A) == 3 + assert bench.OUT_OF_SAMPLE_A[0] == "Ich kann nicht kommen, ich muss arbeiten." + assert all(text.strip() for text in bench.OUT_OF_SAMPLE_A) + frozen = {item.text for items in bench.NEGATIVES.values() for item in items} + assert not (set(bench.OUT_OF_SAMPLE_A) & frozen), "追补句不得混入冻结样本集" + + # 2) verdict（text 与 --json 同源）：A 维必须带追补句与翻档结论；B 维不得带。 + outcomes = [bench.SentenceOutcome("TN", "positive", "p1", False, False, "Ein Satz.")] + oos = [(text, True) for text in bench.OUT_OF_SAMPLE_A] + a_verdict = bench._verdict_text(outcomes, oos) + assert "样本外追补" in a_verdict + assert "未入本冻结集" in a_verdict + assert "3 个变体中 3 个报 True" in a_verdict + assert "warning 档条件亦不成立" in a_verdict, "3 句报 True 计入对照组时必须翻掉 warning 档条件" + b_verdict = bench._verdict_text(outcomes, None) + assert "样本外追补" not in b_verdict + + # 3) CLI 独立区块：注入桩结果 ⇒ 必须打印 3 句原文与结果（含 err7 族结构性边界）。 + monkeypatch.setattr(bench, "_out_of_sample_a_results", lambda: [(text, True) for text in bench.OUT_OF_SAMPLE_A]) + report = { + "per_candidate": [ + {"name": "a_modal_frame_order", "fp": 0, "fn": 0, "fp_samples": [], "fn_samples": []}, + {"name": "b_past_anchor_tense_conflict", "fp": 0, "fn": 0, "fp_samples": [], "fn_samples": []}, + ], + "verdict": {}, + } + details: dict[str, list[Any]] = {"a_modal_frame_order": [], "b_past_anchor_tense_conflict": []} + bench._print_text_report(report, details, bench.CANDIDATES, 1, 0) + out = capsys.readouterr().out + assert "样本外追补（不入计数）" in out + for text in bench.OUT_OF_SAMPLE_A: + assert text in out, f"区块缺原文：{text}" + assert "[报=True]" in out + assert "err7" in out diff --git a/tools/bench_judge_fp.py b/tools/bench_judge_fp.py new file mode 100644 index 00000000..f9ac91b7 --- /dev/null +++ b/tools/bench_judge_fp.py @@ -0,0 +1,765 @@ +# -*- coding: utf-8 -*- +"""A1 裁判候选维度的 FP 标定实验（Task 6 的 AFK 半：**只标定，不接线**）。 + +为什么存在 +---------- +计划 docs/plans/2026-10-15-a1-judge-expansion.md 的 Task 6 要在两条候选维度 +（情态动词框架语序 / 过去时间锚与时态一致性）上回答一个问题：**把它们接进 +A1 裁判的误报代价有多大**。误报比漏报危险（模型会去"修"一个不存在的错误）， +所以裁决（接线为 error / 降级 warning / 不做）是 HITL，由人拿本脚本产出的 +原始数据拍板 —— **本脚本不下这个结论**。 + +探测实现只住在本脚本里（计划原文：可不进 writing.py），**不得**接进 +`analyze_a1_email`；它们是"探针"而不是"规则"。 + +为什么两条探测都刻意绕开 spaCy 的依存连接（实测，2026-10-15，de_core_news_sm） +------------------------------------------------------------------------------ +错误句 `Ich muss gehen heute nach Hause.`： + spaCy: muss=AUX/dep=nk、gehen=VERB/ROOT 且被误标 VerbForm=Fin（本应为 Inf）； + 正确句 `Ich muss heute nach Hause gehen.` 下同一对词是 muss=ROOT、gehen=oc/Inf。 +错误句 `Sie muss machen die Hausaufgaben heute.`： + spaCy: muss=ADV/dep=mo（连动词词性都错了）、machen=VERB/ROOT。 +错误句 `Du kannst helfen mir bei der Hausaufgabe.`： + spaCy: kannst=VERB/dep=sb（荒谬）、helfen=VERB/ROOT/Inf。 +范文 email_05 里 `kannst` 的 lemma 是垃圾值 "kannstn"；范文 email_06 里 +`muss` 被标 Tense=Past。且整篇解析与单句解析不一致（"Kannst du ... mitbringen?" +整篇=VERB/ROOT、单句=PROPN/ROOT）。 + +⇒ A 维探测用「情态动词表面形式表 + 位置 + 实词 POS 检查」、B 维用「时间锚词表 + +morph 时态」——都不依赖 dep 边的正确性。这不改变一个事实：探测在真实文本上的 +FP 率由本脚本的样本集来量化。 + +样本集 +------ +- 正样本：`delector/data/a1_writing_dict.py` 的 `A1_SCHREIBEN_TEIL2` 全部 10 篇 + 官方 sample_email（期望误报 = 0）。 +- 负样本：每维 ≥5 句手工定向错误句 + 正确对照组（逐句标注期望；对照组期望 + "不报" —— 没有对照组，FP/FN 无法分开）。 +- 切句为确定性标点规则 `(?<=\\D[.!?])\\s+`（数字缩写如 "15." 不切）：与 spaCy + senter 的实测差异仅 1 处（email_06 落款 "Liebe Grüße\\nJulia" 多切一段 + 无动词碎片，不影响这两维的判定），换来"切句零模型依赖 + 口径固定为单句解析"。 + +计数口径与裁决 +-------------- +per_candidate[i] = ``{name, fp, fn, fp_samples, fn_samples}``： +- ``fp`` = 正样本句误报数 + 对照组句误报数（两类都进 fp_samples，带来源前缀）； +- ``fn`` = 定向错误句漏报数（进 fn_samples，带来源前缀）。 +``verdict`` 只给"实测值与建议阈值的对照"（error 档 / warning 档的条件是否 +成立），**不写"建议做/不做"** —— 裁决归 HITL。 +另：A 维附**样本外追补**（OUT_OF_SAMPLE_A，3 句逗号并列正确句；2026-10-15 评审 +追补实测 3/3 被 A 维误报）——**不入任何计数**：原文与 live 结果打印在 CLI +「样本外追补（不入计数）」区块，结论（含 warning 档翻档影响）并入 A 维 +``verdict``。防止产物读者以冻结表的 0 误报外推出"A 维真实文本 FP≈0"。 + +退出码 +------ +0 = 标定完成；1 = 样本集自身无效（空样本 / 标注缺失 / JSON 结构错误）； +2 = 环境不可用（spaCy 未安装 / 德语模型加载失败；**绝不**触发 ``spacy.cli.download`` —— +与 ``processor.try_load_nlp_no_download`` 同纪律）。 + +可复跑：同输入同输出（无随机、无时间、无网络；切句为确定性正则）。 +""" + +from __future__ import annotations + +import argparse +import io +import json +import os +import re +import sys +from dataclasses import dataclass +from typing import Any, Callable, Dict, List, Literal, Mapping, Optional, Sequence, Tuple, TypedDict + +# 允许从任意 CWD 直接 `python tools/bench_judge_fp.py` 运行（同 tools/ 其余脚本约定）。 +# 注意：这里**只**注入路径、不 import 仓库模块 —— 仓库 import 全部延迟到函数内 +# （import 期零重依赖、零副作用；E402 也无从触发）。 +_REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if _REPO_ROOT not in sys.path: + sys.path.insert(0, _REPO_ROOT) + +# --------------------------------------------------------------------------- # +# 类型与常量 +# --------------------------------------------------------------------------- # + +#: 四分类标签：TP=期望报且报；FN=期望报却漏；FP=期望不报却报；TN=期望不报且没报。 +OutcomeLabel = Literal["TP", "TN", "FP", "FN"] + +#: 模型候选顺序**复制自** processor.SPACY_MODEL_CANDIDATES（不 import：本脚本 +#: 不应拉起 delector 的依赖链；顺序不一致会让标定口径和产品漂移，改这里时必须 +#: 同步 `delector/nlp_engine/processor.py:23`）。 +MODEL_CANDIDATES: Tuple[str, ...] = ("de_core_news_md", "de_core_news_sm") + +#: verdict 的建议阈值（**脚本算"条件是否成立"，不替人裁决**）： +#: error 档 = 零误报（正样本句 + 对照组句）且零漏报；warning 档 = 各容忍少量。 +ERROR_POS_FP_MAX = 0 +ERROR_CTRL_FP_MAX = 0 +ERROR_FN_MAX = 0 +WARN_POS_FP_MAX = 1 +WARN_CTRL_FP_MAX = 1 +WARN_FN_MAX = 2 + +#: 确定性切句：句末标点后跟空白才切；`\\D` 防 "vom 15. bis 18. August" 这类 +#: 数字缩写被切碎（实测：不加它会切出 "vom 15." / "bis 18." 碎片）。 +_SENT_BOUNDARY = re.compile(r"(?<=\D[.!?])\s+") + + +@dataclass(frozen=True) +class LabeledSentence: + """负样本条目：逐句标注期望（``expected=None`` = 标注缺失 ⇒ 样本集无效）。""" + + text: str + expected: Optional[bool] + note: str = "" + + +@dataclass(frozen=True) +class Candidate: + """一条候选维度：名字 + 描述 + 句级探测（True = 报违规）。""" + + name: str + description: str + detect: Callable[[str], bool] + + +@dataclass(frozen=True) +class SentenceOutcome: + """一个句子的评估结果（明细，供 CLI 打印与 fold 折叠）。""" + + label: OutcomeLabel + kind: Literal["positive", "negative"] + source: str + expected: bool + reported: bool + text: str + + +class CandidateResult(TypedDict): + """单条候选的标定计数（计划 Task 6 固定的 Report 形状）。""" + + name: str + fp: int + fn: int + fp_samples: List[str] + fn_samples: List[str] + + +class Report(TypedDict): + """标定报告：per_candidate 计数 + verdict（只含量与阈值对照，不含裁决）。""" + + per_candidate: List[CandidateResult] + verdict: Dict[str, str] + + +# --------------------------------------------------------------------------- # +# 探测实现（候选维度 A/B —— 只住脚本里，不接线） +# --------------------------------------------------------------------------- # + +# 维度 A：情态动词表面形式表。为什么用"表面形式"而不是 lemma： +# spaCy 的德语 lemma 实测会产出垃圾（kannst→kannstn、muss→Muss），不可依赖。 +# 覆盖六大情态动词的现在时/过去时/第二虚拟式全部常见变位（60+ 形式）。 +_MODAL_SURFACE_FORMS = frozenset({ + # können + "kann", "kannst", "könnt", "können", "konnte", "konntest", "konnten", "konntet", + "könnte", "könntest", "könnten", "könntet", + # müssen + "muss", "musst", "müsst", "müssen", "musste", "musstest", "mussten", "musstet", + "müsste", "müsstest", "müssten", "müsstet", + # wollen + "will", "willst", "wollt", "wollen", "wollte", "wolltest", "wollten", "wolltet", + # dürfen + "darf", "darfst", "dürft", "dürfen", "durfte", "durftest", "durften", "durftet", + "dürfte", "dürftest", "dürften", "dürftet", + # sollen + "soll", "sollst", "sollt", "sollen", "sollte", "solltest", "sollten", "solltet", + # mögen（含 möchte 全系列；mochte 系列兼收无变音符号的 möchte 误拼） + "mag", "magst", "mögt", "mögen", "mochte", "mochtest", "mochten", "mochtet", + "möchte", "möchtest", "möchten", "möchtet", +}) + +# 维度 A：触发"框架被拆开"的实词 POS（功能词/标点/动词本身都不算）。 +_CONTENT_POS = frozenset({"NOUN", "PROPN", "PRON", "ADJ", "ADV", "NUM"}) + +# 维度 B：过去时间锚（决定性锚定过去的副词；含无变音符号转写）。 +_PAST_ANCHOR_ADVERBS = frozenset({ + "gestern", "vorgestern", "damals", "früher", "frueher", + "neulich", "kürzlich", "kuerzlich", "ehemals", +}) +# 维度 B：letzte/letzten/... + 时间名词 才是锚（单独 "letzte" 可能是"末班车"）。 +_LETZTE_FORMS = frozenset({"letzte", "letzten", "letzter", "letztes"}) +_TIME_NOUNS = frozenset({ + "woche", "wochen", "monat", "monaten", "jahr", "jahren", + "wochenende", "mal", "sommer", "winter", "tag", "tagen", +}) +# 维度 B：现在时形式的完成时助动词（haben/sein）——句中存在 Partizip II 时豁免。 +# 例：`Gestern habe ich eine Suppe gekocht.` 的 habe 是现在时形态但整体是过去语义。 +_PERFECT_AUX_PRES = frozenset({"habe", "hast", "hat", "haben", "habt", "bin", "bist", "ist", "sind", "seid"}) + +# spaCy 惰性加载的进程内缓存（import 期不加载、不联网；加载失败不写缓存）。 +_NLP: Any = None +_NLP_MODEL_NAME: str = "" + + +def _load_nlp() -> Any: + """惰性加载德语模型（缓存）。spaCy 缺失 / 全部候选失败一律抛 RuntimeError；**绝不下载**。""" + global _NLP, _NLP_MODEL_NAME + if _NLP is not None: + return _NLP + try: + import spacy # 惰性：import 期不引入 spacy（本脚本直接运行时的启动成本也在意） + except ImportError as exc: # 裸外泄会拿到未捕获异常的 rc=1，与"样本集无效"撞语义 ⇒ 归一为 RuntimeError + raise RuntimeError(f"spaCy 未安装（本脚本不自动安装、不触发下载）：{exc}") from exc + + errors: List[str] = [] + for name in MODEL_CANDIDATES: + try: + _NLP = spacy.load(name) + _NLP_MODEL_NAME = name + return _NLP + except Exception as exc: # 该候选加载失败 ⇒ 继续试下一个；全部失败才抛 RuntimeError + errors.append(f"{name}: {exc}") + raise RuntimeError("德语模型加载失败（不自动下载；请先安装 de_core_news_sm）：" + " | ".join(errors)) + + +def get_loaded_model_name() -> str: + """返回实际生效的模型名（未加载时为空串）。""" + return _NLP_MODEL_NAME + + +def probe_environment(load_nlp: Optional[Callable[[], Any]] = None) -> Optional[str]: + """环境探测（"退出码 2 = 环境不可用"的单一归口）：可用返回 None，不可用返回原因文本。 + + ``load_nlp`` 仅供测试注入（默认 ``_load_nlp``）；同时兜住两类环境故障： + spaCy 未安装（ImportError，原始形态）与德语模型加载失败（RuntimeError， + 见 ``_load_nlp`` 的归一化）。**绝不**触发 ``spacy.cli.download`` —— 与 + ``processor.try_load_nlp_no_download`` 同纪律。 + """ + loader = _load_nlp if load_nlp is None else load_nlp + try: + loader() + except (RuntimeError, ImportError) as exc: + return str(exc) + return None + + +def _is_zu_infinitive(tokens: Sequence[Any], index: int) -> bool: + """判断 index 处的不定式是否属于 zu-Infinitiv（如 `etwas zu trinken`）。 + + zu-Inf 不是情态框架的一部分：`Kannst du ... etwas zu trinken mitbringen?` + 里的 trinken 若被误当框架动词，正确范文会被误报 —— 排除它是保 FP=0 的关键。 + """ + return index > 0 and tokens[index - 1].pos_ == "PART" and tokens[index - 1].lower_ == "zu" + + +def _detect_modal_frame_order(sentence: str) -> bool: + """候选维度 A：主句情态框架（情态动词 + 句末不定式）疑似被拆开 ⇒ True。 + + 判据（表面形式 + 位置 + 实词 POS 检查，**刻意不用 dep 连接与 morph**，理由见模块 docstring）： + 1. 找句中第一个情态动词表面形式 W； + 2. 找 W 之后第一个动词 V（跳过 zu-不定式）； + 3. 若 V 之后（在遇到下一个从句/并列引导词 SCONJ/CCONJ 之前）还有实词 + （名词/代词/形容词/副词/数词）⇒ 框架动词不在末尾 ⇒ 报。 + + 已知边界（未覆盖，如实登记；2026-10-15 实测）： + - 机制：探测**仅按 SCONJ/CCONJ 断句，不识别从句/并列结构** —— 从句内框架被不被 + 报，只看实词落在末位动词之后（`..., dass ich muss gehen heute.` 会报）还是夹在 + 情态动词与末位动词之间（`..., dass ich muss heute arbeiten.` 不报；负样本 err7 + 即此族，**整族不可见**）； + - 逗号并列主句（`Ich kann nicht kommen, ich muss arbeiten.`）**会误报**（FP 方向； + 第二分句主语 PRON 触发实词检查）。样本外追补原文见 ``OUT_OF_SAMPLE_A``（不入计数）。 + """ + doc = _load_nlp()(sentence) + tokens = [t for t in doc if not t.is_space] + w_index: Optional[int] = None + for i, token in enumerate(tokens): + if token.lower_ in _MODAL_SURFACE_FORMS: + w_index = i + break + if w_index is None: + return False + v_index: Optional[int] = None + for i in range(w_index + 1, len(tokens)): + if tokens[i].pos_ == "VERB" and not _is_zu_infinitive(tokens, i): + v_index = i + break + if v_index is None: + return False + for token in tokens[v_index + 1:]: + if token.pos_ in ("SCONJ", "CCONJ"): + break # 从句/并列分句从引导词开始 ≠ 主句 Mittelfeld（`..., weil ...` / `und ...`） + if token.pos_ in _CONTENT_POS: + return True + return False + + +def _has_past_anchor(tokens: Sequence[Any]) -> bool: + """句中是否含过去时间锚（副词表 或 letzte-系 + 时间名词）。""" + for i, token in enumerate(tokens): + if token.lower_ in _PAST_ANCHOR_ADVERBS: + return True + if token.lower_ in _LETZTE_FORMS and i + 1 < len(tokens) and tokens[i + 1].lower_ in _TIME_NOUNS: + return True + return False + + +def _detect_past_anchor_tense_conflict(sentence: str) -> bool: + """候选维度 B：过去时间锚 + 现在时限定动词（非完成时结构）⇒ True。 + + 判据（词表 + morph）： + 1. 句中含过去时间锚（gestern / letzte Woche / damals ...）； + 2. 存在 morph VerbForm=Fin 且 Tense=Pres 的动词； + 3. 豁免完成时结构：句中存在 Partizip II（VerbForm=Part 的 VERB）时， + haben/sein 的现在时形式不触发（`Gestern habe ich ... gekocht.` 是正确句）。 + + 已知边界（未覆盖，如实登记）：`Gestern muss ich müde gewesen sein.` 这类 + "情态词 + 完成时不定式"的正确推测句会被误报；`Morgen`/`am Samstag` 等 + 中性/未来时间表达不在锚表内（`Morgen fahre ich ...` 正确不报）。 + """ + doc = _load_nlp()(sentence) + tokens = [t for t in doc if not t.is_space] + if not _has_past_anchor(tokens): + return False + has_partizip = any(t.pos_ == "VERB" and "Part" in t.morph.get("VerbForm") for t in tokens) + for token in tokens: + if "Fin" in token.morph.get("VerbForm") and "Pres" in token.morph.get("Tense"): + if has_partizip and token.lower_ in _PERFECT_AUX_PRES: + continue + return True + return False + + +# --------------------------------------------------------------------------- # +# 样本集：正样本装载 + 负样本（逐句标注期望；错句与正确对照组配对） +# --------------------------------------------------------------------------- # + + +def load_positives() -> List[Tuple[str, str]]: + """装载正样本：A1_SCHREIBEN_TEIL2 全部 10 篇官方 sample_email。 + + 返回 ``[(email_id, sample_email), ...]``（顺序 = 数据文件顺序，deterministic）。 + """ + from delector.data.a1_writing_dict import A1_SCHREIBEN_TEIL2 # 延迟 import（见模块头） + + return [(str(entry["id"]), str(entry["sample_email"])) for entry in A1_SCHREIBEN_TEIL2] + + +# 负样本集（内置；`--negatives` 可覆盖）。每维 = 定向错误句（expected=True） +# + 正确对照组（expected=False）。构造依据如下：错误句取"情态框架拆裂" +# 与"过去锚+现在时"两个高频学生错误族；对照组是修正版 + 边界守卫 +# （从句框架 / 完成时 / 未来现在时）。 +NEGATIVES: Dict[str, Tuple[LabeledSentence, ...]] = { + "a_modal_frame_order": ( + LabeledSentence("Ich muss gehen heute nach Hause.", True, "err1_verb_vorgezogen"), + LabeledSentence("Ich kann besuchen dich morgen.", True, "err2_verb_vorgezogen"), + LabeledSentence("Wir wollen fahren am Wochenende nach Berlin.", True, "err3_verb_vorgezogen"), + LabeledSentence("Er will kaufen ein neues Auto.", True, "err4_verb_vorgezogen"), + LabeledSentence("Sie muss machen die Hausaufgaben heute.", True, "err5_verb_vorgezogen"), + LabeledSentence("Du kannst helfen mir bei der Hausaufgabe.", True, "err6_verb_vorgezogen"), + LabeledSentence("Ich weiß, dass ich muss heute arbeiten.", True, "err7_nebensatz_klammer"), + LabeledSentence("Ich muss heute nach Hause gehen.", False, "ctrl1_klammer_korrekt"), + LabeledSentence("Ich kann dich morgen besuchen.", False, "ctrl2_klammer_korrekt"), + LabeledSentence("Wir wollen am Wochenende nach Berlin fahren.", False, "ctrl3_klammer_korrekt"), + LabeledSentence("Er will ein neues Auto kaufen.", False, "ctrl4_klammer_korrekt"), + LabeledSentence("Sie muss die Hausaufgaben heute machen.", False, "ctrl5_klammer_korrekt"), + LabeledSentence("Du kannst mir bei der Hausaufgabe helfen.", False, "ctrl6_klammer_korrekt"), + LabeledSentence("Ich weiß, dass ich heute arbeiten muss.", False, "ctrl7_nebensatz_korrekt"), + ), + "b_past_anchor_tense_conflict": ( + LabeledSentence("Gestern gehe ich zur Schule.", True, "err1_praesens_statt_praeteritum"), + LabeledSentence("Vorgestern koche ich eine Suppe.", True, "err2_praesens_statt_praeteritum"), + LabeledSentence("Letzte Woche fahre ich nach Berlin.", True, "err3_praesens_statt_praeteritum"), + LabeledSentence("Gestern kaufe ich ein Buch im Supermarkt.", True, "err4_praesens_statt_praeteritum"), + LabeledSentence("Damals wohne ich in Hamburg.", True, "err5_praesens_statt_praeteritum"), + LabeledSentence("Letztes Jahr arbeite ich in einer Firma.", True, "err6_praesens_statt_praeteritum"), + LabeledSentence("Gestern habe ich eine Suppe koche.", True, "err7_kein_partizip"), + LabeledSentence("Gestern ging ich zur Schule.", False, "ctrl1_praeteritum"), + LabeledSentence("Gestern habe ich eine Suppe gekocht.", False, "ctrl2_perfekt"), + LabeledSentence("Letzte Woche bin ich nach Berlin gefahren.", False, "ctrl3_perfekt"), + LabeledSentence("Gestern kaufte ich ein Buch im Supermarkt.", False, "ctrl4_praeteritum"), + LabeledSentence("Damals wohnte ich in Hamburg.", False, "ctrl5_praeteritum"), + LabeledSentence("Morgen fahre ich nach Berlin.", False, "ctrl6_futur_praesens"), + ), +} + +#: A 维候选名（verdict 的样本外追补句与 CLI 追补区块按此名挂钩；同名键出现在 +#: NEGATIVES / CANDIDATES 里，改名时三处必须同步）。 +_A_MODAL_FRAME_NAME = "a_modal_frame_order" + +#: A 维**样本外追补集**（**不入冻结集、不入任何计数**）。2026-10-15 评审追补实测： +#: 逗号并列的两个正确主句被误报 —— 第一分句情态框架的末位动词之后，"第二分句主语 +#: PRON"命中实词检查（机制边界见 _detect_modal_frame_order docstring）。第 1 句为 +#: 评审原记录句；本机 de_core_news_sm 复测 3 句均报 True —— 结果不硬编码，由 +#: _out_of_sample_a_results() 现场实测（CLI 区块与 verdict 追补句同源）。 +#: 此前这些实测量只住 docstring ⇒ 产物无痕迹、读者会误得"A 维真实文本 FP≈0"： +#: 产物必须自带反例（评审 RED 修复）。 +OUT_OF_SAMPLE_A: Tuple[str, ...] = ( + "Ich kann nicht kommen, ich muss arbeiten.", + "Er kann nicht kommen, er muss noch arbeiten.", + "Wir können nicht kommen, wir müssen am Wochenende arbeiten.", +) + + +def _out_of_sample_a_results() -> List[Tuple[str, bool]]: + """对 ``OUT_OF_SAMPLE_A`` 跑 A 维探测（live 实测；verdict 追补句与 CLI 区块共用）。""" + return [(text, bool(_detect_modal_frame_order(text))) for text in OUT_OF_SAMPLE_A] + + +#: 内置候选（探测实现见上方；接线与否由 HITL 拍板，这里只定义"候选"）。 +CANDIDATES: Tuple[Candidate, ...] = ( + Candidate( + name="a_modal_frame_order", + description="维度A：主句情态动词框架（情态动词 + 不定式末位）被拆开", + detect=_detect_modal_frame_order, + ), + Candidate( + name="b_past_anchor_tense_conflict", + description="维度B：过去时间锚 + 现在时限定动词（非完成时结构）冲突", + detect=_detect_past_anchor_tense_conflict, + ), +) + + +def load_negatives_from_json(path: str) -> Dict[str, List[LabeledSentence]]: + """从 JSON 装载负样本覆盖集（格式：``{维度名: [{text, expected, note?}, ...]}``）。 + + 结构错误抛 ValueError（CLI 转退出码 1）。条目缺 expected / 非 bool 一律 + 记 expected=None ⇒ 由 validate_samples 报"标注缺失"（这正是退出码 1 的 + 可测路径，见 tests/test_judge_fp_bench.py）。 + """ + with open(path, encoding="utf-8") as handle: + raw = json.load(handle) + if not isinstance(raw, dict): + raise ValueError("负样本 JSON 顶层必须是对象（{维度名: [条目, ...]}）") + result: Dict[str, List[LabeledSentence]] = {} + for dim, items in raw.items(): + if not isinstance(items, list): + raise ValueError(f"负样本维度 {dim} 的值必须是列表") + loaded: List[LabeledSentence] = [] + for j, item in enumerate(items): + if not isinstance(item, dict): + raise ValueError(f"负样本维度 {dim} 第 {j + 1} 条必须是对象") + text = item.get("text") + if not isinstance(text, str): + raise ValueError(f"负样本维度 {dim} 第 {j + 1} 条缺 text（或非字符串）") + expected_raw = item.get("expected") + expected: Optional[bool] = expected_raw if isinstance(expected_raw, bool) else None + note = item.get("note") + loaded.append(LabeledSentence(text, expected, note if isinstance(note, str) else "")) + result[dim] = loaded + return result + + +# --------------------------------------------------------------------------- # +# 校验与评估引擎 +# --------------------------------------------------------------------------- # + + +def _split_sentences(text: str) -> List[str]: + """确定性标点切句（不依赖模型；实测与 spaCy senter 的差异见模块 docstring）。""" + flat = " ".join(text.split()) + return [part.strip() for part in _SENT_BOUNDARY.split(flat) if part.strip()] + + +def validate_samples( + candidates: Sequence[Candidate], + positives: Sequence[str], + negatives: Mapping[str, Sequence[LabeledSentence]], +) -> List[str]: + """校验样本集；返回问题列表（空列表 = 有效）。 + + 退出码语义：本函数非空 ⇔ CLI 退出码 1（"样本集自身无效"），覆盖两类 + 致命情况：空样本（正样本空 / 某维负样本空）与标注缺失（expected=None）。 + """ + errors: List[str] = [] + if not candidates: + errors.append("候选集为空：没有可标定的维度") + if not positives: + errors.append("正样本为空：无法标定误报（FP）") + else: + for i, text in enumerate(positives): + if not text.strip(): + errors.append(f"正样本第 {i + 1} 篇为空文本") + if not negatives: + errors.append("负样本集为空：无法标定漏报（FN）") + for candidate in candidates: + items = negatives.get(candidate.name) + if items is None: + errors.append(f"候选 {candidate.name} 缺负样本集（键缺失）") + continue + if not items: + errors.append(f"候选 {candidate.name} 的负样本集为空") + continue + for j, item in enumerate(items): + if not item.text.strip(): + errors.append(f"{candidate.name} 第 {j + 1} 条负样本为空文本") + if item.expected is None: + errors.append(f"{candidate.name} 第 {j + 1} 条缺标注（expected 缺失）") + return errors + + +def _classify(kind: Literal["positive", "negative"], expected: bool, reported: bool) -> OutcomeLabel: + """四分类。正样本句 = 期望不报的 negative 同口径（expected=False）。""" + if expected and reported: + return "TP" + if expected and not reported: + return "FN" + if (not expected) and reported: + return "FP" + return "TN" + + +def evaluate_candidate( + candidate: Candidate, + positives: Sequence[str], + negatives: Sequence[LabeledSentence], + positive_labels: Optional[Sequence[str]] = None, +) -> List[SentenceOutcome]: + """逐句评估一条候选维度，返回明细（顺序确定：正样本在前、负样本在后）。 + + ``positive_labels`` 仅影响明细/样例里的来源标识（CLI 传 email id； + 库调用默认 ``positive#N``）。 + """ + outcomes: List[SentenceOutcome] = [] + for i, text in enumerate(positives): + source = positive_labels[i] if positive_labels is not None and i < len(positive_labels) else f"positive#{i + 1}" + for sentence in _split_sentences(text): + reported = bool(candidate.detect(sentence)) + outcomes.append( + SentenceOutcome(_classify("positive", False, reported), "positive", source, False, reported, sentence) + ) + for j, item in enumerate(negatives): + if item.expected is None: + raise ValueError(f"负样本第 {j + 1} 条缺标注（expected=None）：{item.text!r}（先跑 validate_samples）") + source = item.note or f"negative#{j + 1}" + reported = bool(candidate.detect(item.text)) + outcomes.append( + SentenceOutcome( + _classify("negative", item.expected, reported), "negative", source, item.expected, reported, item.text + ) + ) + return outcomes + + +def _fold(name: str, outcomes: Sequence[SentenceOutcome]) -> CandidateResult: + """把明细折叠成 per_candidate 计数（fp/fn + 样例全文）。""" + fp_samples = [f"[{o.source}] {o.text}" for o in outcomes if o.label == "FP"] + fn_samples = [f"[{o.source}] {o.text}" for o in outcomes if o.label == "FN"] + return CandidateResult( + name=name, fp=len(fp_samples), fn=len(fn_samples), fp_samples=fp_samples, fn_samples=fn_samples + ) + + +def _verdict_text( + outcomes: Sequence[SentenceOutcome], + out_of_sample: Optional[Sequence[Tuple[str, bool]]] = None, +) -> str: + """生成 verdict 文本：只报"实测值 + 建议阈值对照"，裁决归 HITL。 + + ``out_of_sample``（仅 A 维传入，见 ``OUT_OF_SAMPLE_A``）：**不入任何计数**的样本外 + live 实测；追补句必须同时出现在 text 与 ``--json`` 的 verdict（同一份 Report ⇒ 同源）， + 防止产物读者以冻结表的 0 误报外推"A 维真实文本 FP≈0"。 + """ + pos = [o for o in outcomes if o.kind == "positive"] + neg = [o for o in outcomes if o.kind == "negative"] + pos_fp = [o for o in pos if o.label == "FP"] + neg_err = [o for o in neg if o.expected] + neg_ctrl = [o for o in neg if not o.expected] + fn = [o for o in neg_err if o.label == "FN"] + ctrl_fp = [o for o in neg_ctrl if o.label == "FP"] + error_ok = len(pos_fp) <= ERROR_POS_FP_MAX and len(ctrl_fp) <= ERROR_CTRL_FP_MAX and len(fn) <= ERROR_FN_MAX + warn_ok = len(pos_fp) <= WARN_POS_FP_MAX and len(ctrl_fp) <= WARN_CTRL_FP_MAX and len(fn) <= WARN_FN_MAX + text = ( + f"实测：正样本误报 {len(pos_fp)}/{len(pos)} 句；负样本定向错误句漏报 {len(fn)}/{len(neg_err)} 句；" + f"正确对照组误报 {len(ctrl_fp)}/{len(neg_ctrl)} 句。" + f"建议阈值对照：error 档「正样本 FP<={ERROR_POS_FP_MAX} 且 对照组 FP<={ERROR_CTRL_FP_MAX} " + f"且 FN<={ERROR_FN_MAX}」⇒ 条件{'成立' if error_ok else '不成立'}；" + f"warning 档「正样本 FP<={WARN_POS_FP_MAX} 且 对照组 FP<={WARN_CTRL_FP_MAX} 且 FN<={WARN_FN_MAX}」" + f"⇒ 条件{'成立' if warn_ok else '不成立'}。" + f"裁决（接线为 error / 降级 warning / 不做）归 HITL，本脚本只报量与阈值对照，不下结论。" + ) + if out_of_sample: + hits = sum(1 for _text, reported in out_of_sample if reported) + table_fp = len(pos_fp) + len(ctrl_fp) + text += ( + f"样本外追补实测（**未入本冻结集**，不计入上面任何计数）：逗号并列正确句" + f"「{out_of_sample[0][0]}」等 {len(out_of_sample)} 个变体中 {hits} 个报 True" + f" ⇒ **真实文本 FP 不得以本表 {table_fp} 外推**" + ) + if len(ctrl_fp) + hits > WARN_CTRL_FP_MAX: + text += ( + f"；若将其计入对照组（对照组 FP={len(ctrl_fp)}+{hits}={len(ctrl_fp) + hits}" + f" > WARN_CTRL_FP_MAX={WARN_CTRL_FP_MAX}）则 warning 档条件亦不成立" + ) + text += "。" + return text + + +def _evaluate_all( + candidates: Sequence[Candidate], + positives: Sequence[str], + negatives: Mapping[str, Sequence[LabeledSentence]], + positive_labels: Optional[Sequence[str]] = None, +) -> Tuple[Report, Dict[str, List[SentenceOutcome]]]: + """评估全部候选：返回 (Report, 逐句明细)。CLI 用同一份明细打印原始结果（不二次计算）。 + + A 维额外跑一次样本外追补 live 实测（``_out_of_sample_a_results``，**不入计数**） + 并把它并入该维 verdict（text 与 --json 同源）。 + """ + per_candidate: List[CandidateResult] = [] + details: Dict[str, List[SentenceOutcome]] = {} + for candidate in candidates: + outcomes = evaluate_candidate(candidate, positives, negatives[candidate.name], positive_labels) + details[candidate.name] = outcomes + per_candidate.append(_fold(candidate.name, outcomes)) + verdict: Dict[str, str] = {} + for entry in per_candidate: + out_of_sample = _out_of_sample_a_results() if entry["name"] == _A_MODAL_FRAME_NAME else None + verdict[entry["name"]] = _verdict_text(details[entry["name"]], out_of_sample) + report = Report(per_candidate=per_candidate, verdict=verdict) + return report, details + + +def measure_candidates( + candidates: Sequence[Candidate], + positives: Sequence[str], + negatives: Mapping[str, Sequence[LabeledSentence]], +) -> Report: + """标定入口（可证伪签名，计划 Task 6）：样本集无效时抛 ValueError。 + + 返回 ``{per_candidate: [{name, fp, fn, fp_samples, fn_samples}, ...], verdict: {name: str}}``。 + 环境不可用（spaCy 缺失 / 模型加载失败，见 ``_load_nlp``）由 detect 抛 RuntimeError； + CLI 层用 ``probe_environment`` 预加载并把任何环境故障转成退出码 2。 + """ + errors = validate_samples(candidates, positives, negatives) + if errors: + raise ValueError("样本集无效：" + "；".join(errors)) + report, _details = _evaluate_all(candidates, positives, negatives) + return report + + +# --------------------------------------------------------------------------- # +# CLI +# --------------------------------------------------------------------------- # + + +def _print_out_of_sample_block() -> None: + """CLI 独立区块：A 维样本外追补（**不入计数**）——3 句原文 + live 结果 + err7 族边界。 + + 评审 RED 修复：这些实测误报此前只住 docstring ⇒ 以产物为据的读者会误得 + "A 维真实文本 FP≈0"。结果与 verdict 追补句同源（``_out_of_sample_a_results``）。 + """ + results = _out_of_sample_a_results() + print() + print("--- 样本外追补（不入计数）---") + print("逗号并列正确句（**不在**冻结样本集内、**不计入**任何 fp/fn；原文见模块常量 OUT_OF_SAMPLE_A）：") + for text, reported in results: + print(f" [报={'True' if reported else 'False'}] {text}") + print("结构性边界（漏报方向，2026-10-15 实测）：err7 族（实词夹在情态动词与末位动词之间，") + print("如 `Ich weiß, dass ich muss heute arbeiten.`）**整族不可见** —— 探测只扫描末位动词") + print("之后的实词；该边界与上列误报同为 HITL 判据的一部分，不允许只住 docstring。") + + +def _print_text_report( + report: Report, + details: Dict[str, List[SentenceOutcome]], + candidates: Sequence[Candidate], + positive_docs: int, + positive_sentences: int, +) -> None: + """文本模式：逐句原始结果 + 计数 + 样例全文（只报比例无法证伪判据，故必须打全文）。""" + descriptions = {candidate.name: candidate.description for candidate in candidates} + print("=== bench_judge_fp（A1 裁判候选维度 FP 标定实验；只标定不接线）===") + print(f"model={get_loaded_model_name()}") + print("positive_source=A1_SCHREIBEN_TEIL2（官方 sample_email，逐句评估）") + print(f"positive_docs={positive_docs} positive_sentences={positive_sentences}") + for entry in report["per_candidate"]: + name = entry["name"] + print() + print(f"--- candidate: {name} ---") + print(f"描述：{descriptions.get(name, '')}") + print("逐句结果（TP=期望报且报；FN=期望报却漏；FP=期望不报却报；TN=期望不报且没报）：") + for outcome in details[name]: + print(f" [{outcome.label}] [{outcome.source}] {outcome.text}") + print(f"fp={entry['fp']} fn={entry['fn']}") + print("误报样例（全文）：") + if entry["fp_samples"]: + for sample in entry["fp_samples"]: + print(f" - {sample}") + else: + print(" （无）") + print("漏报样例（全文）：") + if entry["fn_samples"]: + for sample in entry["fn_samples"]: + print(f" - {sample}") + else: + print(" （无）") + if name == _A_MODAL_FRAME_NAME: + _print_out_of_sample_block() + print() + print("--- verdict（量与建议阈值对照；裁决归 HITL）---") + for name, text in report["verdict"].items(): + print(f"verdict[{name}]={text}") + print() + print("退出码：0=标定完成；1=样本集自身无效（空样本/标注缺失）；2=环境不可用（spaCy 缺失/模型加载失败）") + + +def main(argv: Optional[Sequence[str]] = None) -> int: + """CLI 入口。退出码：0=标定完成；1=样本集无效；2=环境不可用。""" + stdout = sys.stdout + if isinstance(stdout, io.TextIOWrapper): + try: + stdout.reconfigure(encoding="utf-8") # Windows 控制台默认 GBK：德语字符需 UTF-8 + except Exception: # 已关闭/不可重配置的流（如 pytest capture）⇒ 保持原状 + pass + + parser = argparse.ArgumentParser(description="A1 裁判候选维度 FP 标定实验（Task 6 AFK 半：只标定、不接线）。") + parser.add_argument( + "--json", + action="store_true", + help="以 JSON 输出 Report（stdout；含 fp_samples/fn_samples 全文）", + ) + parser.add_argument( + "--negatives", + metavar="PATH", + default=None, + help="覆盖内置负样本集（JSON：{维度名: [{text, expected, note?}, ...]}；缺标注 ⇒ 退出码 1）", + ) + args = parser.parse_args(argv) + + try: + if args.negatives is not None: + negatives: Dict[str, List[LabeledSentence]] = load_negatives_from_json(args.negatives) + else: + negatives = {dim: list(items) for dim, items in NEGATIVES.items()} + except (ValueError, OSError) as exc: + print(f"[样本集无效] 负样本装载失败：{exc}", file=sys.stderr) + return 1 + + pairs = load_positives() + positive_labels = [entry_id for entry_id, _ in pairs] + positive_texts = [text for _, text in pairs] + + errors = validate_samples(CANDIDATES, positive_texts, negatives) + if errors: + print(f"[样本集无效] 共 {len(errors)} 个问题（退出码 1）：", file=sys.stderr) + for error in errors: + print(f" - {error}", file=sys.stderr) + return 1 + + env_error = probe_environment() + if env_error is not None: + print(f"[环境不可用] {env_error}", file=sys.stderr) + return 2 + + report, details = _evaluate_all(CANDIDATES, positive_texts, negatives, positive_labels) + + if args.json: + print(json.dumps(report, ensure_ascii=False, indent=2)) + else: + positive_sentences = sum(len(_split_sentences(text)) for text in positive_texts) + _print_text_report(report, details, CANDIDATES, len(positive_texts), positive_sentences) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) From 55e0f0daedc051285616878d9db9115fb9a7687d Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 20:13:58 +0800 Subject: [PATCH 10/13] =?UTF-8?q?docs(plan+workmemory):=20Task=206=20HITL?= =?UTF-8?q?=20=E8=A3=81=E5=86=B3=E8=90=BD=E6=A1=A3=20=E2=80=94=E2=80=94=20?= =?UTF-8?q?A=20=E7=BB=B4=E4=B8=8D=E5=81=9A=E3=80=81B=20=E7=BB=B4=E6=8E=A5?= =?UTF-8?q?=E7=BA=BF=E4=B8=BA=20warning=EF=BC=88=E5=90=AB=2051=20=E5=8F=A5?= =?UTF-8?q?=E5=AE=9E=E6=B5=8B=E6=9B=B4=E6=AD=A3=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- WORKMEMORY/work.log | 7 +++++++ docs/plans/2026-10-15-a1-judge-expansion.md | 5 +++++ 2 files changed, 12 insertions(+) diff --git a/WORKMEMORY/work.log b/WORKMEMORY/work.log index 1944c778..f8db8f7c 100644 --- a/WORKMEMORY/work.log +++ b/WORKMEMORY/work.log @@ -529,3 +529,10 @@ Caps: filesystem-read, filesystem-write, shell-exec - **基础设施坑（两次）**：两次 subagent 派单被掐（10003 / 10101），第一次留了半成品 + 一条取消用例跑不完（备份 `/tmp/task8-partial.diff` 后丢弃、重派成功）。**教训：给 maker 的反挂死纪律必须写进 prompt**（所有 sleep 要有 wait_for/固定次数兜底、禁 join 线程、禁无界 while、每条用例贴实测耗时）。Task 8 的 flaky 黄卡（心跳窗口余量趋零）由我按 CRV 开方改 1 行（跨调用取 max）并 20 连跑自证 —— 偏离 maker-checker，已如实记录在提交信息。 - **门禁**：5 套件 411 passed；`ruff check .` 全绿；`mypy --strict delector` 66 files 0；契约闸 PASS；CRLF。 - **未做**：Task 3/4/5（三个新维度规则）、Task 6（FP 标定，HITL）、Task 7（闸门收窄 + §4.3 判据表，HITL，含前端降级提示）。**Pi 式分层重构已由用户拍板暂缓**（`docs/agents/architecture.md` 已登记）。 + +### 2026-10-15 16:40 | codebuddy | DECISION +Caps: filesystem-read, filesystem-write, shell-exec +事件：**Task 6 的 HITL 裁决落地**（用户拍板）：A 维**不做**、B 维**接线为 warning**。 +- **A 维（情态动词框架语序）不做**：实测负样本 6/7（「实词夹在情态动词与末位动词之间」整族不可见 = 结构性 FN），且样本外追补的 3 句**正确**句（逗号并列主句）全部误报 ⇒ FP 与 FN 同源、两侧都破。标定产物（`tools/bench_judge_fp.py`）保留作记录、不接线。**Why 这条要记**：本计划第一个"测了之后选择不做"的维度 —— 防止后来者看到 bench 脚本以为它只是"还没接线"。 +- **B 维（时间副词 ↔ 时态一致性）接线为 warning**：正样本 FP 0/35、负样本 7/7、对照 0/6，两档阈值均成立；样本偏小（7 错 + 6 对照）⇒ 先 advisory 不阻断收敛，积累真实用法后再议升 error。可见性靠响应体新增 `judge_advisories`（只增不改）+ Task 7 的前端渲染。 +- 更正一条**未实测口径**：提交 `39e6d79` 的消息里写「COMMON_CORRECT_SENTENCES 47 句」是我未实测的转述，**实测为 51 句** —— 以实测为准（本事件与 PR 正文为准）。 diff --git a/docs/plans/2026-10-15-a1-judge-expansion.md b/docs/plans/2026-10-15-a1-judge-expansion.md index fb65fe80..58565101 100644 --- a/docs/plans/2026-10-15-a1-judge-expansion.md +++ b/docs/plans/2026-10-15-a1-judge-expansion.md @@ -199,6 +199,11 @@ **Subagent Prompt Scaffold (for /dfs-exec):** > "做一次可复跑的 FP 标定实验，**不接线**。① 建 `tools/bench_judge_fp.py`：对两条候选维度（情态动词框架语序 / 时间副词与时态一致性）各写一版**探测实现**（可住在脚本里，不必进 `writing.py`），在 a) 官方 10 篇 `sample_email`（正样本，期望 FP=0）与 b) 每维 ≥5 句手工定向错误句（负样本，期望能报）上逐句跑，输出原始计数表 + 误报样例全文。② 建 `tests/test_judge_fp_bench.py` 钉脚本自身行为（给固定样本 ⇒ 固定计数；不许"跑得过但数不清"）。③ 产出**带阈值的结论建议**（例如：FP 率 ≤ 某值 ⇒ 可做 error；否则 warning 或不做的理由），并**把误报样例原文带回**（不许只报比例 —— 比例无法证伪判据）。RUN：`python tools/bench_judge_fp.py` 与 `python -m pytest tests/test_judge_fp_bench.py -q`，原始输出全带回。⚠️ 若某维在正样本上就误报 ⇒ **如实结论是"不做"**，不许调样本让它好看。" +**HITL 裁决（用户 2026-10-15 拍板，Step 4 已结）**： +- **A 维（情态动词框架语序）= 不做**。依据：实测负样本 6/7（「实词夹在情态动词与末位动词之间」整族不可见 ⇒ FN），且样本外追补的 3 句逗号并列**正确**句全部误报（⇒ 若计入对照组，warning 档条件亦不成立）——**FP 与 FN 同源**，两侧都破。标定产物与数据保留在 `tools/bench_judge_fp.py` 作记录，**不接线**（后来者勿把它当"只是还没接线"）。 +- **B 维（时间副词 ↔ 时态一致性）= 接线为 `level="warning"`（advisory）**。依据：正样本 FP 0/35、负样本 7/7、对照 0/6，两档阈值均成立（样本偏小：7 错 + 6 对照 ⇒ 先 advisory，积累真实用法后再议升 error）。**不阻断收敛**：`violations_of` 只认 `level=="error"`（Task 4 已钉死的语义）。 +- **advisory 的可见性**（编排者定的最小实现）：warning 必须真能被看到，否则是 no-op ⇒ 响应体 `result` 追加 `judge_advisories: list[str]`（**只增不改**），前端渲染与本计划的 Task 7 同批。 + **Step Breakdown:** - [ ] Step 1: 建正/负样本集（负样本每维 ≥5 句，逐句标注期望） - [ ] Step 2: 写探测实现 + 脚本（含脚本自身测试） From cf9ea76bc5ae4fdb3ba7db8d579aa7abea9c9141 Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 21:33:15 +0800 Subject: [PATCH 11/13] =?UTF-8?q?feat(judge):=20B=20=E7=BB=B4=E6=8E=A5?= =?UTF-8?q?=E7=BA=BF=E4=B8=BA=20warning=20+=20=E9=97=B8=E9=97=A8=E6=94=B6?= =?UTF-8?q?=E7=AA=84=E5=88=B0=E4=BB=BB=E6=84=8F=E5=BE=B7=E8=AF=AD=E6=96=87?= =?UTF-8?q?=E6=9C=AC=20+=20=E6=8F=90=E7=A4=BA=E8=AF=8D=E5=8F=82=E6=95=B0?= =?UTF-8?q?=E5=8C=96=EF=BC=88Task=206=20=E6=94=B6=E5=B0=BE=20+=20Task=207?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Task 6 收尾（按用户 2026-10-15 HITL 裁决：A 维不做、B 维接线为 warning）： - 移植 tools/bench_judge_fp.py 已验证的 B 维探测为 writing.detect_past_anchor_tense_conflict（severity=warning、error_type=tempus；冻结脚本未动）。 - 按 level 路由接线：error ⇒ violations（既有语义），warning ⇒ 新增并列键 advisories —— collect_violations 一字符未动（既有 pin 要求 violations 保留格式族 warning）。 - advisory 可见化（否则是 no-op）：端点 _JudgeRecorder 扩为同时接住 judge_engine 与 advisories；响应体 result 追加 judge_advisories（只增不改）；前端在 overlay notes 区非阻断呈现。 - 不阻断收敛有用例钉住：带 advisory 与去掉该句时 (error_count, converged, reason) 逐字段相同。 - A 维未接线（全仓唯一实现仍是冻结的标定记录），符合裁决。 Task 7 技术面： - 闸门按规则族分流（main.py violations_for(kind, verdict) + _text_kind + _polish_violations_of）：格式/字数族（a1_ 前缀）仅书信体；语法族（artikel/kasus/praeposition/numerus/rektion/wortstellung + tempus）对任意德语文本生效。 - 非书信文本的产品语义变更（已写进三处 docstring 并有用例钉住）：模型修不动 ⇒ no_improvement ⇒ argmin 回退原文 + 前端人话原因码。 - 提示词按文本族参数化：run_polish_loop 只加一个可选参数 system_prompt（None ⇒ A1 默认，向后兼容；停止策略/预算/收敛归属一律不动）；pick_system_prompt：书信 ⇒ 内核 A1 逐字，散文 ⇒ 产品层 POLISH_PROSE_SYSTEM_PROMPT（删 A1 自查指令、保留 JSON 契约与逐句/顺序约束）。 - 前端非阻断提示：judge_degraded 与 judge_advisories 在 overlay notes 区呈现（不是 error toast）。 - 死绿守卫改写：三态全绿的 test_ai_polish_non_letter_text_is_not_rolled_back 改为两条能区分行为的断言；goethe 侧旧钉子按新语义显式翻转命名（断言零放宽）。 黄卡清理（独立验收 4 条，全部非阻断）：① _text_kind docstring 登记 greeting.valid 判据的三处边界后果（含"书信缺称呼语 ⇒ 格式族永远不被计数"这一继承边界与候选侧翻转欠账）；② _JudgeRecorder docstring 收窄（argmin 回退路径下 advisories 可能与出口文本不一致，如实登记）；③ 前端降级提示在 no-key 路径抑制（原先"本次仅做格式/字数检查"在循环根本没跑时不实）；④ analyze_a1_email docstring 登记 warning 按族分居两键。 门禁：450 passed（4 套件，含硬门全绿）；ruff 全绿；mypy --strict delector 67 files 0；契约闸 PASS；CRLF。 注：本批 maker 会话在报告前被 API 掐断（改动已落盘）；4 条黄卡由编排者逐条核到行号并复跑门禁后代为提交。批内另有一条既有网络型 flaky（test_get_audio_tts_returns_mp3 走 Edge TTS，单独跑绿）已排除。 --- delector/routes/main.py | 161 +++++++++++++++++++++++----- delector/services/polish_loop.py | 9 +- delector/services/writing.py | 131 +++++++++++++++++++++-- static/js/writer.js | 52 +++++++-- tests/test_goethe_a1_writing.py | 58 +++++----- tests/test_server.py | 177 +++++++++++++++++++++++++++++-- tests/test_writing_rules.py | 71 +++++++++++++ 7 files changed, 581 insertions(+), 78 deletions(-) diff --git a/delector/routes/main.py b/delector/routes/main.py index ad84c642..9c3ade2a 100644 --- a/delector/routes/main.py +++ b/delector/routes/main.py @@ -2203,30 +2203,91 @@ def api_syntax_analyze(req: SyntaxAnalyzeReq) -> Any: _SSE_POLL_INTERVAL_S = 0.02 -def _a1_violations_if_letter(verdict: Dict[str, Any]) -> List[Dict[str, Any]]: - """适用性闸门（**旧语义**：非书信体 ⇒ 零违规）：A1 书信规则只对书信体计数。 +# 格式/字数族 = 书信题材专属规则的 rule 前缀（`a1_*`：称呼语 / 结语 / 字数）。 +# 语法族 = 不以 `a1_` 开头的 rule（artikel / kasus / praeposition / numerus / rektion / +# wortstellung）—— **与题材无关** ⇒ 对任意德语文本生效（Task 7 收窄；`tempus` 是 advisory、 +# 不进 `collect_violations` 的输出，天然不参与计数）。 +_LETTER_FORMAT_RULE_PREFIX = "a1_" + + +def _text_kind(verdict: Dict[str, Any]) -> str: + """文本族判定：**沿用既有 `greeting.valid` 口径**（书信体 ⇔ 称呼语合法）。 + + ⚠️ 以 `greeting.valid` 为唯一判据的三条边界后果（**如实登记，勿删**）： + + ① **书信缺称呼语** ⇒ 归 `prose` ⇒ 格式族（含 `a1_greeting_missing` 这条 error）被 + `a1_` 前缀过滤 ⇒ 该类邮件的格式错**永远不被计数**；且提示词按初始文本族装配 + （`pick_system_prompt`）⇒ 走散文版。这是**继承自旧闸门**的边界，不是本批回归。 + ② **散文含称呼语** ⇒ 归 `letter` ⇒ 格式族照用（对散文生效）+ 书信版提示词。 + ③ **候选侧翻转（未收口欠账）**：循环的 kind **逐候选**按候选自身裁决体判定 + （`_polish_violations_of` 单参契约）⇒ 模型"删掉称呼语"的那个候选会翻转口径 —— + 该候选自身的格式族违规被过滤后 v 可能掉到 0。这是 2026-10-14 计划里已登记的 + "闸门对候选单向生效"欠账，本批**未收口**，如实登记。 + """ + greeting = verdict.get("greeting") if isinstance(verdict, dict) else None + if isinstance(greeting, dict) and greeting.get("valid"): + return "letter" + return "prose" + + +def violations_for(kind: str, verdict: Dict[str, Any]) -> List[Dict[str, Any]]: + """适用性闸门（**Task 7 收窄版**：按**规则族**分流，而不是按整份裁判开关）。 - 旧闸门的理由：手上这套裁判（`analyze_a1_email`）报的是**书信题材**的规则 —— 对**非书信体** - （普通作文）它必然报 `a1_greeting_missing`(error)，那是**题材差异**不是错误；照单全收会让 - `v_0 = 1`、`v_1 >= v_0` ⇒ `no_improvement` ⇒ 回退原文 ⇒ 用户点了润色拿回原文（功能报废）。 - 故非书信体（`greeting.valid` 为假）⇒ 返回 `[]`（闸门「无话可说」，语义等价于首轮即接受， - **不等于**「裁判判定无错」）。 + - `kind == "letter"` ⇒ 格式/字数族（`a1_*`）+ 语法族 **全计**； + - `kind == "prose"` ⇒ **只计语法族**（语法与题材无关）—— 这就是「循环的价值面扩到 + 任意德语文本」的落点。 统一抽取器：走 `collect_violations`（新键 `violations` 优先、legacy `suggestions` 回退， - 且只取 `level == "error"`），与裁判层同口径。 + 且只取 `level == "error"`），与裁判层同口径；advisory（warning 级）不在其输出里。 - ⚠️ 注记（**本批故意不落地**）：把闸门改成**按规则族分流**（格式/字数族只对书信体计数、 - 语法族对**任意德语文本**生效）属 **Task 7（HITL）** —— 那是**产品行为变更**（非书信文本从 - "首轮即接受"变成"真迭代"），且会让模型修不动的作文落到 `no_improvement` ⇒ argmin 回退原文 - （ADR §10.3 记过的「用户点了润色拿回原文」失败模式）⇒ MUST 由用户拍板、不能作为本批的副产品 - 落地。见 `docs/plans/2026-10-15-a1-judge-expansion.md` Task 7。 + ⚠️ **产品语义（ADR §10.3 失败模式的实际落点，MUST NOT 静默改）**：非书信文本的语法违规 + 开始计数 ⇒ 若模型修不动（v 不降），循环按 Task 4 钉死的语义走 `no_improvement` ⇒ argmin + 回退**原文**（**不是**"首轮即接受"）。这是**明知而接受**的行为变更（2026-10-15 用户拍板）： + 价值面从"仅 A1 书信"扩到"任意德语文本"，代价是修不动的文本拿到原文 + 人话原因码 + （前端 `POLISH_REASON_COPY.no_improvement`）。 + + 历史注记（为什么不再"非书信体一律零违规"）：旧闸门是针对"裁判只有书信格式规则"的权宜 + —— 当时 `a1_greeting_missing` 对每篇非书信文本恒报 error ⇒ v 恒 > 0 ⇒ 恒回退原文。 + 语法维度接线后前提变了：上面的失败模式只在**模型真修不动**时出现，而不是对非书信文本恒真。 """ violations = collect_violations(verdict) - greeting = verdict.get("greeting") if isinstance(verdict, dict) else None - if isinstance(greeting, dict) and greeting.get("valid"): - return violations # 书信体：照常计数 - # 非书信体：整套 A1 书信规则不适用（题材差异）⇒ 闸门「无话可说」。 - return [] + if kind == "letter": + return violations + return [v for v in violations if not str(v.get("rule", "")).startswith(_LETTER_FORMAT_RULE_PREFIX)] + + +def _polish_violations_of(verdict: Dict[str, Any]) -> List[Dict[str, Any]]: + """循环入口（单参，`violations_of` 契约）：文本族由**裁决体自己**判（沿用 `greeting.valid`）。""" + return violations_for(_text_kind(verdict), verdict) + + +# 散文向系统提示词（Task 7 的立论冲突解法 b：提示词按**文本族**参数化，业务知识住产品层）。 +# 与书信版（内核 `polish_loop.POLISH_LOOP_SYSTEM_PROMPT`）的差异——**只删题材指令，不动协议**： +# - 去掉逐字的 A1 书信自查指令（"称呼语存在且以逗号结尾 / 逗号后正文首词小写 / 结语后不得加 +# 逗号"）：评审黄卡 #2 —— 对非书信文本它会**诱导模型加一个称呼语**，而格式族规则此时已被 +# 闸门关掉 ⇒ 污染无守卫； +# - **保留** JSON 契约（循环按它解析回复）与"逐句润色、保持句子结构与出现顺序"（来自 +# `essay_diff.diff_sentences` 的按句对齐，diff 逐 hunk 采纳 UI 的**关键约束**）。 +POLISH_PROSE_SYSTEM_PROMPT = ( + "你是德语写作润色助手。每一轮**只**回复一个 JSON 对象，不要输出任何其他文字。\n" + "回复有且只有两种形态：\n" + '1) 还需要证据：{"tool_call": {"name": "<工具名>", "payload": {...}}}\n' + '2) 可以收尾：{"corrected_text": "<润色后的全文>", "notes_zh": ["<中文说明>", ...]}\n' + "工具名必须在可用工具列表里，否则会被拒绝并把错误原样回传给你。\n" + "请尽量逐句润色，保持句子的结构与出现顺序，不要合并或拆分句子，除非确实必要。" +) + + +def pick_system_prompt(kind: str) -> str: + """文本族 → 系统提示词（Task 7；**业务知识住在产品层**，内核只收参数）。 + + - `"letter"` ⇒ 既有 A1 书信提示词（`polish_loop.POLISH_LOOP_SYSTEM_PROMPT`，逐字）； + - 其余（`"prose"` 及未知值）⇒ 散文向提示词 —— 未知 kind 取散文向是**保守默认**： + 宁少一条题材指令（漏掉书信自查），也不冒"对非书信文本诱导加称呼语"的污染风险。 + """ + if kind == "letter": + return polish_loop.POLISH_LOOP_SYSTEM_PROMPT + return POLISH_PROSE_SYSTEM_PROMPT def _make_tool_audit_hook(seen: List[str]) -> Any: @@ -2314,6 +2375,13 @@ def _make_judge(leitpunkte: Optional[List[str]], nlp: Any) -> Callable[[str], Di “没检查语法”不等于“语法零违规”：声明层的诚实性由裁决体的 `judge_engine` 透出 （`_JudgeRecorder` 捕获 → 响应体 `judge_degraded`），门禁层 fail-closed 由调用方承担。 **禁止**靠塞一条人造 violation 来实现降级提示。 + + ⚠️ **非书信文本的产品语义（Task 7 收窄后的落点；ADR §10.3 失败模式的实际发生点，勿删）**： + 本裁判对**任意德语文本**都会给出语法族裁决（语法与题材无关），闸门（`violations_for`）只把 + 格式/字数族（`a1_*`）限给书信体。后果：非书信文本 + 语法错若**模型修不动**（候选的 v 不降）， + 循环按 Task 4 钉死的语义走 `no_improvement` ⇒ argmin 回退**原文** —— + **不是**"首轮即接受"，用户拿到原文 + 前端人话原因码（`no_improvement`）。 + 这是 2026-10-15 用户拍板的**明知而接受**的行为（价值面从"仅 A1 书信"扩到"任意德语文本"）。 """ def _judge(text: str) -> Dict[str, Any]: @@ -2323,12 +2391,24 @@ def _judge(text: str) -> Dict[str, Any]: class _JudgeRecorder: - """裁判的**录制包装**（与 `_PolishReplyRecorder` 同形）：记下每次裁决的 `judge_engine`， - 再原样返回裁决。 + """裁判的**录制包装**（与 `_PolishReplyRecorder` 同形）：记下每次裁决的 `judge_engine` + 与 `judge_advisories`，再原样返回裁决。 + + 为什么端点要自己录：`judge_engine` / `advisories` 住在裁决体里（`analyze_a1_email` 的 + 并列字段），而循环出口的 `LoopResult` 不带它们 ⇒ 端点必须从裁判这一侧捕获，才能把 + 降级状态与 advisory **如实透出**到响应体（红线 1：不得让“没检查”看起来像“检查通过”； + Task 6 HITL：warning 必须真能被看到，否则是 no-op）。 - 为什么端点要自己录：`judge_engine` 住在裁决体里（`analyze_a1_email` 的并列字段），而循环 - 出口的 `LoopResult` 不带它 ⇒ 端点必须从裁判这一侧捕获，才能把降级状态如实透出到响应体 - （红线 1：不得让“没检查”看起来像“检查通过”）。 + `judge_advisories` 取裁决体 `advisories`（统一形状、`level=="warning"`）的 `message` + 文本；它**不进** `violations`（`violations_of`/`collect_violations` 只认 `level=="error"`） + ⇒ 不改变 v、不阻断收敛。每次裁决**覆盖式**记录：记录的是**最后一次裁决**。 + + ⚠️ 收窄说明（如实登记，勿删）：**argmin 回退路径下 `judge_advisories` 可能与出口文本 + 不一致** —— 未收敛时循环出口走 `min(history, key=v)` 回退，出口文本可能是**更早**的 + 候选或原文（`min` 并列取最早 ⇒ 此时原文胜出），而本包装记的是**最后一次裁判调用**的 + 裁决 ⇒ 响应体 advisory 描述的是"最后一次被裁的文本"，不保证是返回给用户的那份。 + 非阻断：advisory **不进任何计数**（v / 停止策略 / 收敛归属全不受它影响）⇒ 仅呈现层 + 的对应性欠账。（`judge_engine` 是引擎装配态、与文本无关，不受此影响。） `__call__` 的第二参数兼容循环的 `judge_fn(text, leitpunkte)` 调用约定（leitpunkte 已由 `_make_judge` 闭包绑定，这里忽略即可）。 @@ -2338,6 +2418,7 @@ def __init__(self, judge_fn: Callable[[str], Dict[str, Any]]) -> None: self._judge_fn = judge_fn # 未被裁过时的保守默认：宁报降级（rules_only）不报可用，避免“没跑却标成已跑”。 self.judge_engine: str = "rules_only" + self.judge_advisories: List[str] = [] def __call__(self, text: str, leitpunkte: Optional[List[str]] = None) -> Dict[str, Any]: verdict = self._judge_fn(text) @@ -2345,6 +2426,9 @@ def __call__(self, text: str, leitpunkte: Optional[List[str]] = None) -> Dict[st engine = verdict.get("judge_engine") if isinstance(engine, str) and engine: self.judge_engine = engine + advisories = verdict.get("advisories") + if isinstance(advisories, list): + self.judge_advisories = [str(a.get("message", "")) for a in advisories if isinstance(a, dict)] return verdict @@ -2353,6 +2437,9 @@ class _PolishOutcome(NamedTuple): `judge_engine`（追加，Task 1）：本次运行实际装配的裁判引擎（`"rules+spacy"` / `"rules_only"`）， 端据此算出响应体 `judge_degraded`。 + + `judge_advisories`（追加，Task 6 HITL 收尾）：最后一次裁决的 advisory 文本（warning 级， + 当前 = B 维 `tempus`）——响应体 `judge_advisories` 的承载，**不参与任何计数**。 """ text: str @@ -2361,6 +2448,7 @@ class _PolishOutcome(NamedTuple): converged: bool reason: Optional[str] judge_engine: str + judge_advisories: List[str] def _no_key_outcome(text: str) -> _PolishOutcome: @@ -2376,6 +2464,7 @@ def _no_key_outcome(text: str) -> _PolishOutcome: reason=REASON_NO_API_KEY, # 循环没跑 ⇒ 裁判也未装配 ⇒ 保守记为降级（宁报降级不报可用）。 judge_engine="rules_only", + judge_advisories=[], ) @@ -2386,12 +2475,21 @@ async def _run_polish( on_progress: Optional[Any] = None, should_stop: Optional[Any] = None, ) -> _PolishOutcome: - """跑一遍润色循环：Task 4 内核 + Task 5 白名单/钩子 + 适用性闸门 + **语法裁判装配**。 + """跑一遍润色循环：Task 4 内核 + Task 5 白名单/钩子 + **规则族闸门** + 语法裁判装配 + + **文本族感知的提示词装配**。 引擎来源（评审 RED#1 的闭环点）：先**只读**已加载模型（`get_loaded_nlp`，不触发加载/下载）； 没有则在线程里尝试**仅本地**加载（`try_load_nlp_no_download` 绝不 `spacy.cli.download`， 且同步函数放 `asyncio.to_thread` 里跑，不阻塞事件循环）。`nlp=None` ⇒ 裁判降级为 `rules_only`、循环照常收敛，降级状态由 `judge_engine` 如实透出（响应体 `judge_degraded`）。 + + 文本族（Task 7）：`kind` 由**纯规则**裁决体判一次（见下方注释），决定 + ①系统提示词（`pick_system_prompt`：内核的 A1 书信指令对非书信体不适用）； + ②闸门口径（`violations_for`：格式族只对书信体、语法族对任意德语文本）。 + + 产品语义（ADR §10.3 的落点，同款登记在 `violations_for` / `_make_judge` docstring）： + 非书信文本的语法违规**会计数** ⇒ 模型修不动时 `no_improvement` ⇒ argmin 回退**原文** + （**不是**"首轮即接受"）。 """ import logging @@ -2401,13 +2499,18 @@ async def _run_polish( nlp = _nlp_processor.get_loaded_nlp() if nlp is None: nlp = await asyncio.to_thread(_nlp_processor.try_load_nlp_no_download) + # 文本族（选提示词用）：纯规则口径（不传 nlp ⇒ 不加载、不跑 spaCy）；`greeting.valid` + # 本身是纯规则，与带 nlp 的裁决逐字一致。只用于装配提示词，不当作裁决（裁决仍由 + # judge_recorder 全量记录并透出）。 + kind = _text_kind(analyze_a1_email(text)) judge_recorder = _JudgeRecorder(_make_judge(None, nlp)) try: loop = await polish_loop.run_polish_loop( text=text, tools=POLISH_TOOL_ALLOWLIST, dispatch=functools.partial(call_tool, hooks=(_make_tool_audit_hook(seen),)), - violations_of=_a1_violations_if_letter, + violations_of=_polish_violations_of, + system_prompt=pick_system_prompt(kind), # 必须真的注入（不能退回内核默认裁判）—— 否则生产上语法裁判恒不生效 = dead-green。 judge=judge_recorder, chat=recorder, @@ -2435,6 +2538,7 @@ async def _run_polish( converged=loop.converged, reason=loop.reason, judge_engine=judge_recorder.judge_engine, + judge_advisories=judge_recorder.judge_advisories, ) @@ -2444,7 +2548,7 @@ def _judge_degraded(outcome: _PolishOutcome) -> bool: def _polish_payload(outcome: _PolishOutcome) -> Dict[str, Any]: - """`/api/writing/ai-polish` 的 `result`（**只增不改**：追加 `judge_degraded`）。""" + """`/api/writing/ai-polish` 的 `result`（**只增不改**：追加 `judge_degraded` / `judge_advisories`）。""" return { "corrected_text": outcome.text, "notes_zh": outcome.notes_zh, @@ -2452,11 +2556,13 @@ def _polish_payload(outcome: _PolishOutcome) -> Dict[str, Any]: "converged": outcome.converged, "unconverged_reason": None if outcome.converged else outcome.reason, "judge_degraded": _judge_degraded(outcome), + "judge_advisories": outcome.judge_advisories, } def _polish_diff_payload(text: str, outcome: _PolishOutcome) -> Dict[str, Any]: - """`/api/writing/ai-polish/diff` 的 `result`（既有字段与顺序一律不动，末尾追加 `judge_degraded`）。""" + """`/api/writing/ai-polish/diff` 的 `result`（既有字段与顺序一律不动，末尾追加 `judge_degraded` / + `judge_advisories`）。""" from delector.services.essay_diff import diff_sentences return { @@ -2468,6 +2574,7 @@ def _polish_diff_payload(text: str, outcome: _PolishOutcome) -> Dict[str, Any]: "converged": outcome.converged, "unconverged_reason": None if outcome.converged else outcome.reason, "judge_degraded": _judge_degraded(outcome), + "judge_advisories": outcome.judge_advisories, } diff --git a/delector/services/polish_loop.py b/delector/services/polish_loop.py index 6498f9b1..a57e8abe 100644 --- a/delector/services/polish_loop.py +++ b/delector/services/polish_loop.py @@ -329,6 +329,7 @@ async def run_polish_loop( judge: Callable[[str, list[str] | None], dict[str, Any]] | None = None, violations_of: Callable[[dict[str, Any]], list[dict[str, Any]]] | None = None, dispatch: Callable[[str, dict[str, Any]], Awaitable[dict[str, Any]]] | None = None, + system_prompt: str | None = None, clock: Callable[[], float] = time.monotonic, on_progress: Callable[[dict[str, Any]], None] | None = None, should_stop: Callable[[], bool] | None = None, @@ -336,6 +337,11 @@ async def run_polish_loop( """跑一遍有界润色循环。**全部依赖可注入**（测试一律 stub，严禁真 Key）。 返回 `LoopResult`：未收敛 MUST 带原因码（零静默失败），`rounds` 是真实跑过的轮数。 + + `system_prompt`（Task 7，**唯一新增参数，向后兼容**）：`None` ⇒ 用内核默认的 A1 书信 + 提示词（`POLISH_LOOP_SYSTEM_PROMPT`）；产品层可按文本族传入（书信 ⇒ 默认；散文 ⇒ + 不含称呼语/结语指令的变体，见 `routes.main.pick_system_prompt`）。**只换提示词文本**： + 停止策略 / 预算 / 收敛归属（Task 4 定稿）一律不动。 """ tools_map: Mapping[str, Callable[..., Awaitable[dict[str, Any]]]] = tools or {} judge_fn: Callable[[str, list[str] | None], dict[str, Any]] = judge if judge is not None else _default_judge @@ -346,7 +352,8 @@ async def run_polish_loop( model = "" if chat is not None else get_effective_api_model() messages: list[dict[str, Any]] = [ - {"role": "system", "content": POLISH_LOOP_SYSTEM_PROMPT}, + # `system_prompt=None` ⇒ 内核默认 A1 书信提示词（向后兼容；Task 7 的注入缝）。 + {"role": "system", "content": POLISH_LOOP_SYSTEM_PROMPT if system_prompt is None else system_prompt}, {"role": "user", "content": f"待润色的德语文本:\n{text}"}, ] if tools_map: diff --git a/delector/services/writing.py b/delector/services/writing.py index ff23ab6a..f0d55d5a 100644 --- a/delector/services/writing.py +++ b/delector/services/writing.py @@ -900,6 +900,107 @@ def detect_verb_second_position(tokens: List[Any], base: int) -> List[Dict[str, return spans +# ── 规则 F：过去时间锚 × 时态一致性（advisory / warning，Task 6 HITL 裁决）──────── +# 移植自 `tools/bench_judge_fp.py` 的 B 维探测（**该脚本是冻结的标定记录，勿改**）。 +# HITL 裁决（用户 2026-10-15）：接线为 `level="warning"` —— 正样本 FP 0/35、负样本 7/7、 +# 对照 0/6，两档阈值均成立；但样本偏小（7 错 + 6 对照）⇒ **先 advisory，不阻断收敛** +# （`violations_of`/`collect_violations` 只认 `level=="error"`），积累真实用法后再议升 error。 +# 探测器刻意不依赖 dep 边（实测 spaCy 对德语框架解析不可靠，见 bench 模块头），只用 +# 「时间锚词表 + morph 时态 + 完成时豁免」。 +_PAST_ANCHOR_ADVERBS = frozenset( + { + "gestern", + "vorgestern", + "damals", + "früher", + "frueher", + "neulich", + "kürzlich", + "kuerzlich", + "ehemals", + } +) +# letzte/letzten/... + 时间名词 才是锚（单独 "letzte" 可能是"末班车"）。 +_LETZTE_FORMS = frozenset({"letzte", "letzten", "letzter", "letztes"}) +_TIME_NOUNS = frozenset( + { + "woche", + "wochen", + "monat", + "monaten", + "jahr", + "jahren", + "wochenende", + "mal", + "sommer", + "winter", + "tag", + "tagen", + } +) +# 现在时形式的完成时助动词（haben/sein）—— 句中存在 Partizip II 时豁免。 +# 例：`Gestern habe ich eine Suppe gekocht.` 的 habe 是现在时形态但整体是过去语义。 +_PERFECT_AUX_PRES = frozenset({"habe", "hast", "hat", "haben", "habt", "bin", "bist", "ist", "sind", "seid"}) + + +def _past_anchor_token(tokens: List[Any]) -> Optional[Any]: + """返回句中第一个过去时间锚 token（无 ⇒ None）。""" + for i, token in enumerate(tokens): + if token.lower_ in _PAST_ANCHOR_ADVERBS: + return token + if token.lower_ in _LETZTE_FORMS and i + 1 < len(tokens) and tokens[i + 1].lower_ in _TIME_NOUNS: + return token + return None + + +def detect_past_anchor_tense_conflict(tokens: List[Any], base: int) -> List[Dict[str, Any]]: + """规则 F（**advisory / warning**）：过去时间锚 + 现在时限定动词（非完成时结构）。 + + 实测锚点：`Gestern gehe ich zur Schule.` ⇒ 报 span 指向 `gehe`（span=(8, 12)）； + `Gestern ging ich zur Schule.` / `Gestern habe ich eine Suppe gekocht.` ⇒ 0 条。 + + 判据（词表 + morph；与 bench 同源）： + 1. 句中含过去时间锚（gestern / letzte Woche / damals ...）； + 2. 存在 morph `VerbForm=Fin` 且 `Tense=Pres` 的动词； + 3. 豁免完成时结构：句中存在 Partizip II（`VerbForm=Part` 的 VERB）时， + haben/sein 的现在时形式不触发（`Gestern habe ich ... gekocht.` 是正确句）。 + + 每句至多报 1 条（首个命中的限定动词；与 bench 的句级布尔口径一致，避免 advisory 刷屏）。 + + 已知边界（未覆盖，如实登记，与 bench 同源）：`Gestern muss ich müde gewesen sein.` 这类 + "情态词 + 完成时不定式"的正确推测句会被报（advisory 语义下可接受）；`Morgen`/`am Samstag` + 等中性/未来时间表达不在锚表内 ⇒ 不报。 + + `corrected_form` 留空串：确定性的过去时形式需要完整变位表，编一个具体形式就是误导 + （宁缺勿假）——方向性建议在 `explanation_zh` 里给出。 + """ + spans: List[Dict[str, Any]] = [] + anchor = _past_anchor_token(tokens) + if anchor is None: + return spans + has_partizip = any(t.pos_ == "VERB" and "Part" in t.morph.get("VerbForm") for t in tokens) + for token in tokens: + if "Fin" in token.morph.get("VerbForm") and "Pres" in token.morph.get("Tense"): + if has_partizip and token.lower_ in _PERFECT_AUX_PRES: + continue + start, end = _tok_off(token, base) + spans.append( + { + "severity": "warning", + "error_type": "tempus", + "corrected_form": "", + "explanation_zh": ( + f"句中时间锚「{anchor.text}」指向过去，但限定动词「{token.text}」是现在时。" + f"A1 建议改用过去时（Präteritum）或完成时（Perfekt）。" + ), + "start": start, + "end": end, + } + ) + break + return spans + + def _collect_prep_hints(tokens: List[Any], base: int) -> List[Dict[str, Any]]: """收集介词支配格内联提示。""" hints = [] @@ -1120,8 +1221,14 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None, nlp: Opt 追加并列字段（Task 1/2，只增不改；既有键逐字不动）： - `violations`：统一形状 `{rule, level, message, span}`（格式族 + 语法族并列）； + - `advisories`：**warning 级**语法族的并列键（Task 6 HITL 裁决的 B 维 `tempus`）—— + 与 `violations` 同形状、同 span 口径，但 `collect_violations` 不读它 ⇒ **不阻断收敛**； - `judge_engine`：`"rules+spacy"`（nlp 可用且语法族至少跑过一个检测器）/ `"rules_only"`（否则）。 + ⚠️ **warning 级条目按族分居两键**（如实登记）：格式族 warning（如 `a1_word_count`） + 留在 `violations`（既有 pin 所钉），语法族 warning（`tempus`）入 `advisories`； + 取"全部 warning"需并集两键。 + **降级运行时 `converged` 的语义边界**（评审 RED#2 的诚实性，勿删）：`judge_engine == "rules_only"` 时语法族**根本未检查**，此时「零违规 ⇒ 收敛」只代表**格式族**无阻塞性违规，**不等于**语法正确； 任何人（判据表/发行说明/宣传文案）MUST NOT 把该次 `converged` 当作「全引擎零违规」的证据 @@ -1262,6 +1369,10 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None, nlp: Opt violations: List[Dict[str, Any]] = [ {"rule": s["rule"], "level": s["level"], "message": s["message"], "span": None} for s in suggestions ] + # advisory 并列键（Task 6 HITL 收尾）：**warning 级**语法族（当前 = B 维 `tempus`）住这里。 + # `collect_violations` 只读 `violations` 且只认 `level=="error"` ⇒ advisory 不阻断收敛； + # 端点经 `_JudgeRecorder` 取它的 `message` 进响应体 `judge_advisories`（可见性）。 + advisories: List[Dict[str, Any]] = [] judge_engine = "rules_only" if nlp is not None and text and text.strip(): # 沿用 `analyze_essay_text(text, nlp)` 的「显式传 nlp」惯例：不在模块内自读全局 nlp。 @@ -1277,18 +1388,21 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None, nlp: Opt + detect_subject_verb_agreement(toks, base) + detect_verb_case_government(toks, base) + detect_verb_second_position(toks, base) + + detect_past_anchor_tense_conflict(toks, base) ) # 语法族至少跑过一个检测器（哪怕零违规）⇒ 引擎标记为 rules+spacy。 judge_engine = "rules+spacy" for sp in spans: - violations.append( - { - "rule": str(sp.get("error_type", "")), - "level": "error" if sp.get("severity") == "error" else "warning", - "message": str(sp.get("explanation_zh", "")), - "span": (int(sp["start"]), int(sp["end"])) if ("start" in sp and "end" in sp) else None, - } - ) + entry = { + "rule": str(sp.get("error_type", "")), + "level": "error" if sp.get("severity") == "error" else "warning", + "message": str(sp.get("explanation_zh", "")), + "span": (int(sp["start"]), int(sp["end"])) if ("start" in sp and "end" in sp) else None, + } + # 路由以 `level` 为准（单一判据点）：error ⇒ `violations`（进违规计数）； + # warning ⇒ `advisories`（advisory，不阻断收敛 —— Task 6 HITL 裁决的落地）。 + # 变异自证①：把 tempus 的 severity 改成 error ⇒ 立刻翻进 `violations`。 + (violations if entry["level"] == "error" else advisories).append(entry) return { "word_count": word_count, @@ -1305,5 +1419,6 @@ def analyze_a1_email(text: str, leitpunkte: Optional[List[str]] = None, nlp: Opt "leitpunkte_results": leitpunkte_results, "suggestions": suggestions, "violations": violations, + "advisories": advisories, "judge_engine": judge_engine, } diff --git a/static/js/writer.js b/static/js/writer.js index 316868d4..3f7c1a86 100644 --- a/static/js/writer.js +++ b/static/js/writer.js @@ -42,7 +42,13 @@ let polishState = { corrected: '', hunks: [], notes_zh: [], - error_count: 0 + error_count: 0, + // Task 6/7 的响应契约（只增不改）：advisory 文本 + 引擎降级标记。 + // 两者都只做**非阻断**呈现（overlay 的 notes 区），绝不弹 error toast。 + judge_advisories: [], + judge_degraded: false, + // Y3：no-key 抑制分支的输入（no-key 路径循环根本没跑，见 renderPolishReview 的守卫）。 + unconverged_reason: null }; // ── Error Type Labels & Badges ────────────────────────────────────────────── @@ -1199,14 +1205,40 @@ export function renderPolishReview() { const notesEl = document.getElementById('polish-notes'); if (notesEl) { - if (polishState.notes_zh && polishState.notes_zh.length > 0) { - notesEl.classList.remove('hidden'); - notesEl.innerHTML = ` -
💡 AI 润色解析与语法点评 (${polishState.notes_zh.length} 条)
+ const notes = polishState.notes_zh || []; + // Task 6/7：advisory（warning 级，如时态口径不一致）与引擎降级提示都**复用**这块 + // notes 区呈现 —— 非阻断、不是 error toast（降级提示的文案口径见 + // `judge_degraded`；advisory 不参与任何计数，见后端 `advisories` / `judge_advisories`）。 + const advisories = polishState.judge_advisories || []; + let html = ''; + if (notes.length > 0) { + html += ` +
💡 AI 润色解析与语法点评 (${notes.length} 条)
+
+ ${notes.map(n => `
• ${esc(n)}
`).join('')} +
+ `; + } + if (advisories.length > 0) { + html += ` +
⚠️ 语法提醒（不影响采纳）(${advisories.length} 条)
- ${polishState.notes_zh.map(n => `
• ${esc(n)}
`).join('')} + ${advisories.map(n => `
• ${esc(n)}
`).join('')}
`; + } + // Y3 小修（二选一取①"抑制"）：no-key 路径循环**根本没跑**（后端 `_no_key_outcome` + // 什么都没检查）⇒"本次仅做格式/字数检查"不实 ⇒ `unconverged_reason === 'no_api_key'` + // 时抑制本提示（no-key 已有自己的 toast / notes 文案，抑制不丢信息）。不选②改措辞： + // 那会连"有 key 但无 nlp"这条提示真实成立（格式/字数确实做了）的路径一起说糊。 + if (polishState.judge_degraded && polishState.unconverged_reason !== 'no_api_key') { + html += ` +
ℹ️ 语法检查未启用：本机未加载德语模型，本次仅做格式/字数检查。
+ `; + } + if (html) { + notesEl.classList.remove('hidden'); + notesEl.innerHTML = html; } else { notesEl.classList.add('hidden'); notesEl.innerHTML = ''; @@ -1324,13 +1356,17 @@ export async function aiPolishEssay() { } if (payload) { - const { original, corrected, hunks, notes_zh, error_count } = payload; + const { original, corrected, hunks, notes_zh, error_count, judge_advisories, judge_degraded, unconverged_reason } = payload; polishState = { original: original || text, corrected: corrected || text, hunks: (hunks || []).map(h => ({ ...h, accepted: true })), notes_zh: notes_zh || [], - error_count: error_count || 0 + error_count: error_count || 0, + judge_advisories: judge_advisories || [], + judge_degraded: judge_degraded === true, + // Y3：抑制分支的输入（收敛时为 null；no-key 路径为 'no_api_key'）。 + unconverged_reason: unconverged_reason || null }; openPolishOverlay(); renderPolishReview(); diff --git a/tests/test_goethe_a1_writing.py b/tests/test_goethe_a1_writing.py index 047a8cea..37e41458 100644 --- a/tests/test_goethe_a1_writing.py +++ b/tests/test_goethe_a1_writing.py @@ -14,7 +14,7 @@ from fastapi.testclient import TestClient from delector.data import a1_writing_dict -from delector.routes.main import _a1_violations_if_letter +from delector.routes.main import violations_for from delector.server import app from delector.services.polish_loop import default_violations_of from delector.services.writing import analyze_a1_email, check_a1_formular_answer, collect_violations @@ -220,15 +220,13 @@ def test_a1_writing_frontend_html_and_css(): _LETTER_TEXT = "Liebe Maria,\nich lade dich ein.\nViele Grüße,\nAnna" -def test_a1_violations_gate_only_counts_when_text_is_a_letter(): - """适用性闸门（**Unknown A 的边界**）：A1 书信规则只对书信体计数。 +def test_a1_violations_gate_format_family_still_letter_only(): + """闸门（Task 7 收窄后的口径）：格式/字数族只对书信体生效；无语法违规的非书信文本 ⇒ 零计数。 - 裁判集今天**只有** A1 书信规则（`analyze_a1_email`，裁判集扩充属 Unknown A， - 本计划不做）。对非书信文本它必然报 `a1_greeting_missing`(error) —— 那是**题材 - 差异**，不是错误 ⇒ 闸门让它「无话可说」（返回 []）。 - - 注意这**不等于**「裁判判定无错」：它只是说明手上这套规则不适用于该文本， - 语义等价于今天的一次性润色（首轮即接受），而不是「零违规」的证明。 + - 非书信体 `_ESSAY_TEXT` 的裁决体只有格式族违规（无 nlp ⇒ 语法族未跑）⇒ + `violations_for("prose", ·)` 为 [] —— 但这**不等于**「裁判判定无错」：语义是 + 「格式族对本文本不适用 + 语法族没有可计的东西」，与旧文档的措辞不同、结论按本次输入相同。 + - 书信体照常计数（闸门必须**有选择性**，一律返回 [] 是关掉裁判，不是闸门）。 """ verdict_letter = analyze_a1_email(_LETTER_TEXT) verdict_essay = analyze_a1_email(_ESSAY_TEXT) @@ -238,35 +236,47 @@ def test_a1_violations_gate_only_counts_when_text_is_a_letter(): # 无闸门时：非书信体被判「缺少称呼语」= error ⇒ v_0 = 1 ⇒ 循环会误判「改不动」 assert len(default_violations_of(verdict_essay)) >= 1 - # 有闸门：规则不适用 ⇒ 零违规 - assert _a1_violations_if_letter(verdict_essay) == [] - # 书信体照常计数（闸门必须**有选择性**，一律返回 [] 是关掉裁判，不是闸门） - assert len(_a1_violations_if_letter(verdict_letter)) >= 1 + # 收窄后的闸门：格式族对非书信体不计数（此处裁决体无语法违规 ⇒ 结果为空） + assert violations_for("prose", verdict_essay) == [] + # 书信体照常计数 + assert len(violations_for("letter", verdict_letter)) >= 1 -def test_a1_violations_gate_does_not_count_grammar_for_non_letter_text(nlp): - """★ 本批「不改行为」的钉子：非书信体 + 语法错 ⇒ **MUST 仍不计数**。 +def test_a1_violations_gate_counts_grammar_for_non_letter_text(nlp): + """★ Task 7 闸门收窄（**旧钉子的显式改写**）：非书信体 + 语法错 ⇒ 语法违规**真被计数**。 - 这是**故意钉住的当前行为**（语法族此刻**只对书信体生效**）—— **Task 7 会显式改写它** - （把闸门按规则族分流：格式/字数族只对书信体、语法族对**任意德语文本**生效）。钉在这里的 - **目的**：让「闸门被收窄」这件事**不可能被静默做掉** —— 谁把闸门改成按规则族分流，这条就红。 + 这枚钉子此前钉住"非书信体 MUST 仍不计数"，目的就是让「闸门被收窄」不可能被静默做掉； + 2026-10-15 用户拍板收窄后，本用例**翻转口径**成为新行为的守卫（谁把闸门改回 + "非书信体一律零违规"，这条立刻红 —— 变异自证②）。 - 判别力来源：先证语法错**真实存在**于裁决体（"ein Hund" ⇒ `artikel` 违规），再证闸门此刻 - **仍**对它返回 []（不是「没有违规可挡」的空转）。 + 判别力来源：先证语法错**真实存在**于裁决体（"ein Hund" ⇒ `artikel` 违规）， + 再证闸门**现在**对它计数（不是「没有违规可挡」的空转），且格式族不被顺带带进来。 """ verdict_essay = analyze_a1_email(_ESSAY_TEXT, nlp=nlp) - # 前提①：非书信体（称呼语不合法 ⇒ 走旧闸门的「不适用」分支）。 + # 前提①：非书信体（称呼语不合法 ⇒ 文本族 = prose）。 assert verdict_essay["greeting"]["valid"] is False - # 前提②：语法族**确实**报出了违规（否则这条钉子就是空转 —— 挡了个不存在的东西）。 + # 前提②：语法族**确实**报出了违规（否则这条用例就是空转 —— 验了个不存在的东西）。 essay_violations = collect_violations(verdict_essay) assert any(v["rule"] == "artikel" for v in essay_violations), ( f"冠词格错必须被语法族捕获（夹具失效？实际={essay_violations}）" ) - # 钉子：闸门**此刻故意**把非书信体的全部违规掐掉（含语法族）—— 语法族只对书信体生效。 - assert _a1_violations_if_letter(verdict_essay) == [] + counted = violations_for("prose", verdict_essay) + assert any(v["rule"] == "artikel" for v in counted), "非书信体的语法违规 MUST 被计数（闸门收窄）" + assert all(not v["rule"].startswith("a1_") for v in counted), "格式/字数族 MUST 只对书信体生效" + + +def test_a1_violations_gate_letter_counts_format_and_grammar(nlp): + """闸门对照：书信体 ⇒ 格式/字数族 + 语法族**全计**（收窄不误伤书信体）。""" + letter = "Liebe Maria,\nich habe ein Hund.\nViele Grüße,\nAnna" + verdict = analyze_a1_email(letter, nlp=nlp) + assert verdict["greeting"]["valid"] is True + + rules = [v["rule"] for v in violations_for("letter", verdict)] + assert "a1_valediction_comma" in rules, "书信体的格式错 MUST 照旧计数" + assert "artikel" in rules, "书信体的语法错 MUST 照旧计数" def test_ai_polish_endpoint_keeps_non_letter_polish(monkeypatch): diff --git a/tests/test_server.py b/tests/test_server.py index 7934d8f8..4316e37e 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -6640,23 +6640,48 @@ def test_ai_polish_no_key_reports_endpoint_level_reason(client, monkeypatch): ) -def test_ai_polish_non_letter_text_is_not_rolled_back(client, monkeypatch): - """★ 产品回归闸门：非书信体不得被回退成原文。 +def test_ai_polish_non_letter_grammar_error_is_counted_by_the_loop(client, monkeypatch): + """★ Task 7 闸门收窄（**三态死绿守卫的改写其一**）：非书信体 + 语法错 ⇒ 语法违规**真被计数**。 - 裁判集只有 A1 书信规则（`analyze_a1_email`）；对普通作文它必然报 - `a1_greeting_missing` ⇒ 不挂适用性闸门的话 v_0=1、v_1>=v_0 ⇒ 回退原文 - ⇒ 用户点了润色却拿回原文，功能报废。 + 场景：桩模型改了措辞但**不修**冠词错（`ein Hund` 原样保留）⇒ v_0 == v_1 == 1 ⇒ + `no_improvement`（语法违规进了 v 才会发生）。 + + 判别力（变异自证②）：把闸门改回"非书信体一律零违规" ⇒ v_0 == v_1 == 0 ⇒ 首轮即收敛 + ⇒ 本用例 MUST 红 —— 旧闸门下的行为就是"零违规"，本用例的存在即"真被计数"与它的对比。 """ + nlp = _real_nlp_or_skip() _stub_api_key(monkeypatch) - polished = "Ich habe einen Hund. Er ist gut und sehr lieb." - chat = _ScriptedChat([{"corrected_text": polished, "notes_zh": ["用词更地道"]}]) + chat = _ScriptedChat([{"corrected_text": "Ich habe ein Hund. Er ist sehr lieb.", "notes_zh": ["x"]}]) monkeypatch.setattr("delector.routes.main.llm_client.chat", chat) + monkeypatch.setattr("delector.nlp_engine.processor.get_loaded_nlp", lambda: nlp) result = client.post("/api/writing/ai-polish/diff", json={"text": _ESSAY_TEXT}).json()["result"] - assert result["corrected"] == polished, "裁判对非书信体无话可说 ⇒ 首轮即接受，不得回退原文" - assert result["converged"] is True - assert result["unconverged_reason"] is None + assert result["converged"] is False, "非书信体的语法违规 MUST 被计数（否则修不动也会被判收敛）" + assert result["unconverged_reason"] == "no_improvement" + assert result["judge_degraded"] is False + + +def test_ai_polish_non_letter_unfixable_falls_back_to_original(client, monkeypatch): + """★ 产品语义钉子（**三态死绿守卫的改写其二**；ADR §10.3 的落点，MUST 有断言）： + 非书信体语法错**修不动** ⇒ 回退**原文**（**不是**"首轮即接受"）。 + + 这是闸门收窄后的**明知而接受**的行为（2026-10-15 用户拍板；同款登记在 + `violations_for` 与 `_make_judge` 的 docstring）：循环按 Task 4 钉死的 + `no_improvement` 语义走 argmin ⇒ 原文；用户拿到的人话是前端 + `POLISH_REASON_COPY.no_improvement`（"AI 改了几轮仍没能减少硬性错误，已保留更接近原文的一版。"）。 + """ + nlp = _real_nlp_or_skip() + _stub_api_key(monkeypatch) + chat = _ScriptedChat([{"corrected_text": "Ich habe ein Hund. Er ist sehr lieb.", "notes_zh": ["x"]}]) + monkeypatch.setattr("delector.routes.main.llm_client.chat", chat) + monkeypatch.setattr("delector.nlp_engine.processor.get_loaded_nlp", lambda: nlp) + + result = client.post("/api/writing/ai-polish", json={"text": _ESSAY_TEXT}).json()["result"] + + assert result["corrected_text"] == _ESSAY_TEXT, "修不动 ⇒ 按循环语义回退原文（不是首轮即接受）" + assert result["converged"] is False + assert result["unconverged_reason"] == "no_improvement" def test_ai_polish_letter_text_still_judged_by_a1_rules(client, monkeypatch): @@ -6739,6 +6764,138 @@ def test_ai_polish_endpoint_reports_degraded_when_no_nlp(client, monkeypatch): assert result["converged"] is True +def test_ai_polish_endpoint_surfaces_advisories_without_blocking_convergence(client, monkeypatch): + """★ Task 6 HITL 收尾（B 维 advisory 可见性）：`judge_advisories` MUST 到达响应体， + 且 advisory **不阻断收敛** —— 判定与「去掉该句」逐字段相同。 + + 判别力（变异自证①）：把 advisory 的 level 改成 error ⇒ 它翻进 error 计数 ⇒ + v_0 == v_1 == 1 ⇒ no_improvement ⇒ 本用例的 `converged is True` 与 + `unconverged_reason is None` 断言 MUST 红。 + """ + nlp = _real_nlp_or_skip() + _stub_api_key(monkeypatch) + text_with = "Gestern gehe ich zur Schule." + text_without = "Ich gehe zur Schule." + + # 桩模型「不修任何东西」：候选 = 原文 ⇒ 本用例只观察判定不受 advisory 影响。 + chat_with = _ScriptedChat([{"corrected_text": text_with, "notes_zh": []}]) + monkeypatch.setattr("delector.routes.main.llm_client.chat", chat_with) + monkeypatch.setattr("delector.nlp_engine.processor.get_loaded_nlp", lambda: nlp) + res_with = client.post("/api/writing/ai-polish", json={"text": text_with}).json()["result"] + + chat_without = _ScriptedChat([{"corrected_text": text_without, "notes_zh": []}]) + monkeypatch.setattr("delector.routes.main.llm_client.chat", chat_without) + res_without = client.post("/api/writing/ai-polish", json={"text": text_without}).json()["result"] + + assert res_with["judge_advisories"], "B 维 advisory MUST 到达响应体（否则 warning 是 no-op）" + assert all(isinstance(a, str) for a in res_with["judge_advisories"]) + assert any("过去" in a for a in res_with["judge_advisories"]), ( + f"advisory 文案应解释时间锚与时态冲突: {res_with['judge_advisories']}" + ) + assert res_without["judge_advisories"] == [], "对照组不得有 advisory（防断言恒真）" + assert res_with["converged"] is True and res_with["unconverged_reason"] is None + assert res_with["judge_degraded"] is False + # 「与去掉该句逐字相同」：advisory 不得进 error 计数、不得改变停止策略。 + assert (res_with["error_count"], res_with["converged"], res_with["unconverged_reason"]) == ( + res_without["error_count"], + res_without["converged"], + res_without["unconverged_reason"], + ), "advisory 影响了判定（警告被当成错误计数？）" + + +def test_ai_polish_response_carries_judge_advisories_contract(client, monkeypatch): + """响应契约（只增不改）：无 Key 路径也要带 `judge_advisories: []`（前端消费不炸）。""" + monkeypatch.setattr("delector.routes.main.get_effective_api_key", lambda *a, **k: "") + + result = client.post("/api/writing/ai-polish", json={"text": "Hallo."}).json()["result"] + + assert result["judge_advisories"] == [] + assert result["judge_degraded"] is True + + +# ── Task 7：文本族感知的提示词参数化（立论冲突解法 b；业务知识住产品层）────────── + + +def test_pick_system_prompt_letter_vs_prose(): + """提示词选择：书信体 ⇒ 既有 A1 提示词**逐字**；散文 ⇒ 不含称呼语/结语指令。 + + 为什么散文版必须去书信指令（评审黄卡 #2）：内核里逐字 A1 书信指令对非书信体会 + **诱导模型加一个称呼语**，而格式族规则此时已被闸门关掉 ⇒ 污染无守卫。 + """ + from delector.routes.main import POLISH_PROSE_SYSTEM_PROMPT, pick_system_prompt + + letter_prompt = pick_system_prompt("letter") + prose_prompt = pick_system_prompt("prose") + + assert letter_prompt == polish_loop.POLISH_LOOP_SYSTEM_PROMPT, "书信体 MUST 用既有 A1 提示词（逐字）" + assert prose_prompt == POLISH_PROSE_SYSTEM_PROMPT, "散文体 MUST 用散文向提示词（产品层常量）" + assert prose_prompt != letter_prompt + assert "称呼语" not in prose_prompt and "结语" not in prose_prompt, "散文提示词不得含称呼语/结语指令" + assert "逐句润色" in prose_prompt and "保持句子的结构与出现顺序" in prose_prompt, "diff 关键约束 MUST 保留" + assert "corrected_text" in prose_prompt, "JSON 契约 MUST 保留（循环按它解析）" + + +def test_run_polish_passes_text_family_aware_system_prompt(monkeypatch): + """装配点：`_run_polish` MUST 按文本族把系统提示词**真的送进循环**（否则参数化是死代码）。 + + 判别力（变异自证③）：`pick_system_prompt` 恒返回 A1 提示词 ⇒ 本用例第一条断言（散文 + 提示词）MUST 红。 + """ + from delector.routes.main import POLISH_PROSE_SYSTEM_PROMPT, _run_polish + + captured: List[Dict[str, Any]] = [] + + async def _fake_loop(**kwargs: Any) -> Any: + captured.append(kwargs) + return polish_loop.LoopResult(text=kwargs["text"], converged=True, reason="ok", rounds=0, violations=[]) + + monkeypatch.setattr("delector.services.polish_loop.run_polish_loop", _fake_loop) + monkeypatch.setattr("delector.routes.main.get_effective_api_base_url", lambda: "http://stub") + monkeypatch.setattr("delector.nlp_engine.processor.get_loaded_nlp", lambda: None) + monkeypatch.setattr("delector.nlp_engine.processor.try_load_nlp_no_download", lambda: None) + + essay = "Ich habe ein Hund. Er ist gut." + letter = "Liebe Maria,\nich lade dich ein.\nViele Grüße\nAnna" + asyncio.run(_run_polish(essay, "sk-stub")) + asyncio.run(_run_polish(letter, "sk-stub")) + + assert captured[0]["system_prompt"] == POLISH_PROSE_SYSTEM_PROMPT, ( + "非书信体 ⇒ 散文提示词 MUST 真送进循环（参数化不许是死代码）" + ) + assert captured[1]["system_prompt"] == polish_loop.POLISH_LOOP_SYSTEM_PROMPT, "书信体 ⇒ 既有 A1 提示词" + + +def test_writer_js_surfaces_degraded_hint_and_advisories_without_toast(): + """前端生产者（评审黄卡的闭环）：`judge_degraded` / `judge_advisories` MUST 被 + writer.js 消费，且走 **overlay notes 区的非阻断呈现**（Global Constraints 明说 + "不是 error toast"）。 + + 与 `test_frontend_polish_reason_copy_covers_every_reason_code` 同为源码级守卫： + 后端加了字段而前端不渲染 ⇒ 字段等于没加（这正是评审黄卡点名的"无生产者"）。 + + no-key 抑制（评审黄卡 Y3 的闭环）：no-key 路径**循环根本没跑**（`_no_key_outcome` + 什么都没检查）⇒ 降级提示里"本次仅做格式/字数检查"不实 ⇒ `unconverged_reason == + "no_api_key"` 时 MUST 抑制该提示（no-key 已有自己的 toast / notes 文案，抑制不丢信息）。 + """ + src = open(os.path.join(ROOT, "static", "js", "writer.js"), encoding="utf-8").read() + assert "judge_advisories" in src, "writer.js MUST 消费 judge_advisories（advisory 可见性）" + assert "judge_degraded" in src, "writer.js MUST 消费 judge_degraded（降级可见性）" + + render_block = src[src.index("export function renderPolishReview") : src.index("// ── AI 润色：未收敛原因码")] + assert "polishState.judge_advisories" in render_block, "advisory MUST 在 renderPolishReview 里逐条呈现" + assert "polishState.judge_degraded" in render_block, "降级提示 MUST 在 renderPolishReview 里呈现" + assert "语法检查未启用" in render_block, "降级提示 MUST 是一句可见的人话（非阻断，不是 toast）" + assert ( + "polishState.judge_degraded && polishState.unconverged_reason !== 'no_api_key'" in render_block + ), "no-key 路径循环根本没跑 ⇒ 提示 MUST 受 unconverged_reason 守卫（否则'仅做格式/字数检查'不实）" + + # 生产侧（抑制条件的输入）：响应装配 MUST 把 unconverged_reason 存进 polishState + assign = src[src.index("const { original, corrected, hunks, notes_zh"):] + assert "unconverged_reason" in assign[: assign.index("};")], ( + "polishState MUST 携带 unconverged_reason（no-key 抑制分支的输入）" + ) + + def test_get_loaded_nlp_is_read_only(monkeypatch): """`get_loaded_nlp()` 只读已加载模型：未解析/加载失败 ⇒ None，且**绝不触发加载**。""" from delector.nlp_engine import processor diff --git a/tests/test_writing_rules.py b/tests/test_writing_rules.py index 7feac379..8653e71b 100644 --- a/tests/test_writing_rules.py +++ b/tests/test_writing_rules.py @@ -974,3 +974,74 @@ def test_common_correct_sentences_grammar_gate(nlp): assert diag["judge_engine"] == "rules+spacy", f"语法族未跑（门空转）: {s}" got = [v for v in collect_violations(diag) if not v["rule"].startswith("a1_")] assert got == [], f"合法句被语法族误报: {s} -> {got}" + + +# ── Task 6 HITL 收尾（B 维）：过去时间锚 × 时态一致性 = advisory（warning）────────── +# 移植自 `tools/bench_judge_fp.py` 的 B 维探测（该脚本是冻结的标定记录，勿改）。 +# HITL 裁决（用户 2026-10-15）：接线为 `level="warning"`（正样本 FP 0/35、负样本 7/7、 +# 对照 0/6 两档阈值均成立，但样本偏小 ⇒ 先 advisory，不阻断收敛）。 + + +def _tempus(text, nlp): + from delector.services.writing import detect_past_anchor_tense_conflict + + return _sent_spans(text, nlp, detect_past_anchor_tense_conflict) + + +def test_tempus_past_anchor_conflict_is_warning_span(nlp): + """负样本：过去时间锚 + 现在时限定动词 MUST 报 1 条，且是 **warning** 级（advisory）。""" + spans = _tempus("Gestern gehe ich zur Schule.", nlp) + assert len(spans) == 1 + sp = spans[0] + assert set(sp.keys()) == {"severity", "error_type", "corrected_form", "explanation_zh", "start", "end"} + assert sp["severity"] == "warning", "B 维是 advisory：severity 必须是 warning（HITL 裁决）" + assert sp["error_type"] == "tempus" + assert (sp["start"], sp["end"]) == (8, 12), "span 应指向出错的定式动词 gehe" + assert "Gestern" in sp["explanation_zh"] + assert "过去" in sp["explanation_zh"] + + +def test_tempus_correct_past_sentences_clean(nlp): + """正/边界样本：Präteritum / Perfekt / 未来现在时 MUST 零误报（与 bench 对照 0/6 同口径）。""" + for text in [ + "Gestern ging ich zur Schule.", + "Gestern habe ich eine Suppe gekocht.", + "Letzte Woche bin ich nach Berlin gefahren.", + "Gestern kaufte ich ein Buch im Supermarkt.", + "Damals wohnte ich in Hamburg.", + "Morgen fahre ich nach Berlin.", + ]: + assert _tempus(text, nlp) == [], f"正确句被误报: {text}" + + +def test_tempus_no_false_advisory_on_known_good_texts(nlp): + """FP 守卫（正样本零误报，D3 硬门同口径）：官方 10 篇 + 51 句硬门清单 MUST 零 advisory。""" + from delector.data import a1_writing_dict + from delector.services.writing import analyze_a1_email + + for ex in a1_writing_dict.A1_SCHREIBEN_TEIL2: + advs = analyze_a1_email(ex["sample_email"], nlp=nlp)["advisories"] + assert advs == [], f"官方范文被报 advisory（误报）: {ex['id']} -> {advs}" + for s in COMMON_CORRECT_SENTENCES: + advs = analyze_a1_email(s, nlp=nlp)["advisories"] + assert advs == [], f"合法句被报 advisory（误报）: {s} -> {advs}" + + +def test_tempus_advisory_wired_but_not_counted_as_error(nlp): + """接线缝：advisory 进并列键 `advisories`（统一形状、level=warning），**不进 error 计数**。 + + 判别力（变异自证①）：把 tempus 的 severity 改成 error ⇒ 路由翻进 `violations` ⇒ + `collect_violations` 非空 ⇒ 本用例 `== []` 断言 MUST 红。 + """ + from delector.services.writing import analyze_a1_email, collect_violations + + letter = "Liebe Maria,\ngestern gehe ich zur Schule.\nViele Grüße\nAnna" + diag = analyze_a1_email(letter, nlp=nlp) + assert diag["judge_engine"] == "rules+spacy" + tempus = [a for a in diag["advisories"] if a["rule"] == "tempus"] + assert len(tempus) == 1 + assert tempus[0]["level"] == "warning" + assert set(tempus[0].keys()) == {"rule", "level", "message", "span"} + assert tempus[0]["span"] == (21, 25), "advisory 的 span 与 detect_* 同口径（指向 gehe）" + assert collect_violations(diag) == [], "advisory 不得进 error 计数（否则阻断收敛）" + assert all(v["rule"] != "tempus" for v in diag["violations"]), "advisory 只住 advisories 键" From a5a7c1eb4b888fbbaaaa87f6277edb96cca61ee6 Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 21:42:14 +0800 Subject: [PATCH 12/13] =?UTF-8?q?docs(plan+workmemory):=20=C2=A74.3=20?= =?UTF-8?q?=E8=A7=A3=E9=99=A4=E5=88=A4=E6=8D=AE=E8=A1=A8=EF=BC=888=20?= =?UTF-8?q?=E6=9D=A1=E5=AE=9E=E6=B5=8B=EF=BC=89+=20=E5=8B=BE=E9=80=89=20Ta?= =?UTF-8?q?sk=203~8=20=E6=AD=A5=E9=AA=A4=20+=20=E6=9C=AC=E6=89=B9=E4=BA=A4?= =?UTF-8?q?=E6=8E=A5=E4=BA=8B=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- WORKMEMORY/work.log | 10 +++ docs/plans/2026-10-15-a1-judge-expansion.md | 79 +++++++++++++-------- 2 files changed, 58 insertions(+), 31 deletions(-) diff --git a/WORKMEMORY/work.log b/WORKMEMORY/work.log index f8db8f7c..7a356264 100644 --- a/WORKMEMORY/work.log +++ b/WORKMEMORY/work.log @@ -536,3 +536,13 @@ Caps: filesystem-read, filesystem-write, shell-exec - **A 维（情态动词框架语序）不做**：实测负样本 6/7（「实词夹在情态动词与末位动词之间」整族不可见 = 结构性 FN），且样本外追补的 3 句**正确**句（逗号并列主句）全部误报 ⇒ FP 与 FN 同源、两侧都破。标定产物（`tools/bench_judge_fp.py`）保留作记录、不接线。**Why 这条要记**：本计划第一个"测了之后选择不做"的维度 —— 防止后来者看到 bench 脚本以为它只是"还没接线"。 - **B 维（时间副词 ↔ 时态一致性）接线为 warning**：正样本 FP 0/35、负样本 7/7、对照 0/6，两档阈值均成立；样本偏小（7 错 + 6 对照）⇒ 先 advisory 不阻断收敛，积累真实用法后再议升 error。可见性靠响应体新增 `judge_advisories`（只增不改）+ Task 7 的前端渲染。 - 更正一条**未实测口径**：提交 `39e6d79` 的消息里写「COMMON_CORRECT_SENTENCES 47 句」是我未实测的转述，**实测为 51 句** —— 以实测为准（本事件与 PR 正文为准）。 + +### 2026-10-15 18:20 | codebuddy | NOTE +Caps: filesystem-read, filesystem-write, shell-exec +事件：**A1 裁判集扩充计划（`docs/plans/2026-10-15-a1-judge-expansion.md`，8 任务）技术面全部落地，台账 8/8**（分支 `feat/a1-judge-expansion`，待开 PR）。 +- **交付面**：`88856ab` Task 1+2（违规形状统一 + 接线既有两件算力 + 端点注入缝 + 官方范文零违规门）· `39e6d79` Task 3/4/5（`numerus` / `rektion`+29 条人工词表 / `wortstellung` + 加宽后的 51 句永久硬门）· `209cc24` Task 6（FP 标定工具，冻结记录）· `cf9ea76` Task 6 收尾 + Task 7（B 维 warning/advisory + 闸门按规则族分流 + 提示词参数化 + 前端非阻断提示）· `deede44` Task 8（dispatch 超时 / 同步裁判移出事件循环 / 修不可达 except）。 +- **HITL 裁决（用户）**：A 维（情态框架语序）**不做** —— 实测负样本 6/7 + 样本外 3 句正确句全误报 ⇒ FP/FN 同源；B 维（时态一致性）**接线为 warning** —— 正样本 FP 0/35、负样本 7/7、对照 0/6。 +- **本计划最有价值的产出不是规则，而是三次"误报类"返工**：① `öffnen/bezahlen/schmecken` 被当严格 Acc ⇒ 合法自由第三格被报；② V2 把**主语 NP 内修饰**（`Meine sehr große Familie…`）当独立前置成分；③ V2 漏豁免**焦点小词**（`Auch…`/`Nur…`）+ rektion 把自由第三格当违规。三次都**先写成用例跑红再修**，并把硬门从"官方 10 篇"扩到 **51 句 + 类覆盖清单**（编排者另做 30 句广度扫雷 FP=0 后定稿）。**Why 要记**：官方范文门放过了这三类 —— "正样本不够宽"本身就是一类系统性风险。 +- **判据面**：§4.3 解除判据表已入计划（8 条判据：维度覆盖**部分满足**、官方范文零误报 ✅、51 句硬门 ✅、30 句扫雷 ✅、负样本召回 ✅、非书信可判 ✅、降级可见性 ✅、**"浅裁判是否被模型针对"的对照实验未做**（阻塞于 `DEEPSEEK_API_KEY`）⇒ 建议**只允许限定表述**，不建议解禁 §4.3 原文所禁的无条件"已实现"）。 +- **基础设施坑（本会话共 5 次子代理中断：10003×2 / 10006×3 / 10101）**：Task 8 首次留半成品 + 挂死用例（备份后丢弃重派）；Task 6 前两次零落盘；最后一次死在报告前但改动已落盘 ⇒ 由我逐条核到行号并复跑门禁后代提交。**两条实操教训**：⑴ 给 maker 的 prompt MUST 写反挂死纪律（所有 sleep 要有 wait_for/固定次数兜底、禁 join 线程、禁无界 while、每条用例贴实测耗时）；⑵ 提交信息**禁用 `python -c "...'''...'''"` 形式**（反引号会被 bash 当命令替换吞掉正文 —— Task 6 那次就丢了正文，已用 heredoc 重建并在消息尾部注明）。 +- **未做**：Android 真机点检（含新 API 的 WebView 表现）、有 Key 后的真实轮次分布与真 token 计数回测、Pi 式分层重构（用户已拍板暂缓，登记在 `docs/agents/architecture.md`）。 diff --git a/docs/plans/2026-10-15-a1-judge-expansion.md b/docs/plans/2026-10-15-a1-judge-expansion.md index 58565101..13e42696 100644 --- a/docs/plans/2026-10-15-a1-judge-expansion.md +++ b/docs/plans/2026-10-15-a1-judge-expansion.md @@ -125,11 +125,11 @@ > "新增主谓一致规则 `detect_subject_verb_agreement(tokens, base)`，返回与 `detect_determiner_noun_agreement` **完全同形状**的 span 列表。判据：主语 `dep=="sb"` 的 `Number` 与定式动词的 `Number` 不一致即报错（实测锚点：`Die Kinder spielt im Garten.` ⇒ `Kinder`=Plur / `spielt`=Sing ⇒ MUST 报 1 条；`Die Kinder spielen im Garten.` ⇒ MUST 报 0 条）。**FP 守卫必须先写**：① 主语含并列（`Anna und Tom`）/② 主语是集合名词（`die Familie`）/③ 主语为 `man`、不定代词 /④ 复合时态（`hat ... gemacht`，`Number` 落在助动词上）⇒ 一律**不报**（宁漏不误）。每条 FP 守卫都要有用例。RUN：`python -m pytest tests/test_writing_rules.py -q`。⚠️ 若实测发现 spaCy 的 `Number` 在常见结构上不可靠（如 `es gibt`），**不要硬做** —— 停手报告，把该维度降级登记。" **Step Breakdown:** -- [ ] Step 1: 写失败测试（RED：负样本报 1 条 + 4 条 FP 守卫各不报） -- [ ] Step 2: 跑并记录预期失败原文 -- [ ] Step 3: 实现（GREEN） -- [ ] Step 4: 变异自证（抽掉 FP 守卫 ⇒ 对应用例红） -- [ ] Step 5: 官方范文零违规门仍绿 + 原子提交 +- [x] Step 1: 写失败测试（RED：负样本报 1 条 + 4 条 FP 守卫各不报） +- [x] Step 2: 跑并记录预期失败原文 +- [x] Step 3: 实现（GREEN） +- [x] Step 4: 变异自证（抽掉 FP 守卫 ⇒ 对应用例红） +- [x] Step 5: 官方范文零违规门仍绿 + 原子提交 --- @@ -152,11 +152,11 @@ > "新增动词支配格规则。① 建 `delector/data/a1_verb_case.py`，内容 = **人工登记**的 A1 高频动词→支配格映射（如 `helfen: Dat`、`danken: Dat`、`sehen: Acc`、`es gibt: Acc`…），条目数**先只收你能逐条确认的**，每个条目带一行来源注释；**禁止**用 LLM 批量生成（这是事实数据，不是文本生成）。② `detect_verb_case_government(tokens, base)`：找动词（`VERB`/`AUX`）→ 查表 → 取其宾语 NP 的 `morph.Case` 与之比对，不一致则用 `decline_determiner` 生成 `corrected_form` 并报 error（实测锚点：`Ich helfe meinen Bruder.` MUST 报 1 条；`Ich helfe meinem Bruder.` MUST 报 0）。③ FP 守卫：动词不在表内 / 反身动词 / 可分前缀动词 / 名词化动词 ⇒ 不报。④ 数据自检测试（键 ⊆ A1 lemma、值集合合法）。RUN：`python -m pytest tests/test_writing_rules.py tests/test_a1_verb_case_data.py -q`。**官方 10 篇范文零违规门（Task 2 起）必须仍绿。**" **Step Breakdown:** -- [ ] Step 1: 写失败测试（RED：负样本报 1 条 + 正样本 0 条 + 数据自检 + FP 守卫） -- [ ] Step 2: 跑并记录预期失败原文 -- [ ] Step 3: 数据 + 规则实现（GREEN） -- [ ] Step 4: 变异自证 + 官方范文零违规门复核 -- [ ] Step 5: 原子提交 +- [x] Step 1: 写失败测试（RED：负样本报 1 条 + 正样本 0 条 + 数据自检 + FP 守卫） +- [x] Step 2: 跑并记录预期失败原文 +- [x] Step 3: 数据 + 规则实现（GREEN） +- [x] Step 4: 变异自证 + 官方范文零违规门复核 +- [x] Step 5: 原子提交 --- @@ -176,11 +176,11 @@ > "新增主句动词位置规则（德语 V2）。实测信号：主句定式动词 MUST 落在第二位置；`Gestern habe ich gearbeitet.`（`habe` index 1）正确，`Gestern ich habe gearbeitet.`（`habe` index 2）错误。实现 `detect_verb_second_position(tokens, base)`，返回既有 span 形状。**豁免面逐条写用例**（从句 / 疑问句 / 祈使句 / 并列句 / 直接引语 / 标题式片段）—— 这些结构里 V2 不成立，漏一条豁免就会在真实文本上大批误报。区分主句/从句优先用 `dep`（`ROOT` vs `cs`/`mo` 等）而不是标点启发。RUN：`python -m pytest tests/test_writing_rules.py -q`。" **Step Breakdown:** -- [ ] Step 1: 写失败测试（RED：错句报 1 条 + 正句 0 条 + 6 条豁免各 0 条） -- [ ] Step 2: 跑并记录预期失败原文 -- [ ] Step 3: 实现（GREEN） -- [ ] Step 4: 变异自证（抽掉任一条豁免 ⇒ 对应用例红）+ 官方范文零违规门复核 -- [ ] Step 5: 原子提交 +- [x] Step 1: 写失败测试（RED：错句报 1 条 + 正句 0 条 + 6 条豁免各 0 条） +- [x] Step 2: 跑并记录预期失败原文 +- [x] Step 3: 实现（GREEN） +- [x] Step 4: 变异自证（抽掉任一条豁免 ⇒ 对应用例红）+ 官方范文零违规门复核 +- [x] Step 5: 原子提交 --- @@ -205,11 +205,11 @@ - **advisory 的可见性**（编排者定的最小实现）：warning 必须真能被看到，否则是 no-op ⇒ 响应体 `result` 追加 `judge_advisories: list[str]`（**只增不改**），前端渲染与本计划的 Task 7 同批。 **Step Breakdown:** -- [ ] Step 1: 建正/负样本集（负样本每维 ≥5 句，逐句标注期望） -- [ ] Step 2: 写探测实现 + 脚本（含脚本自身测试） -- [ ] Step 3: 跑出原始计数表与误报样例 -- [ ] Step 4: **HITL**：把结论（做 error / warning / 不做）交用户拍板 -- [ ] Step 5: 按拍板结论决定是否接线（若接线 ⇒ 走 Task 2~5 同款门禁：正样本零违规 + FP 守卫 + 变异自证）+ 原子提交 +- [x] Step 1: 建正/负样本集（负样本每维 ≥5 句，逐句标注期望） +- [x] Step 2: 写探测实现 + 脚本（含脚本自身测试） +- [x] Step 3: 跑出原始计数表与误报样例 +- [x] Step 4: **HITL**：把结论（做 error / warning / 不做）交用户拍板 +- [x] Step 5: 按拍板结论决定是否接线（若接线 ⇒ 走 Task 2~5 同款门禁：正样本零违规 + FP 守卫 + 变异自证）+ 原子提交 --- @@ -234,12 +234,29 @@ > "收窄适用性闸门的范围。现状：`_a1_violations_if_letter` 因当时裁判只有书信格式规则而做成「称呼语不合法 ⇒ 零违规」；语法维度接线后**前提变了** —— 语法与题材无关。改法：闸门改按**规则族**分流 —— ① 格式/字数族（`a1_greeting_*` / `a1_valediction_*` / `a1_word_count`）仍仅对书信体生效；② 语法族（冠词-格一致 / 介词支配格 / 动词支配格 / 主谓一致 / V2）对**任意德语文本**生效。测试 MUST 覆盖：非书信体文本带语法错误 ⇒ **真被计数**（与今日"零违规"对比，这是行为变更）；书信体文本的格式规则语义不变。③ 同时在本计划文件里落一张 **§4.3 解除判据表**（维度数 / 官方正样本零误报 / 负样本 recall / 非书信文本可判 / 降级标记可见性 各条 + 实测值），**满足与否由用户拍板**，agent 不自行解禁。RUN：`python -m pytest tests/test_goethe_a1_writing.py tests/test_server.py tests/test_ai_polish_loop.py -q` + 全量。⚠️ 本任务会改变产品行为（非书信文本从"首轮即接受"变为"真迭代"），执行前 MUST 先跑一遍 `tests/test_server.py::test_ai_polish_diff_mocked` 系用例确认既有断言仍成立。" **Step Breakdown:** -- [ ] Step 1: 写失败测试（RED：非书信体带语法错误 ⇒ 被计数） -- [ ] Step 2: 跑并记录预期失败原文 -- [ ] Step 3: 闸门按规则族分流（GREEN） -- [ ] Step 4: 全量套件 + 契约闸 + §4.3 解除判据表落盘 -- [ ] Step 5: **改写 `tests/test_server.py::test_ai_polish_non_letter_text_is_not_rolled_back`**（评审黄卡③：它在"现状 / 仅接 nlp / 收窄闸门"**三态下都绿** ⇒ 已不守卫任何东西）为能区分行为的两条：① 非书信体 + 语法错（且桩模型不修）⇒ 断言语法违规**真被计数**；② 明确并钉住收窄后的产品语义（该修不动时是回退原文还是首轮即接受）—— 后者正是 ADR §10.3「功能忘了判就是报废」失败模式的重现，MUST 有断言，不许只留在 Fog of War。 -- [ ] Step 6: **HITL**：判据表交用户拍板（是否允许宣称"已实现"）+ 原子提交 +- [x] Step 1: 写失败测试（RED：非书信体带语法错误 ⇒ 被计数） +- [x] Step 2: 跑并记录预期失败原文 +- [x] Step 3: 闸门按规则族分流（GREEN） +- [x] Step 4: 全量套件 + 契约闸 + §4.3 解除判据表落盘 +- [x] Step 5: **改写 `tests/test_server.py::test_ai_polish_non_letter_text_is_not_rolled_back`**（评审黄卡③：它在"现状 / 仅接 nlp / 收窄闸门"**三态下都绿** ⇒ 已不守卫任何东西）为能区分行为的两条：① 非书信体 + 语法错（且桩模型不修）⇒ 断言语法违规**真被计数**；② 明确并钉住收窄后的产品语义（该修不动时是回退原文还是首轮即接受）—— 后者正是 ADR §10.3「功能忘了判就是报废」失败模式的重现，MUST 有断言，不许只留在 Fog of War。 +- [x] Step 6: **HITL**：判据表交用户拍板（是否允许宣称"已实现"）+ 原子提交 + +### §4.3 解除判据表（2026-10-15 实测值；签批归用户） + +| # | 判据 | 口径 | 实测 | 满足 | +| --- | --- | --- | --- | --- | +| 1 | **维度覆盖**（ADR §4.3 点名四项：动词位置 / 时态一致性 / 语序 / 格的使用） | 每项 MUST 有确定性规则且接线 | **动词位置** = `wortstellung`（主句 V2 + 8 豁免）✅ · **格的使用** = `artikel` + `kasus` + `rektion` 三条 ✅ · **时态一致性** = `tempus`（**warning/advisory**，按用户裁决）🟡 · **语序（主谓宾/情态框架）** = **经实测评审判定不做**（负样本 6/7 + 样本外正确句 3/3 误报 ⇒ FP/FN 同源）❌ | **部分**（3 error + 1 advisory + 1 明确不做） | +| 2 | **官方正样本零误报** | 10 篇 `A1_SCHREIBEN_TEIL2.sample_email` 逐句 error 级违规 == 0 | `FP_TOTAL 0`（逐篇全 0） | ✅ | +| 3 | **更宽的合法句硬门** | `COMMON_CORRECT_SENTENCES`（≥51 句，含类覆盖清单）零语法族违规 **且** `judge_engine == "rules+spacy"`（防降级假绿） | **51 句全绿** | ✅ | +| 4 | **编排者独立广度扫雷** | 另取 30 句常见正确德语（焦点小词/自由第三格/前置状语/从句前置/疑问祈使/反身/可分动词…） | **FP = 0** | ✅ | +| 5 | **负样本召回** | 每个已接线维度都有定向错误句用例（且变异自证：抽掉守卫即红） | 三新维度 + 两个既有算力各有负样本用例；变异自证 5 组以上 | ✅ | +| 6 | **非书信文本可判** | 语法族对**任意德语文本**生效（不再要求书信体） | 已落地（闸门按规则族分流：格式族仅书信体、语法族任意文本） | ✅ | +| 7 | **降级可见性**（不许"没检查"伪装成"检查通过"） | `judge_engine`/`judge_degraded` 忠实透出 + 前端非阻断提示 | 已落地（含 no-key 路径抑制不实文案） | ✅ | +| 8 | **"浅裁判失效"对照实验**（奖励黑客的正面证据：模型学会通过检查 vs 真变好） | 需真实模型与 Key | **未做**（阻塞于 `DEEPSEEK_API_KEY` 缺失） | ❌ | + +**判据结论（供签批）**：第 1 项**部分**满足、第 8 项**未做** ⇒ 建议**只允许限定表述**，例如「裁判已扩到 A1 语法维度（动词位置 + 格的使用三规则 error 级、时态一致性 advisory；语序经实测评审判定不做）」，**不建议**解禁 §4.3 原文所禁的那句无条件"已实现"—— 因为第 8 项（浅裁判是否真被模型针对）尚无证据。 + +**已知边界（随判据表一并登记）**：① 书信缺称呼语 ⇒ 判据 `greeting.valid` 归 prose ⇒ 格式族（含 `a1_greeting_missing`）**永远不被计数**（继承自旧闸门）；② 候选侧 kind 逐候选翻转（旧欠账，未收口）；③ 非书信文本模型修不动 ⇒ `no_improvement` ⇒ **回退原文**（有断言 + 三处 docstring，前端给人话原因码）；④ advisory 在 argmin 回退路径下可能与出口文本不对应（不进任何计数）；⑤ warning 级条目按族分居 `violations`（格式族）/ `advisories`（语法族），取全集需并集两键。 --- @@ -260,11 +277,11 @@ > "补三处接缝。① `polish_loop.py` 的 `dispatch`（:412）目前**无超时**：包 `asyncio.wait_for`，超时按 errors-as-messages 返回工具失败消息（不炸循环）；② 同步裁判 `judge`（:330/:439）直接跑在事件循环上 ⇒ 移 `asyncio.to_thread`，使 (a) `task.cancel()` 真能掐断、(b) 长裁判不阻塞 `/api/health` 与其他路由；用例钉住"取消时裁判线程不再被等待"/"裁判期间 health 仍可应答"（后者可用事件循环探针）。③ 修 `main.py` 的**不可达分支**：`_run_polish`（:2342-2344）已把 `LLMError` 转成 `HTTPException(502)`，而 `_polish_event_stream`（:2439-2442）写的是 `except llm_client.LLMError` ⇒ 该分支永不命中、流内 error 帧永不发出、用户拿到通用文案而非 `e.detail` 人话。断言：注入的 chat 在流中途抛 LLMError ⇒ 用户**看得到** `e.detail`（走 error 帧或明确的状态码，二选一并在注释写明为什么）。RUN：`python -m pytest tests/test_ai_polish_loop.py tests/test_server.py -q` + 全量。" **Step Breakdown:** -- [ ] Step 1: 写失败测试（RED：dispatch 无超时 / 同步裁判阻塞事件循环 / error 帧不可达） -- [ ] Step 2: 跑并记录预期失败原文 -- [ ] Step 3: 三处实现（GREEN） -- [ ] Step 4: 变异自证（抽掉 `wait_for` ⇒ 超时用例红；抽掉 `to_thread` ⇒ 阻塞探针红；把 except 改回 LLMError ⇒ error 帧用例红） -- [ ] Step 5: 全量 + ruff + mypy 四档 + 原子提交 +- [x] Step 1: 写失败测试（RED：dispatch 无超时 / 同步裁判阻塞事件循环 / error 帧不可达） +- [x] Step 2: 跑并记录预期失败原文 +- [x] Step 3: 三处实现（GREEN） +- [x] Step 4: 变异自证（抽掉 `wait_for` ⇒ 超时用例红；抽掉 `to_thread` ⇒ 阻塞探针红；把 except 改回 LLMError ⇒ error 帧用例红） +- [x] Step 5: 全量 + ruff + mypy 四档 + 原子提交 --- From 555cd4a1b5730728474847d7100ae3a72697842b Mon Sep 17 00:00:00 2001 From: Haoyu Xi Date: Thu, 15 Oct 2026 21:44:51 +0800 Subject: [PATCH 13/13] =?UTF-8?q?docs(plan+workmemory):=20=C2=A74.3=20?= =?UTF-8?q?=E7=AD=BE=E6=89=B9=E8=90=BD=E6=A1=A3=20=E2=80=94=E2=80=94=20?= =?UTF-8?q?=E9=99=90=E5=AE=9A=E8=A1=A8=E8=BF=B0=EF=BC=88=E6=97=A0=E6=9D=A1?= =?UTF-8?q?=E4=BB=B6=E3=80=8C=E5=B7=B2=E5=AE=9E=E7=8E=B0=E3=80=8D=E7=BB=A7?= =?UTF-8?q?=E7=BB=AD=E7=A6=81=E7=94=A8=EF=BC=89+=20=E5=9B=9E=E9=80=80?= =?UTF-8?q?=E8=AF=AD=E4=B9=89=E4=BF=9D=E6=8C=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- WORKMEMORY/work.log | 7 +++++++ docs/plans/2026-10-15-a1-judge-expansion.md | 4 ++++ 2 files changed, 11 insertions(+) diff --git a/WORKMEMORY/work.log b/WORKMEMORY/work.log index 7a356264..cee1f60f 100644 --- a/WORKMEMORY/work.log +++ b/WORKMEMORY/work.log @@ -546,3 +546,10 @@ Caps: filesystem-read, filesystem-write, shell-exec - **判据面**：§4.3 解除判据表已入计划（8 条判据：维度覆盖**部分满足**、官方范文零误报 ✅、51 句硬门 ✅、30 句扫雷 ✅、负样本召回 ✅、非书信可判 ✅、降级可见性 ✅、**"浅裁判是否被模型针对"的对照实验未做**（阻塞于 `DEEPSEEK_API_KEY`）⇒ 建议**只允许限定表述**，不建议解禁 §4.3 原文所禁的无条件"已实现"）。 - **基础设施坑（本会话共 5 次子代理中断：10003×2 / 10006×3 / 10101）**：Task 8 首次留半成品 + 挂死用例（备份后丢弃重派）；Task 6 前两次零落盘；最后一次死在报告前但改动已落盘 ⇒ 由我逐条核到行号并复跑门禁后代提交。**两条实操教训**：⑴ 给 maker 的 prompt MUST 写反挂死纪律（所有 sleep 要有 wait_for/固定次数兜底、禁 join 线程、禁无界 while、每条用例贴实测耗时）；⑵ 提交信息**禁用 `python -c "...'''...'''"` 形式**（反引号会被 bash 当命令替换吞掉正文 —— Task 6 那次就丢了正文，已用 heredoc 重建并在消息尾部注明）。 - **未做**：Android 真机点检（含新 API 的 WebView 表现）、有 Key 后的真实轮次分布与真 token 计数回测、Pi 式分层重构（用户已拍板暂缓，登记在 `docs/agents/architecture.md`）。 + +### 2026-10-15 19:05 | codebuddy | DECISION +Caps: filesystem-read, filesystem-write, shell-exec +事件：**§4.3 门槛的宣称方式与回退语义由用户签批**（计划 `docs/plans/2026-10-15-a1-judge-expansion.md` 的 §4.3 判据表尾已记）。 +- **宣称方式 = 限定表述**：允许对外写「裁判已扩到 A1 语法维度：动词位置 + 格的使用三规则 error 级、时态一致性 advisory；语序经实测评审判定不做」；**无条件「已实现验证驱动 agent 循环」继续禁用** —— 判据表第 8 条（"浅裁判是否真被模型针对"的对照实验）因缺 `DEEPSEEK_API_KEY` 未做，故 §4.3 的门槛只算**部分抬升**。 +- **回退语义 = 保持**：非书信文本模型修不动 ⇒ `no_improvement` ⇒ argmin 回退**原文**（与循环语义一致，断言 + 三处 docstring + 前端人话原因码已钉住）。 +- **Why 记**：这是"测出来之后**不做**"与"允许**限定**宣称"两个反直觉结论 —— 防止后来者把 §4.3 读成"已经解禁"或把 bench 脚本里的 A 维当成"待接线"。 diff --git a/docs/plans/2026-10-15-a1-judge-expansion.md b/docs/plans/2026-10-15-a1-judge-expansion.md index 13e42696..3602b816 100644 --- a/docs/plans/2026-10-15-a1-judge-expansion.md +++ b/docs/plans/2026-10-15-a1-judge-expansion.md @@ -256,6 +256,10 @@ **判据结论（供签批）**：第 1 项**部分**满足、第 8 项**未做** ⇒ 建议**只允许限定表述**，例如「裁判已扩到 A1 语法维度（动词位置 + 格的使用三规则 error 级、时态一致性 advisory；语序经实测评审判定不做）」，**不建议**解禁 §4.3 原文所禁的那句无条件"已实现"—— 因为第 8 项（浅裁判是否真被模型针对）尚无证据。 +**✅ 用户签批（2026-10-15，Task 7 Step 6 结）**： +1. **采用限定表述** —— 允许对外写「裁判已扩到 A1 语法维度：动词位置 + 格的使用三规则 error 级、时态一致性 advisory；语序经实测评审判定不做」；**无条件「已实现验证驱动 agent 循环」继续禁用**（第 8 条对照实验未做之前不解禁）。 +2. **非书信文本「模型修不动 ⇒ 回退原文」保持**（与循环 argmin 语义一致，已有断言 + 三处 docstring + 前端人话原因码钉住）。 + **已知边界（随判据表一并登记）**：① 书信缺称呼语 ⇒ 判据 `greeting.valid` 归 prose ⇒ 格式族（含 `a1_greeting_missing`）**永远不被计数**（继承自旧闸门）；② 候选侧 kind 逐候选翻转（旧欠账，未收口）；③ 非书信文本模型修不动 ⇒ `no_improvement` ⇒ **回退原文**（有断言 + 三处 docstring，前端给人话原因码）；④ advisory 在 argmin 回退路径下可能与出口文本不对应（不进任何计数）；⑤ warning 级条目按族分居 `violations`（格式族）/ `advisories`（语法族），取全集需并集两键。 ---