# lieflat-less-ai-tone

Adopt this skill: https://proskills.md/skills/other/larashero3-dotcom-lieflat-less-ai-tone

Page: https://proskills.md/skills/other/larashero3-dotcom-lieflat-less-ai-tone
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 27856
sha: 3bdddab7910820df3a4f35a59a6115a084c27af6
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/SKILL.md

````text
---
name: lieflat-less-ai-tone
description: 三层去 AI 味：脚本检测出分级报告（A 机械改/B 建议改/C 只报告/X 已否决/F 指纹）+ 语义层判读（同义重命名/衔接连环/结论冒号/同构三连），先向用户交付专业、可读的改前报告，列出本篇指标、研究显著性、原文例句和具体改法；收到用户回复后按白名单规则改写，复测并生成前后对比报告（默认 Markdown，与文稿同格式）。规则基于两轮实测（629 篇对照 + 270 对同题同事实配对复测）整理。适用于写作完成后的成稿清理。
---

# 去AI味 v2

识别并改写文本中的 AI 写作痕迹。工作顺序是**先检测、用指标与例句讲清发现和改法、等待用户回复、再改写与复测交付**。报告要专业且容易读懂：说明哪些特征在研究语料中显著，本篇实际命中了多少，以及为什么这些位置值得改。模型负责逐条筛选，不把几十个候选和比喻清单交给用户逐项决策。用户回复「按建议改」即可继续，也可以一句话调整范围。规则基于两轮实测：第一轮 629 篇对照语料，第二轮 270 对同题同事实配对复测 + 43 万次语义判断。配对复测推翻了 v1 的三条规则（见「X 级清单」），这部分规则只出现在检测报告里，永不执行。

检测分三层分工：**数得出符号的归脚本**（detect.py 正则/结构指标），**要理解句意的归语义层**（本会话模型按 [references/semantic-criteria.md](./references/semantic-criteria.md) 的封闭判据逐条判断），**机器间共识不够的归人审**（比喻贴切度、暗喻、拟人化喻体——报告里只列人审区，模型不判）。

## 工作流（必须按顺序）

### 第一步：脚本检测

```bash
python3 scripts/detect.py <文件或目录> [--max-hits 5] [--json]
```

拿到分级报告。各级含义和判级依据见 [DETECT.md](./DETECT.md)。**改前这次务必带 `--json` 存档**（第四步对比报告要用）。

### 第 1.5 步：语义层判读（单篇必跑，目录批量可选）

```bash
python3 scripts/detect.py <文件> --candidates --out /tmp/candidates.json
```

对抽出的四类候选（同义重命名段 / 段间衔接接口 / 冒号句 / 三连同构组），按 [references/semantic-criteria.md](./references/semantic-criteria.md) 的判据逐条给出 `label`/`confidence`/`reason`，写回 JSON。判断纪律（43 万次打标的教训）：只按判据判不按整体感觉、每条独立判断不看全文、拿不准选兜底标签、禁止自造标签。

单篇 3000 字约 40-80 条候选，会话内直接判，token 开销可忽略。判完按判据文件末尾的汇总口径算四个数：重命名 次/段、最长连环、结论冒号占比、高度同构三连数。

### 第二步：给用户看检测结果和建议，等待回复

读完脚本报告和语义层四项汇总后，向用户交付一份**专业、可读的改前检测报告**，并在此结束本轮。篇幅随文章和问题数量而定；不能只给一句感想，也不能把原始脚本输出原样贴给用户。报告至少包含：

1. **方法和口径**：说明脚本统计了什么、语义层判读了什么，给出本篇字数、段落数和候选数量。明确区分“研究语料中的统计显著”和“本篇单次命中”；没有做单篇显著性检验就不能宣称本文统计显著，也不能据此断言作者是 AI。
2. **指标结果与命中去向**：用一张紧凑表列出本篇命中的第一层跨模型指标和第二层单模型指纹。能定位到句子的项目写明**原始命中数、有效命中数、拟改数、保留数**，以及本篇密度、研究参照和证据强度；句长 CV、结构方差等整篇分布指标只报实测值与处置，不强造逐句命中数。原始命中为零也可简列。即使未达处理门槛或决定保留，也不得从报告中删掉这一项；不同轮次计数口径不同，不得混算倍数。
3. **例句与改法**：对每个建议处理的指标，摘 1–2 处原句并标位置，解释命中机制、对阅读的具体影响，再给可执行的改法。可给短句示意，但不是正式改稿；此时不得写入或交付改后全文。保留事实、限定词和信息点，不用“改得自然些”这种空泛建议。
4. **排除项与范围**：对每个保留/排除的指标写明数量和理由类别，并至少举一处能定位的例句；标题/清单/引文等正常用途、低优先级命中和指纹项的具体保留理由都在此说明。最后汇总拟修改范围和保留边界，只请用户对**整套建议**回复「按建议改」或提出调整，不逐条索要决定。

**命中清单不可静默删项。** 脚本原始命中与语义候选先完整保存在 JSON；模型复核只能给每条标注“拟改 / 保留 / 误报 / 待核或人审”及理由，不能改写原始计数或把不喜欢的候选移出清单。语义层的“不符合判据”属于有记录的判读结果，也要计入“原始候选 → 有效命中”的差额。若用户提供了文件，保留可追溯的逐条结果文件；主报告用数量和典型例句解释去向，用户无需逐条决策。

**第一、第二层的执行倾向：有效且可定位的命中，默认列为“拟改”。** 研究指标用于筛选值得处理的写法；本篇次数少、密度不高或未达到整篇提示线，只影响报告中的优先级，不能单独成为放过一处有效命中的理由。模型要把“保留”当成需要举证的例外：明确指出该处的修辞、引文、术语、语义关系或作者风格为何不可替换，或说明最小改写仍会损失信息。不能只写“读着自然”“只有一处”“模型未必如此”就保留。若判据尚无法确定，标“待核/人审”并列出原句，不默认为无问题。用户回复前仍只提出建议，不改正文。

写法以指标表配合解释性段落为主。术语可以用，但要解释其含义；数字要有口径和参照，例句要能在原稿定位。目标是让用户清楚看到“检测依据 → 本篇命中 → 原文例子 → 具体改法”，而不是只看到形容词或一串 A/B/C 级别。主报告不贴全部候选、逐项勾选表或全篇比喻清单。

完整案例见 [examples/agent-memory-case/README.md](./examples/agent-memory-case/README.md)：包含改前检测与建议、改后全文、左右两列 HTML 对照和复测结论。

表达方式示例（只示范一个指标段落，完整报告见案例）：

> 脚本在本文找到 2 处“不是 A 而是 B”式对举，密度 0.763 次/千字；第一轮人类参考约 0.22 次/千字，配对复测中 GPT 与 Opus 也同向偏高。第 13 行“不是冰箱的容量，而是……”和第 76 行“不是存更多，而是分清楚”都在段落结论位置。建议把判断直接说出来，同时保留容量与存储量这两个限定，不把反面信息整句删掉。

这份报告是**唯一的改前确认点**。发出后停在检测阶段，**收到用户回复前不得改写文章**。

模型在给出建议前自己复核每条命中，但复核结果必须留痕：A 级的标题、引文等误报标“误报”，不能从原始数中抹掉；A/B 级有效且可安全改写的局部命中默认标“拟改”，保留需给逐处的具体理由；语义层按封闭判据核验（重命名 ≥2 组的段、≥6 连环、结论冒号、高度同构三连 ≥2 组是重点报告门槛），阴性判读也记录。低于整篇门槛但本句确有同类问题，可列低优先级拟改，不能写成本文统计显著；单凭次数少不得排除。判不准则标“待核/人审”并展示，不归零。**C 级句长方差、小节几何等整篇分布指标不可假装成某句的错误；报告实测值，有可定位且不破坏文章结构的改法才建议处理。H 级比喻、暗喻和拟人仍交人审，不让模型假装能判贴切度。**用户主动要求处理 C/H 时按相应约束办理；涉及引文时仍不得改动引文本身。

用户回复「好」「按建议改」「就这样改」等，即按报告中的建议直接进入第三步，不再二次确认。用户提出修改意见时，按其意见调整并进入第三步；如果回复只是提问或明确要求先别改，先回答或暂停，不能把沉默当作同意。用户说「全部改」时，默认指经复核列为拟改的 A+B+语义层+F 局部命中，不包括 X、不可定位的 C 和待人审的 H；用户对 C/H 给出明确要求时按其要求处理。

### 第三步：改写

收到第二步的用户回复后，只改用户接受或调整后的方案纳入的项。改写原则见下。每处改动记录「原文 → 改后 + 命中规则编号」，供第四步复核。

### 第四步：复测 + 前后对比报告

对改写稿重跑 `detect.py`（带 `--json` 存档），然后生成前后对比报告：

```bash
python3 scripts/detect.py 改后.md --json > /tmp/after.json
python3 scripts/report.py 原文.md 改后.md /tmp/before.json /tmp/after.json \
    --semantic /tmp/candidates_labeled.json --out 去AI味报告.md
```

**默认输出 Markdown**（与用户文稿同格式，对照区是改后稿全文、改动处用 `<del>原文</del><ins>新文字</ins>` 标记，其余 md 标记原样保留，整段可直接复制回写作流程）。用户要网页版再加 `--format html`（红绿划线，`open` 浏览器看）。

报告三段式：顶部指标前后对比表（含人类参考列）、中部分级问题清单+语义层判读、底部前后对照。

复测判读：经复核列为拟改的 A/B/语义/F 局部命中，应核对是否完成修改；标题、清单等误报可保留并在报告里说明。F 指纹密度变化给出方向解读，不强迫归零；C 级结构指标（句长CV、同构/百段）变化给出数字但**不追求推到某个目标值**——把句长CV 从 0.37 拉到 0.67 是机械参差化，比不改更糟。

## 改写原则（解决「AI 改写不好」）

这部分是 v2 新增的。模型改写 AI 味的常见失败模式和对策：

**1. 最小改动。** 一处命中只改解决该问题所必需的部分。不顺便润色，不替换没问题的词，不调整语气详略。没有把握时保持原文。改得越多，错得越多——每次额外改动都是一次新的语义风险。

**2. 信息守恒。** 原文的观点、事实、限定词完整保留。姓名、数字、日期、引语、来源、因果，改写后每个实词都要能在原文指出出处。「可能」改「一定」是篡改判断强度，不是去 AI 味。

**3. 不制造参差。** 句长和段长的离散度实测人机无差异（v1 已证，配对复测确认）。不要为了「像人写的」把句子改得忽长忽短、把段落拆碎。节奏问题只在 C 级报告里提示，默认不逐句改。

**4. 结构不动。** 标题层级、章节顺序、段落顺序、列表、表格、引用、代码块的位置原样保留。小标题编号**不改**（配对复测已推翻，见 X 级清单）。

**5. 有风格参考先读参考。** 同目录有风格文档（写作风格指南、`语言DNA.md` 类）时先读它。冲突时以风格文档为准——那是目标作者的真实写法，不是 AI 痕迹。作者本来就爱用破折号，就不按指纹规则删。

**6. 改完自查三件事。**
- 每处改动能否指出对应的方案项和规则编号？指不出就撤销
- 实词是否都有出处？没有就撤销
- 复测后需要处理的 A/B 是否清零、保留的误报是否有说明、C 级指标是否没有大幅摆动？

## 不改的情况

- 文章框架（同上）
- 对话体、口语体：本来就是自然表达
- 问句、设问、问句小标题：正文问句人类远多于 AI，删了更不像人写
- 文学性表达：散文小说的排比比喻按原有风格判断
- 体裁要求：学术新闻公文不必强加「我/你」
- 代码块、外语段落、引文
- **序数词小标题、「这意味着」复述、空转句引列表、概括替代（同段有数据也不改）**：v1/v2 曾列为规则，270 对配对复测方向反转或净零（人类用得更多/两侧对称），永不改。检测报告的 X 区会标出这些，防止误改

---

## 改写规则（按优先级排序）

规则里的实测数字：标注「配对复测」的来自 270 对同题同事实语料（GPT-5.6 135 篇 + Opus 4.6 135 篇 vs 人类 270 篇），其余来自第一轮 629 篇对照。两轮都过的才保留为规则。

### 1. 翻案腔

先立一个读者并没有的误解，再推翻它。「不是……而是……」「并非……而是……」「与其说……不如说……」「表面……实际……」「看似……实则……」「你以为……其实……」「A 不重要，重要的是 B」。清单只是举例，同一动作换任何字面都要改。

实测：第一轮 AI 0.73 / 人类 0.22（3.4×）；配对复测欧化构式 GPT δ+0.88 / Opus δ+0.72，两轮同向，是最强的纯写作信号。

改法：直接正面下判断，先给判断再给依据。

> ❌ 真正的壁垒不是技术，而是认知。
> ✅ 真正的壁垒是认知。

> ❌ 你以为用户在乎功能多少，其实他们只在乎能不能马上用。
> ✅ 用户首先在乎能不能马上用。

### 2. 提示语冒号

冒号前是「一句话总结」「核心是」「关键在于」「原因如下」这类提示语，替作者宣告下面有结论。

实测：第一轮 AI 0.29 / 人类 0.08（3.8×）；配对复测语义层「结论提示冒号」AI 2.1 倍于人类，两轮同向。

改法分两种。提示语不承担信息时删掉直接写；前半句承接上文时保留、只把冒号换成句号或逗号。判断方法：删掉这半句会不会丢信息或断衔接。

> ❌ 一句话总结：这个方案成本太高。
> ✅ 这个方案成本太高。

> ❌ 原因有两个：交付晚了，预算也超了。
> ✅ 交付晚了，预算也超了。

**空转句引列表（「我见过的几种典型场景：」+列表）不改。** 第一轮测出 9.4×，但配对复测方向反转：人类高一个量级，目录式长文里这是正常写法。已列入 X 级。

不改：引出人物原话；小标题里的冒号；列表项内部；「人擅长的是：判断业务逻辑」这类总说分说（人类内部用量差异 6.6 倍，测不出稳定差异）；网址代码。

### 3. 起手式

「说白了」「说穿了」「先说结论」。删掉直接给判断。第一轮 3.2×，量小但稳定。

### 4. 翻译腔（四种）

只处理四种结构。触发标记之外的即使读着生硬也保留——第一轮从 18 种里只筛出 5 种，配对复测又推翻 1 种（「这意味着」），剩这 4 种。

**过长前置定语**（第一轮 0.42/千字，配对复测前置定语长 GPT δ+0.48 / Opus δ+0.54）：中心名词前修饰超十五字，或「的」连续两个以上。拆成两个分句。

> ❌ 一个能够帮助团队在不增加人力的情况下显著提升审核速度的工具
> ✅ 这个工具能显著提升审核速度，不需要增加人力

**「当……时」前置从句**：删「当」和「时」，让从句直接作前一分句。确实需要标示时点、删了时间关系变模糊的不改。

**前置话题壳**：「对于……来说」「就……而言」「在……方面」后面的句子本来就以这个对象为主语时，删壳子。

> ❌ 对于早期团队来说，招人是最难的事。
> ✅ 早期团队最难的事是招人。

**句首连接词当路标**：「然而，」「因此，」「此外，」尤其相邻段落连续这样开头。移到主语后，或换「不过」「其实」。论证确实需要显式路标时不改。

**「这意味着」「这表明」式复述不改。** 第一轮 0.15/千字收录，配对复测三项口径全部反向（人类 0.027 vs AI 0.016 每千字）。已列入 X 级。

### 5. 顿号罗列过密

一个分句内两个以上顿号、连起三项以上并列。第一轮 AI 3.21 / 人类 1.78；配对复测密集并列 AI 1.45 倍，两轮同向。

改法：能概括就概括；必须保留时改变其中一项的句法，不让它们排成同一结构。不改法规条目、配置清单等必须完整列出的；Markdown 列表内部。句内排比（「提升效率，降低成本，优化体验」）人类用得不比 AI 少，不在本条范围。

### 6. 相邻句结构同款

相邻句同一句法骨架，逗号位置一样、成分顺序一样、收尾一样。第一轮每百段 AI 9.41 / 人类 4.81；配对复测高度同构 AI 1.6 倍（三连句 2.75 倍），两轮同向。

改法：打散其中一句——合并、拆分、换语序或改短句。只改句内，不动段落顺序不删信息。

> ❌ Cloudflare 发长文提了一套凭证隔离框架。AWS 把 Kiro Crew 开源了，一个多 agent 编排平台。Y Combinator 也把内部工具 QM 放出来了。
> ✅ Cloudflare 发长文提了一套凭证隔离框架。AWS 和 Y Combinator 则各自开源了一套编排工具，Kiro Crew 配签名审计日志，QM 自带「人类批准门」。

平级案例凑数时可合并同类项、次要的压成半句，信息不删只改主次。叙事推进（先发生什么、结果如何）不算。清单式段落、对话引语、文学排比不改。

### 7. 拟人化喻体（人审区，不自动改）

把工具系统比作理想化的人：「像一位智慧的导师」「永不疲倦的初级审查员」。第一轮 7.3×，配对复测拟人化喻体 AI 1.2 倍（弱信号）——但两侧近饱和（99.3%/97.4% 的文章都含拟人），差异不在「有没有」在贴切度，而贴切度模型判不准（与比喻贴切度同族，模型间共识 0–40%）。

2026-10-26 起移入人审区：模型对贴切度理解不可靠，默认保留比喻和拟人，不用全篇清单打断改写。用户主动要求检查 H 级时，再列出命中原句供人审，**不评级不给意见**；明确要求把某条改成非比喻时，平实陈述这个工具/系统实际做了什么。

### F 级单模型指纹的处置

**指纹是研究语料中的模型使用偏好，不能用来反推这篇文章由哪个模型写成。** 不要求用户提供生成模型；未知来源文本照样检测，但报告只说“本篇密度/用法与哪种指纹方向相似”，不说“这篇来自某模型”。对可定位、可安全改写的指纹用法，默认提出最小改法；次数与密度用于排序，不是单项豁免。模型的语义判断只核对具体用法，不能把单模型差异说成跨模型通用事实。

- **破折号**：>2/千字为优先处理线，不是唯一入口。逐处检查，装饰性停顿或把本可直说的结论悬置起来时默认建议改；承担必要强调、插入解释或人物语气且改动会损失作用时保留，并写明理由。
- **分号**：逐处看能否安全拆成句号；连续分号让一句承载过多层次时优先建议拆。确有并列层级或逻辑对应、拆句会损失关系时保留。
- **引号**：Opus 偏少不构成补引号的理由。按引语、专名和原文标注需要处理，不凭指纹增删。
- **高度同构三连**：按第 13 条的封闭语义判据确认；达到整篇报告门槛时优先处理，单组确有机械复用也可列低优先级拟改。刻意修辞、清单和叙事中的三件事保留，并说明依据。

F 级可改的局部候选默认提出改法；保留要举出这处表达不可替换的具体功能，不能只因数量少或作者模型未知而放过。指纹中“引号偏少”等缺失型、句长分布等整篇型指标没有逐处命中可改，只报告方向或在确有独立问题时处理。研究中的单模型显著不等于本篇单次命中显著。

### 8. 破折号（指纹规则，密度决定优先级）

**破折号密度 >2/千字时优先处理；低于这条线也逐处检查可否安全改写。** 配对复测显示分模型极端分化：GPT −0.54（比人类还少）/ Opus +0.95（偏多）。密度低于人类参考值 0.80/千字的文本不因“缺破折号”而补写。

确需改时：直接写完整句子，或在不损失语义关系的前提下改用逗号、句号。

> ❌ 答案其实很简单——专注。
> ✅ 答案是专注。

### 9. 段首零主语评论（降级：不再自动检测）

原为改写规则（补「这」字）。2026-10-26 裁定不再列入检测与改写：该特征为第三层弱信号（配对复测 AI 4.9% vs 人类 3.3%，约 1.5 倍，接近临界），且与第四层已反转的「句间指代不清」（人类不清率是 AI 4-5 倍，多为可控紧凑）属同族——AI 的阅读负担不在语法层指代，在概念层换说法（见规则 11）。正文遇到读着悬空的段首评论仍可按「补回指词」处理，但不扫描、不计分、不进报告。

> 原规则 9（概括盖住同段具体信息）2026-10-13 撤销——对称口径复查概括替代净零（更含糊 24.7% vs 更具体 26.0%），净零特征不进改写集，整条降 X 级，见 X 级清单。

---

### 语义层改写规则（第 10-13 条，配合第 1.5 步判读结果使用）

四项基于 270 对配对复测统计显著（同义重命名为单模型判据，弱一档）。改写只动逐条复核后纳入方案的项。

### 10. 同义重命名（段级）

同一实体/概念在段内换实义说法（「优化／增强／提升／提高」轮着用；「版图→基地→项目→节点」叫同一个项目），读者要做「X 就是 Y」的等同连接。配对复测：AI 0.83-0.86 次/段 vs 人类 0.49；≥2 次重灾段 AI 20.6-22.5% vs 人类 8.4%。**证据注记：Jev 单模型一轮判据，跨模型同向但未迭代，稳健性弱于其他三条。**

改法：同义链统一回原名词。零信息损失——人类范本就是反复用原名的写法（人类语料里同一段 3 次原名重复的实测例）。

> ❌ 采用兼容体系……站点利用率就可能提升（同段前文说的是「优化」「增强」）
> ✅ 采用兼容体系……站点利用率就可能优化（统一回原词）

不改：不同实体恰好用近义词（判据要求同一概念）；术语首次引入时「又名 X」的正式介绍；文学性指称变化。

### 11. 衔接连环过长

段段紧扣、零跳转。判读口径：连续「明确承接」接口数 ≥6（AI 短文中位 7 连环 vs 人类 2，93% 的 AI 文有 ≥6 连环）。真正问题不是承接词频率（两侧都低，无害），是零跳转的背景概率——读者全程被动接收，无需参与推理。

改法：在连环中选 1-2 个接口改成自然跳跃——话题跟着材料走，不替读者预先铺垫。改前检查该接口是否承担因果/伏笔功能，承担则换下一个接口。

> ❌ 每段开头都接住上一段末句关键词（「这也解释了为什么……」「从这个角度看……」连环 7 段）
> ✅ 选一处直接切话题（人类范本：从主业务直接跳到一句新业务的引语，中间不铺垫）

不改：论证链的关键环节；文类本身要求紧扣（教程、法律文书）。

### 12. 结论提示冒号（语义层版）

规则 2 的语义层补充：只有「冒号前给出独立明确的结论性判断，冒号后展开论证」这一类才是真信号（AI 2.1-2.2 倍）。冒号总量人类反而多，「空转提示引列表」人类高一个量级（X 级）。

改法同规则 2：删提示语直接写内容；前半句承接上文时只换标点。

### 13. 高度同构三连

连续三句共用同一句法骨架（「叫什么名字？／承载什么功能？／嵌入哪个生态？」）。宽口径排比无区分力（人类本就爱排比），只有骨架逐字复刻的**高度同构**档是信号（AI 29.4% vs 人类 10.7%）。指纹层特征，证据强度弱于第一层。

改法：拆掉其中一句——合并、拆分、换语序或改短句，打破骨架复用。不是删掉一项内容。

> ❌ 服务网络能不能覆盖到我春节回老家的那段路？／车的残值能不能经得起检验？／这家公司出了问题谁来管？
> ✅ 服务网络能不能覆盖到我春节回老家的那段路？车的残值经不经得起检验，谁说了算？出了问题这家公司管不管？

不改：刻意修辞（演讲、檄文、诗歌）；清单/表格体；叙事推进的三件事（先发生什么、结果如何）。

---

## X 级清单（永不改，防误改）

| 特征 | v1 依据 | 配对复测结果 | 处置 |
|------|--------|--------------|------|
| 序数词小标题 | 3.1× | **反转**：人类 8.6% vs AI 4.9% | 永不改 |
| 「这意味着」复述 | 翻译腔收录 | **反向**：人类 0.027 vs AI 0.016/千字 | 永不改 |
| 空转句引列表 | 9.4× | **反向**：人类高一个量级 | 永不改 |
| 概括替代（同段有数也不改） | 语义层 24.7%（单侧口径） | **对称口径净零**：更含糊 24.7% vs 更具体 26.0%，数字保留 98% | 永不改（2026-10-13 撤销 v2 规则 9） |
| 精确数字堆砌 | 曾疑 AI 多 3 倍 | δ−0.06，话题混杂假象 | 永不改 |
| 漂亮词黑名单 | 赋能/闭环/抓手 | δ+0.10 不显著 | 永不改 |
| 名词化、明喻、设问、模糊量词、首先/其次/总之 | 经典清单 | 全部 \|δ\|<0.2 | 永不改 |
| 句长/段落长度不参差 | 曾疑 AI 均匀 | 配对复测两轮均无差异 | 不为节奏改句长 |
| 「其」字用量 | — | 人类更多（反向） | 不删 |

各条实测数据、测量脚本、被推翻的预设见 [RESEARCH.md](./RESEARCH.md)。

## 只能人审的（skill 明确不碰）

- **比喻贴切度**：真实的 AI 味（硬套宏大意象、直译腔、混合比喻），但不是频率问题不是词表问题，模型间共识只有 0–40%。检测报告可给出活跃暗喻密度作参考；默认保留，不把判断任务交给用户。用户主动要求人审时才列 H 级清单，只列出不评级，由用户决定具体条目。
- **暗喻、拟人化喻体**：2026-10-26 起不做语义层检测（暗喻密度只对 Opus 成立，GPT 无差；拟人两侧近饱和），与比喻贴切度一起并入人审区——通读标红区时顺手看，不做候选判读
- 三个并列案例是否在凑数（要看语义）
- 「参差」的质量（自然节奏 vs 机械长短交替，脚本分不开）

---

## 最终验收

- 改前报告是否列出本篇指标、研究参照与显著性口径、可定位的例句、具体改法和排除项，并等待用户回复再改写；A/B 及语义层命中是否逐条复核，误报是否排除；C/H 是否遵守默认保留边界
- 语义层判断是否守了纪律：只用判据标签、每条独立判、拿不准选兜底
- 每处改动是否都能对应方案项和规则编号，指不出的撤销
- 是否最小改动：没有顺便润色、没动相邻文字
- 实词全部有出处；限定词让步（「可能」「通常」）没被抹掉
- 结构完全保留：标题层级、段落顺序、列表表格引用代码块位置
- 小标题编号、「这意味着」、空转引列表句没被误删（X 级）
- 没有制造参差：没为节奏改句长、没拆段落、没强加「我/你」
- 破折号只在高密度文本中处理过
- 没碰概括替代——即使同段有具体数值也不改（X 级；改写不引入新含糊由信息守恒原则兜底）
- 段首零主语评论没被扫描/计分（2026-10-26 降级）
- 复测+对比报告已给用户，A/B 清零，C 级指标无大幅摆动
````

## File: examples/agent-memory-case/README.md
size: 1463
sha: 53b842c2ab4a952fc7410da3821d8057bb807cad
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/README.md

```text
# Lieflat Less AI Tone｜完整案例

文章：《Agent 的记忆问题：为什么你的 AI 助手总在失忆》

这个文件夹把同一篇文章的改前检测、建议、改稿、左右对照和复测放在一起，供阅读或作为 skill 工作流示例。

| 阶段 | 产出 | 用途 |
|---|---|---|
| 原始输入 | [原稿](00-原稿.md) | 核对事实和文字起点。 |
| 阶段一：改前检测 | [检测结果与修改建议](01-改前检测与修改建议.md) | 列出脚本与语义指标、研究参照、原文例句、具体改法和保留范围；这一阶段应等待用户回复。 |
| 阶段二：改写 | [改后全文](02-改后全文.md) | 用户回复后交付可直接使用的文章。 |
| 阶段二：对照 | [左右两列 HTML 对照页](03-左右对照.html) | 逐段查看删去和新增的文字，可切换“仅看修改 / 查看全文”。 |
| 阶段三：复测 | [复测结论](04-复测结论.md) | 核对剩余命中、误报和内容守恒。 |

附录数据：[改前脚本检测](数据-改前检测.json) · [逐条语义判读](数据-语义判读.json) · [改后脚本复测](数据-改后复测.json)

**时间顺序说明**：这篇改稿是在本次对话早些时候生成的；之后 skill 的流程才调整为“展示检测与建议，等用户回复，再改写”。本案例把已有原稿与改稿整理为阶段产出，方便检视新版流程。它不表示新流程可以跳过用户回复。
```

## File: README.md
size: 18758
sha: ffa232f3e48ee115360ecb55919ee9b30014045c
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/README.md

````text
# Lieflat Less AI Tone

中文 | [English](README.en.md)

![去 AI 味 Skill：约 520 万字、100+ 项指标、约 50 万次模型语义判断](assets/less-ai-tone-hero-zh.png)

**一个基于两轮实测语料（共 1,169 篇、约 520 万汉字、100+ 项指标、约 50 万次模型语义判断）的去 AI 味 skill：先交付有指标、研究参照、原文例句和改法的检测报告，用户回复后再改写和复测。**

这个 skill 用两轮对照研究筛选值得处理的写作特征，再对成稿做有依据的检测和最小改写。

---

## 1 研究问题

AI 在 Coding 能力提升的同时，写作的体感好像并没有同步变好，生成的文字依然读起来很奇怪。

比如不少主力模型智商极高，但写出来的长文我往往要读好几遍，很大的原因是它满篇都在用「不是技术问题，而是认知问题」的对举、密集的破折号和分号，还有完全理解不了的比喻。

为了处理这些问题，常见的做法是给模型列一张禁用词表，或者塞一段「去 AI 味 Prompt」。我也试过很长一段时间，但实操下来有两个明显痛点：

第一是禁用词表管不住真正的 AI 味。很多文章完全避开了「赋能」「闭环」「抓手」，标点也很克制，但读完三段依然一眼就能看出是 AI 写的。

第二是容易乱改、误伤正常表达。把十几条经验规则攒在一起喂给模型直接改稿，模型会非常激进地把文章里原本自然的设问句、「一、二、三」小标题一并删掉，甚至为了迎合「长短句参差」的指令，把顺畅的句子硬生生拆碎。

市面上流传的「AI 味清单」基本来自个案观察和个人语感，从未经过系统检验。我的思路是，从「读着像 AI」这个很难直接验证的主观体验里，找到若干个能客观反映模型写作特征的指标，先量化评测，再顺藤摸瓜地从工程和规则上把问题解决掉。

从源头看，把「去 AI 味」做成一套可靠的 Skill，核心只涉及三个问题：

第一，怎么把脚本数不出来的「AI 味」真正测准？这决定了能不能抓到藏在句子意思和上下文里的深层习惯。

第二，哪些语言特征是真正影响阅读体验的标准？这决定了改写规则往哪里发力。

第三，拿到这些指标后，如何管住模型的手？这决定了改写过程能否在清理套路的同时，不误伤作者原本的正常表达。

这些工作在构建思路上有两个相同的原则：

首先是有效，让每个指标能简洁直接地对应一个可定位的句法或篇章问题，通过指标高低，顺藤摸瓜地在规则上准确动刀。

其次是可靠，让评测与改写前后的变化尽量可以量化，避免凭感觉盲改。

## 2 两轮实验

### 2.1 第一轮实验：629 篇对照文本

语料生成方法：同一批话题，五个模型各写 60 篇，与 329 篇人类作者文章对照。

语料统计：

| 侧 | 篇 | 汉字 | 句 | 段 |
|---|---|---|---|---|
| 生成 | 300 | 1,179,105 | 37,642 | 14,549 |
| 人类 | 329 | 1,647,867 | 57,909 | 31,172 |

模型：claude-opus-4-6、deepseek-v4-pro、gemini-3.1-pro、gpt-5.6-sol、kimi-k3。人类侧分组独立统计，检验组间一致性。

判定标准： 倍率 R = 生成侧频率 ÷ 人类侧频率。R≥2.0 纳入；1.25–2.0 条件纳入（需人类侧组间一致且绝对量足）；0.8–1.25 排除；<0.8 人类更多，反向也不可作为删改依据。另有三项附加条件：组间一致性（极差≤5 倍）、算子可定位性（能指出改哪一句）、改写可操作性（"补虚词"无法验收，整项弃用）。

### 2.2 第二轮实验：270 对配对复测

第一轮实验的根本缺陷是语料不配对，第二轮收紧了这一点，选择将人类文章里的数字、事件提炼成任务卡发给 AI，让它在同样的事实约束下写同题文章。

三层测量标准：脚本层，语义层和人工层。脚本层用正则数标点个数、句长、小节数等完全可被量化计算的部分。语义层补充脚本层无法判断的语义理解部分，脚本先抽候选片段，模型对每条做封闭式判断（这是不是密集并列/结论宣告/结构复用），在这里使用 Jev 进行判断，总共判断50 万次。最后是人工测评层面。

一个特征在某一层测量中显著即可成立，不需要三层全通过。

| 层 | 工具 | 测什么 | 规模 |
|---|---|---|---|
| 脚本层 | Python 正则 + 统计 | 90 项可计算指标：标点密度、句长分布、词汇多样性（mtld/mattr）、欧化构式、小节几何、段落桥接、正式度波动、四字词、黑名单词 | 540 篇全量，配对 Wilcoxon + Cliff's δ，\|δ\|≥0.33 显著 |
| 语义层 | 结构化判断接口（Jev） | 9 项脚本测不了的语义指标：结论提示冒号、密集并列、序数词小标题、相邻句同构、段首零回指、句间段间衔接、"这意味着"复述、概括替代具体信息、拟人化喻体 + 活跃暗喻密度 | **约 50 万次判断**（第二轮 43.1 万 + 增补轮回指/同义重命名约 11 万）、1.92 万次请求、3.54 亿 token，全部落盘可复算 |
| 人工层 | 逐句标注 + 抽样复核 | 比喻贴切度、判据误判率 | AI 比喻失败模式归纳（硬套宏大意象、直译腔、混合比喻、三连标题） |

## 3 核心结果：最终指标汇总

按证据强度分四层。表中同时列出第一轮对照值和第二轮配对复测结果，并标明所属口径；配对复测的脚本层使用配对 Wilcoxon + Cliff's δ（|δ|≥0.33 为显著门槛），语义层约 50 万次模型判断。

δ 是什么：随机抽一篇 AI 文和一篇人类文对比，「AI 更多」的概率减去「AI 更少」的概率。正数=AI 比人类多，负数=AI 比人类少；绝对值越大差距越大，0.33 以上算显著，0.66 以上算差距很大。

### 3.1 第一层：通用显著 AI 味指标

由脚本层/语义层/人工层共同测出、GPT5.6 和 Opus4.6 同向显著的9条指标如下：

| 特征 | 脚本层证据（GPT δ / Opus δ） | 语义层证据 | 方向 |
|---|---|---|---|
| **欧化构式「不是A而是B」** | +0.88 / +0.72（最强纯写作信号） | 密集并列 1.45 倍 | 生成侧多。例：「用户购买的不是模型参数，而是一件每天要戴、需要充电、还会出现在社交场合的物品」「潘宇扬并不是从通用AI退回一个小功能，而是在尝试证明另一种生长顺序」 |
| **用词不敢重复（mtld/mattr）** | +0.91/+0.55、+0.75/+0.55 | — | 生成侧词汇更多样。例：同一段里「优化／增强／提升／提高」轮着用；「采用兼容体系……站点利用率就可能提升」——人类会反复用同一个词，AI 换着说 |
| **结构切得太碎** | 小节长度方差 −0.91/−0.75、小标题密度 +0.65/+0.83、每节句数 −0.63/−0.79、小节数 +0.51/+0.70（中位数 AI 7 vs 人类 1） | —（分节是纯结构特征，语义层不测） | 生成侧分节多而短且整齐。实测抽样：AI 文 1.3–1.7 个小标题/千字（3000–6000 字的文章切 5–9 节），人类整篇连写、按自然话题换段 |
| **句长/节奏太均匀** | 句长方差 −0.88/−0.40、逗号小句长方差 −0.87(GPT) | — | 生成侧落差小。第一轮抽样中 AI 文句长 CV 0.41–0.55、人类 0.67；配对复测的人类参考值为 0.54，两轮口径不可直接混用，也不能据此机械调整句长 |
| **前置定语长（欧化）** | +0.48 / +0.54 | — | 生成侧名词前修饰长。例：「它还不是一套能够在任何餐桌上完全自动运行的系统」「这种连续数据也解释了为什么团队没有把产品做成一次拍照识别的工具」——中心词前面挂了二十来字的修饰 |
| **结论提示冒号** | 冒号总密度人类反而多（−0.37/−0.31） | 「结论提示」AI 2.1 倍（「核心是：」「残酷的现实是：」） | 生成侧爱先摆结论。例：「这组数字传递出一个残酷的现实：不管你是街边个体户的夫妻店……三个月是第一道坎，半年是生死线」 |
| **衔接过度顺滑** | — | AI 明确承接 98.9% vs 人类 95.2%；段间跳转 AI 2.1% vs 人类 7.2% | 生成侧段段紧扣。例：连续多段以「这也解释了为什么……」「从这个角度看……」开头（实测 30 篇里"这也解释了"起段 10 次）；人类每 14 段就有一次直接跳到新话题，AI 每 50 段才一次 |
| **密集并列/枚举** | 顿号 +0.56(GPT)、分号 +0.80(GPT) | AI 7.845 vs 人类 5.398 每千字（1.45 倍） | 生成侧爱排比列举。例：「火锅、快餐、家庭聚餐和独自进食，不同光线、不同穿着、……」一句连排多个场景维度 |
| **比喻贴切度差** | —（正则只能数比喻标记词，标记词密度人类反而多 2.4 倍） | —（六个大模型两两共识仅 0–40%，最高分段 22 句里 9 句误报——测不出是模型能力缺口，不是信号不存在） | **人工层确证**。失败模式：硬套宏大意象（"窄门""三根支柱"）、直译腔（"钢夹"）、混合比喻（"坠崖＋松动地板"）、三连标题。贴切度只能人审；skill 默认保留原文比喻 |

**一次重要的二次否决**：初次语义测评发现 24.7% 的可比较段落从具体信息变得更概括，曾据此设立改写规则。改用对称口径复查后，向相反方向变化的比例为 26.0%，净差近零；精确数字密度在配对复测中也无差异。因此“概括替代”已从改写规则降为 X 级，不再据此删改。原文事实和限定词仍受信息守恒原则保护。

### 3.2 第二层：不同模型有不同的写作特征

特征本质是高度重复的表层习惯，即标点与句法的使用偏好，包括破折号用多少、句子多长、爱不爱分号等。这类指标，判定证据主要来自脚本验证。主要有以下特征指标：

| 特征 | GPT-5.6 | Claude Opus 4.6 | 含义 |
|---|---|---|---|
| 破折号 | −0.54（比人类还少） | **+0.95**（100% 文章使用） | 方向完全相反，改写必须先知道文本像谁。Opus 例：「在营收急剧收缩的压力下，公司迅速启动了大规模的营销开支削减——最先被砍掉的，正是搜索广告和效果投放」 |
| 每小句「的」字 | −0.75 | +0.62 | GPT「的」用得比人类少，Opus 比人类多，方向相反 |
| 引号 | ≈0 | −0.67 | Opus 写文章明显不爱用引号，比人类少得多 |
| 分号 / 顿号 | +0.80 / +0.56 | −0.11 / +0.14 | GPT 专属。例：「对于食材分明的欧美常见"白人餐"，准确率可以超过90%；到了中餐火锅，准确率约为70%至80%；遇到糊状食物，则需要用户通过语音或事后手动补充」——三档场景用两个分号串成一句，人类更常拆成三句 |
| 句子结构绕（单动词句少等） | 全显著 | 全不显著 | GPT 专属，含三个子特征，各配例：**① 单动词句少**（δ−0.72）——一个动词撑一句的短直句（「转折发生在疫情期间。」「Odyss试图把这一步交给机器。」）在 GPT 文中稀少，取而代之的是动词堆叠：「项链利用多模态视觉大模型，观察食物被送入口中的过程，再把零散的进食动作还原成一天的饮食记录」——一句四个动词连环。**② 静态句少**（δ−0.71）——直陈状态/判断的句子（「问题在于，开发者影响力不等于消费者入口。」）人类常用，GPT 偏爱把一切都写成动作过程。**③ 主谓距离短**（δ−0.62）——人类常在主语和谓语之间插一大段：「续航能否覆盖一天，设备是否舒适，记录是否准确，建议是否真的改变饮食，这些问题只有在持续使用中才会显现」——主语到谓语隔了 30 字，GPT 很少这样写 |
| 少提问 | −0.59 | −0.12 | GPT 写文章明显不爱提问，比人类少得多；Opus 跟人类差不多 |
| 长句少/中句多 | −0.68/+0.81 | +0.05/+0.04 | GPT 写长句比人类少、中句比人类多：句长集中在中档（25–45 字），几乎没有 6–12 字的短促句收尾，也极少 60 字以上的长流水句 |
| 焦点后置 | +0.05 | +0.47 | Opus 专属：新信息压在句尾，铺垫占前大半句。「定价权不在工厂手里，品牌归属也不在工厂手里，工厂只是全球供应链上那个沉默的、可以被随时替换的生产节点」「如果说一个行业每天有近一万间门店关门，听起来像是危言耸听，但这恰恰是中国餐饮业正在发生的事」——读者要等最后才知道这句想说什么 |
| **活跃暗喻密度** | 2.099 ≈ 人类 2.066 | **2.851**（合并口径 1.2 倍全部由 Opus 拉高） | Opus 专属的研究观察，不是通用删改依据。GPT 暗喻量与人类无异；两种模型的比喻贴切度都需要人审，skill 默认保留原文比喻 |

### 3.3 第三层：不够显著的指标

| 特征 | 证据 |
|---|---|
| 段首零回指评论 | AI 4.9% vs 人类 3.3%（约 1.5 倍） |
| 相邻句高度同构 | AI 8.71% vs 5.52%（1.6 倍，三连句 2.75 倍） |
| AI 堆精确数字 | δ −0.06，话题混杂假象，配对后消失 |
| 赋能/闭环/抓手等黑名单词 | δ +0.10，配对同事实后无差 |
| "首先/其次/总之"连接词 | δ +0.02，对当代模型彻底失效 |
| "这意味着"式空转复述 | 人类反而多（三项口径全反） |

## 4 工作流

```bash
# 第一步：脚本检测（只报告，不改写；--json 存档供第四步用）
python3 scripts/detect.py <文件或目录> --json > /tmp/before.json

# 第 1.5 步：语义层候选抽取 + 会话内模型按封闭判据判读
#   （同义重命名段 / 段间衔接接口 / 冒号句 / 三连同构组，
#     判据见 references/semantic-criteria.md，单篇约 40-80 条）
python3 scripts/detect.py <文件> --candidates --out /tmp/candidates.json

# 第二步：模型复核命中，报告本篇指标、研究显著性、例句、改法和排除项；等待用户回复

# 第三步：收到用户回复后，按其接受或调整的方案改写（规则见 SKILL.md）

# 第四步：复测 + 前后对比报告（默认 Markdown，--format html 出网页版）
python3 scripts/detect.py <改后文件> --json > /tmp/after.json
python3 scripts/report.py 原文 改后文 /tmp/before.json /tmp/after.json \
    --semantic /tmp/candidates_labeled.json --out 去AI味报告.md
```

完整示例：[Agent 记忆问题案例](examples/agent-memory-case/README.md)。其中有改前报告、改后全文、左右两列 HTML 对照页和复测结论。

检测分三层：**脚本层**（数得出符号的，detect.py）、**语义层**（要理解句意的四项，会话内模型按封闭判据逐条判）、**人审层**（比喻贴切度/暗喻/拟人喻体——模型间共识只有 0-40%，只列出不判）。

检测报告分级：

| 级 | 含义 | 处理 |
|---|---|---|
| A | 机械改：删提示语、换标点，零语义风险 | 模型复核误报并提出建议；用户回复后改 |
| B | 建议改：顿号罗列、长定语，需句式重组 | 模型逐条筛选并提出建议；用户回复后改 |
| C | 只报告：句长均匀、结构碎——整篇级问题 | 默认不改；用户主动要求时再处理 |
| H | 人审区：拟人喻体等贴切度问题，模型判不准 | 默认保留；用户主动要求时再列清单 |
| X | 已否决：实测不是 AI 味（配对复测反向） | 永不改，展示计数防误改 |
| F | 指纹：破折号/分号/引号等分模型特征 | 带方向解读；可安全改写的局部命中默认建议改，保留须给具体理由 |

### 防过度改写

模型改写 AI 味最常见的失败是改过头：为"像人写的"把句子改得忽长忽短、拆段落、删掉本来正常的表达。SKILL.md 定了六条改写原则：**最小改动**（一处命中只改必需部分）、**信息守恒**（改写后每个实词须能在原文指出出处）、**不制造参差**（句长离散度人机无差异，不为节奏改句长）、**结构不动**、有风格参考时以参考为准、改后三查加复测。

检测报告的结构区（句长 CV、节长 CV、同构/百段、小标题密度）会标明各参考值所属轮次与计算口径。配对复测的句长 CV 人类参考值为 0.54；第一轮抽样的 0.67 不与其混用，也不把任何指标强行推到目标值——机械参差化比不改更糟。

## 5 方法论教训

研究过程本身的缺陷，记录在 RESEARCH.md，共六次测量失误（宽正则误测、分母选择错误）和两次配对复测推翻。

## 6 复算

```bash
# 单篇/单目录检测报告
python3 scripts/detect.py <目录>

# 人类 vs 生成语料的规则命中率对比（需自备语料）
python3 scripts/compare-human-ai.py --human <目录...> --ai <目录...>

# 段落级：句子同构（段首零回指已于 2026-10-26 移除：弱信号，与已反转的指代不清同族）
python3 scripts/check-structure.py --human <目录...> --ai <目录...>

# 译文句式频率（生成侧）
python3 scripts/check-translationese.py <目录...>
```

语料因版权不入库，数字第三方无法直接核验；可复用的是方法、判定阈值和算子定义，全部在脚本内公开。换成自有语料即可重算全部指标。

## 7 局限

1. 语义层是单模型判断，抽样复核误判 15–30%，方向可信、精确百分点不可信
2. 人类语料组间差异大（破折号极差百倍），扩充语料可能改变部分结论
3. 模型迭代持续向人类文风收敛，所有频率数值是特定时点观测
4. 比喻贴切度、案例是否凑数、参差的质量，机器测不了，只能人审

---

**规则集** [SKILL.md](./SKILL.md) · **检测协议** [DETECT.md](./DETECT.md) · **完整实测记录** [RESEARCH.md](./RESEARCH.md)

## 8 安装与使用

让支持 Agent Skills 的 AI 安装仓库中的 `lieflat-less-ai-tone` skill；也可以在本机运行：

```bash
npx skills add larashero3-dotcom/lieflat-less-ai-tone
```

安装后给 AI 一篇成稿。它会先运行脚本并判读语义候选，交付有研究参照、原文例句和具体改法的检测报告。你回复「按建议改」或调整范围后，它才改写、复测并生成前后对比。完整演示见 [Agent 记忆问题案例](./examples/agent-memory-case/README.md)。

---

**数据与代码** [scripts/](./scripts/) · **English** [README.en.md](README.en.md)

**许可** [CC BY-NC 4.0](./LICENSE)（署名-非商业性使用 4.0；商用授权联系作者）
````

## File: scripts/check-structure.py
size: 4350
sha: 35132c32d9c6b096cfe286e6a5714225748b568c
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/scripts/check-structure.py

````text
"""段落级结构特征对比：相邻句结构同款、段首零主语评论。

用法：
    python3 scripts/check-structure.py --human <目录...> --ai <目录...>

为什么单独一个脚本：这两项的分母是段数，不是字数。
用「每千字」会被结构差异带偏——AI 平均每篇 10 个小标题、人类 1-2 个，
按字数算问句小标题会虚高 30 倍，换成占小标题比例后差异消失。
涉及结构元素的指标，分母必须是同类元素的总数。
"""
import re
import sys
from pathlib import Path

# 段首评论语：省掉回指成分时读者要翻回上一段
COMMENT = re.compile(
    r"^(?:听起来|看起来|看上去|听上去|说白了|说到底|换句话说|意味着|值得注意|"
    r"不难看出|细看|再看|回过头看|问题在于|原因在于|结果是|有意思的是|"
    r"更重要的是|关键在于|真正的)"
)
# 回指成分：把上文接回来
ANAPHOR = re.compile(r"^(?:这|那|其|此|上面|前面|刚才|以上|该|它|他|她|它们|他们|同样|类似|相比|反过来|但|不过|所以|因此|于是|而|另|除此|与此)")
# 比喻起段（对照项，实测人类更多）
METAPHOR = re.compile(r"^(?:像|就像|好比|好像|仿佛|如同|这就像)")

def paragraphs(text):
    out = []
    for p in text.split("\n"):
        p = p.strip()
        if len(p) < 8 or p.startswith(("#", "|", "```", ">", "- ", "* ", "!", "[")):
            continue
        out.append(p)
    return out

def signature(sent):
    """句子结构指纹：逗号数、有无冒号、有无括号、长度档"""
    return (sent.count("，"), "：" in sent, ("（" in sent or "(" in sent), len(sent) // 15)

def isomorphic(para, n):
    """段内是否有连续 n 句结构指纹相同"""
    sents = [s.strip() for s in re.split(r"[。！？]", para) if len(s.strip()) > 10]
    hits = 0
    for i in range(len(sents) - n + 1):
        sigs = [signature(s) for s in sents[i:i + n]]
        if all(s == sigs[0] for s in sigs) and sigs[0][0] >= 1:
            hits += 1
    return hits

def measure(texts):
    total = iso2 = iso3 = zero = meta = nonfirst = 0
    for t in texts:
        ps = paragraphs(t)
        total += len(ps)
        for i, p in enumerate(ps):
            iso2 += isomorphic(p, 2)
            iso3 += isomorphic(p, 3)
            if METAPHOR.match(p):
                meta += 1
            if i == 0:
                continue
            nonfirst += 1
            if COMMENT.match(p) and not ANAPHOR.match(p):
                zero += 1
    return {
        "段数": total,
        "连续两句同构/百段": iso2 / total * 100 if total else 0,
        "连续三句同构/百段": iso3 / total * 100 if total else 0,
        "段首零主语评论/非首段%": zero / nonfirst * 100 if nonfirst else 0,
        "比喻起段/百段(对照)": meta / total * 100 if total else 0,
    }

def load(dirs):
    out = []
    for d in dirs:
        for f in Path(d).rglob("*.md"):
            if f.parent.name == "_meta":
                continue
            try:
                out.append(f.read_text(encoding="utf-8"))
            except (UnicodeDecodeError, OSError):
                continue
    return out

def main():
    human, ai, cur = [], [], None
    for a in sys.argv[1:]:
        if a == "--human":
            cur = human
        elif a == "--ai":
            cur = ai
        elif cur is not None:
            cur.append(a)
    if not human or not ai:
        print(__doc__)
        return

    groups = []
    for d in human:
        ts = load([d])
        if ts:
            groups.append((f"g{len(groups) + 1}", measure(ts)))
    hm = measure([t for d in human for t in load([d])])
    am = measure(load(ai))

    keys = [k for k in am if k != "段数"]
    print(f"AI {am['段数']} 段，人类 {hm['段数']} 段\n")
    head = f"{'指标':<26}{'AI':>8}{'人类':>8}{'倍率':>7}{'稳定性':>8}"
    print(head)
    print("-" * len(head))
    for k in keys:
        a, h = am[k], hm[k]
        r = a / h if h > 0.001 else float("inf")
        # 各组数值只用来算稳定性，不打印
        vals = [m[k] for _, m in groups]
        spread = max(vals) / max(min(vals), 0.01)
        print(f"{k:<26}{a:>8.2f}{h:>8.2f}{r:>6.2f}×{'稳定' if spread <= 5 else '波动大':>8}")

if __name__ == "__main__":
    main()
````

## File: scripts/check-translationese.py
size: 4810
sha: a7ba68ef2ec29145e00b46aae4da83c70ea97090
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/scripts/check-translationese.py

```text
"""统计翻译腔标记在 AI 语料中的出现频率（每千汉字）。

用法：
    python3 scripts/check-translationese.py <语料目录> [更多目录...]

人类语料若不在本机，只能给出 AI 侧绝对频率：
某标记在 AI 文本里都极少出现时，它不可能是 AI 味的判别特征。
BASELINE 是研究已确认有区分力的规则，用同一脚本同一语料测量，作为收录门槛。
"""
import re
import sys
from collections import defaultdict
from pathlib import Path

MARKERS = {
    "被动-抽象": r"被(认为|视为|称为|设计为|应用于|赋予|看作)",
    "受到…的": r"受到[^，。]{0,12}的(关注|影响|重视|挑战)",
    "形式主语": r"(值得注意的是|有必要指出的是|可以说的是|需要指出的是)",
    "存在着/有着": r"(存在着|有着)",
    "当…的时候": r"当[^，。]{2,20}(的时候|时)，",
    "在…的过程中": r"在[^，。]{2,20}(的过程中|的情况下)",
    "如果…的话": r"如果[^，。]{2,20}的话",
    "并列连词密集": r"并且|而且",
    "轻动词": r"(进行|作出|给予|予以)了?[^，。]{0,6}(分析|调整|优化|支持|评估|检查|讨论)",
    "不仅仅是": r"(不仅仅是|远不止是|不过是|无非是)",
    "正是/恰恰是": r"(正是|恰恰是)",
    "复数硬译": r"(一系列的|各种各样的|诸多)",
    "程度直译": r"(在某种程度上|一定程度上|从某种意义上说|在很大程度上|相对而言)",
    "句首连接词": r"(?:^|\n)\s*(然而|因此|此外|与此同时|换言之|总而言之)[，、]",
    "这意味着": r"(这意味着|这表明|这说明|换句话说)",
    "前置话题壳": r"(对于[^，。]{2,15}来说|对[^，。]{2,15}而言|就[^，。]{2,15}而言|在[^，。]{2,12}方面)",
    "扮演角色": r"(扮演|承担)了?[^，。]{0,8}角色",
    "以一种…方式": r"以一种[^，。]{2,12}的(方式|形式)",
    "使得…能够": r"使得?[^，。]{0,12}(能够|可以)",
    "长前置定语": r"(?:一个|一种|一套|这种|这个)[^，。、；：！？\n]{15,}的[一-鿿]{2,5}",
    "的…的…的连用": r"的[^，。]{1,8}的[^，。]{1,8}的",
}

# 对照基准：研究已确认有区分力的规则，同一脚本同一语料
BASELINE = {
    "[基准]段首序数词": r"(?:^|\n)\s*(首先|其次|再次|最后|第一|第二|第三|一方面|另一方面)",
    "[基准]不是…而是": r"(不是|并非)[^，。]{1,20}(，|)而是",
    "[基准]破折号": r"——",
    # 只匹配提示语+冒号；宽正则（任意汉字+冒号）会把标题、列表、对话一并算进来
    "[基准]提示性冒号": (r"(?:一句话(?:总结|说|概括)|简单说|说白了|总结|小结|结论|核心(?:是|在于|观点)?"
                       r"|关键(?:是|在于)?|重点(?:是)?|原因(?:如下|有|在于)?|问题(?:是|在于)?"
                       r"|答案(?:是)?|本质(?:是|上)?|定义(?:是)?|具体(?:来说|如下|包括)?"
                       r"|举例(?:来说)?|换句话说|也就是说|我的(?:观点|判断|结论)|建议(?:是)?)[：:]"),
}

def model_of(path):
    return re.sub(r"-T\d.*", "", Path(path).stem)

def main():
    dirs = sys.argv[1:]
    if not dirs:
        print(__doc__)
        return
    files = [f for d in dirs for f in Path(d).rglob("*.md") if f.parent.name != "_meta"]
    if not files:
        print(f"找不到语料：{dirs}")
        return

    texts = {f: f.read_text(encoding="utf-8") for f in files}
    joined = "\n".join(texts.values())
    kchars = len(re.findall(r"[一-鿿]", joined)) / 1000
    models = sorted({model_of(f) for f in files})
    print(f"语料 {len(files)} 篇，{kchars/10:.1f} 万汉字，模型 {len(models)} 个：{', '.join(models)}\n")

    # 每模型汉字数，用于分模型频率
    mk = defaultdict(float)
    for f, t in texts.items():
        mk[model_of(f)] += len(re.findall(r"[一-鿿]", t)) / 1000

    rows = []
    for name, pat in {**MARKERS, **BASELINE}.items():
        rx = re.compile(pat)
        total = len(rx.findall(joined))
        docs = sum(1 for t in texts.values() if rx.search(t))
        per_model = {m: len(rx.findall("\n".join(t for f, t in texts.items() if model_of(f) == m))) / mk[m]
                     for m in models}
        rows.append((total / kchars, total, docs, name, per_model))
    rows.sort(reverse=True)

    head = f"{'标记':<16}{'每千字':>8}{'总数':>7}{'覆盖':>10}  " + "".join(f"{m[:11]:>12}" for m in models)
    print(head)
    print("-" * len(head))
    for per_k, total, docs, name, pm in rows:
        cov = f"{docs}/{len(files)}"
        line = f"{name:<16}{per_k:>8.2f}{total:>7}{cov:>10}  " + "".join(f"{pm[m]:>12.2f}" for m in models)
        print(line)

if __name__ == "__main__":
    main()
```

## File: scripts/compare-human-ai.py
size: 6529
sha: 645607ba88617fe300bb3be7e01f73fd332aef13
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/scripts/compare-human-ai.py

```text
"""人类语料 vs AI 语料的规则命中率对比报告。

用法：
    python3 scripts/compare-human-ai.py --human <目录> [更多] --ai <目录> [更多]

为什么要这个脚本：SKILL.md 里的「区分力 ×N」都来自一批已不可用的旧测量，
且切句逻辑有缺陷。本脚本用统一的测量方式同时跑人类侧和 AI 侧，
让每条规则的倍率可复现。倍率 = 人类频率 / AI 频率（<1 表示 AI 用得更多）。
"""
import re
import sys
import collections
from pathlib import Path

# 每条对应 SKILL.md 的一条规则，正则尽量贴规则的触发标记
RULES = {
    "2 翻案腔": r"(?:不是|并非|不在于)[^，。！？\n]{1,20}[，]?(?:而是|而在于)",
    # 原正则禁空格与字母，漏掉「用哪个模型、Team Skill 开关、定时任务」这类并列
    "3 顿号罗列过密": r"[^，。！？；：、\n]{1,14}、[^，。！？；：、\n]{1,14}、[^，。！？；：、\n]{1,14}",
    # 句内同构排比已移出规则：实测人类用得不比 AI 少，保留测量供复查
    "(已删)句内同构-更X": r"更[一-鿿]{1,3}[、，][^，。\n]{0,8}更[一-鿿]{1,3}",
    "(已删)句内同构-同字两项": r"([一-鿿]{1,2})[^，。、\n]{2,12}[、，]\1[^，。、\n]{2,12}",
    # 问句相关的规则已从 SKILL.md 删除，此处不再统计。三轮测量结论都不稳定：
    #   问号总量 —— 人类看似多 2.5 倍，但由个别组贡献，组间不一致
    #   自问自答 —— 倍率 1.03，宽正则还会误抓「？这是另一个问题」这类新起句
    #   小标题问句 —— 每千字 32 倍，换成占小标题比例后 AI 2.7% / 人类最高 3.6%，无差异
    # 教训：涉及结构元素的指标，先确认分母可比。
    "4 破折号": r"——",
    # 只匹配提示语+冒号（引出总结/结论/原因/定义），不匹配对话、标题、列表和普通句中冒号
    "5 提示性冒号": (r"(?:一句话(?:总结|说|概括)|简单说|说白了|总结|小结|结论|核心(?:是|在于|观点)?"
                    r"|关键(?:是|在于)?|重点(?:是)?|原因(?:如下|有|在于)?|问题(?:是|在于)?"
                    r"|答案(?:是)?|本质(?:是|上)?|定义(?:是)?|具体(?:来说|如下|包括)?"
                    r"|举例(?:来说)?|换句话说|也就是说|我的(?:观点|判断|结论)|建议(?:是)?)[：:]"),
    "6 序数词当小标题": r"(?:^|\n)\s*(?:首先|其次|再次|最后|第一|第二|第三|一方面|另一方面)[，、]",
    "(已删)就字": r"就",
    "(已删)很字": r"很",
    "(已删)了字": r"了",
    "(已删)口语连接词": r"但是|其实|不过|就是",
    "9 动词名词化": r"(?:完成|实现|进行|开展)了?(?:对)?[^，。\n]{0,10}的(?:优化|提升|调整|分析|改造|升级)",
    "11 过长前置定语": r"(?:一个|一种|一套|这种|这个)[^，。、；：！？\n]{15,}的[一-鿿]{2,5}",
    "11 当…时": r"当[^，。\n]{2,20}(?<!的时候)时，",
    "11 前置话题壳": r"(?:对于[^，。\n]{2,15}来说|对[^，。\n]{2,15}而言|就[^，。\n]{2,15}而言|在[^，。\n]{2,12}方面)",
    "11 句首连接词": r"(?:^|\n)\s*(?:然而|因此|此外|与此同时|换言之|总而言之)[，、]",
    "11 这意味着": r"(?:这意味着|这表明|这说明|换句话说)",
}

def load(dirs):
    out = []
    for d in dirs:
        for f in Path(d).rglob("*.md"):
            if f.parent.name == "_meta":
                continue
            try:
                out.append(f.read_text(encoding="utf-8"))
            except (UnicodeDecodeError, OSError):
                continue
    return out

def measure(texts):
    joined = "\n".join(texts)
    k = len(re.findall(r"[一-鿿]", joined)) / 1000
    hits = {}
    for name, pat in RULES.items():
        rx = re.compile(pat)
        n = len(rx.findall(joined))
        docs = sum(1 for t in texts if rx.search(t))
        hits[name] = (n / k if k else 0, n, docs)
    return hits, k, len(texts)

def parse_args(argv):
    human, ai, cur = [], [], None
    for a in argv:
        if a == "--human":
            cur = human
        elif a == "--ai":
            cur = ai
        elif cur is not None:
            cur.append(a)
    return human, ai

def main():
    hd, ad = parse_args(sys.argv[1:])
    if not hd or not ad:
        print(__doc__)
        return

    # 每个人类目录单独测，用于判断差异在语料内部是否稳定（不输出各组明细）
    per_author = {}
    for d in hd:
        texts = load([d])
        if texts:
            # 不拿目录名当标签，也不输出各组数值：语料目录常带来源信息，
            # 逐组列出等于公开语料构成。只用来算稳定性。
            per_author[f"g{len(per_author) + 1}"] = measure(texts)
    ha = load(ad)
    if not per_author or not ha:
        print(f"语料为空：human={len(per_author)} 组, ai={len(ha)} 篇")
        return

    all_human = [t for d in hd for t in load([d])]
    hh, hk, hn = measure(all_human)
    ah, ak, an = measure(ha)

    names = list(per_author)
    print(f"人类语料：{hn} 篇，{hk/10:.1f} 万汉字")
    print(f"AI 语料：{an} 篇，{ak/10:.1f} 万汉字\n")

    head = f"{'规则':<18}{'人类':>8}{'AI':>7}{'倍率':>8}{'稳定性':>8}  判读"
    print(head)
    print("-" * (len(head) + 6))

    rows = []
    for name in RULES:
        h, a = hh[name][0], ah[name][0]
        ratio = h / a if a > 0.001 else float("inf")
        rows.append((ratio, name, h, a))

    for ratio, name, h, a in sorted(rows, key=lambda r: r[0]):
        disp = f"{ratio:>7.2f}" if ratio != float("inf") else "      ∞"
        # 各组数值只用来算稳定性，不打印——逐组列出等于公开语料构成
        vals = [per_author[n][0][name][0] for n in names]
        spread = max(vals) / max(min(vals), 0.01)
        stable = "稳定" if spread <= 5 else "波动大"
        if ratio < 0.5:
            verdict = "AI 明显更多 → 值得改"
        elif ratio < 0.8:
            verdict = "AI 略多"
        elif ratio <= 1.25:
            verdict = "无差异 → 不该作为规则"
        elif ratio <= 3:
            verdict = "人类更多"
        else:
            verdict = "人类明显更多 → 方向是补"
        if spread > 5 and ratio > 1.25:
            verdict += "（语料内部差异大，疑体裁）"
        print(f"{name:<18}{h:>8.2f}{a:>7.2f}{disp}{stable:>8}  {verdict}")

if __name__ == "__main__":
    main()
```

## File: scripts/detect.py
size: 25176
sha: d8fd6f4a3efbd9e70244d9655f5e5865642d27e2
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/scripts/detect.py

````text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""单篇/单目录 AI 味检测报告（去AI味 v2 的第一步，只检测不改写）。

用法：
    python3 scripts/detect.py <文件或目录> [--json] [--max-hits 5]
    python3 scripts/detect.py <文件> --candidates [--out 候选.json]

--candidates 抽取语义层候选（同义重命名段 / 段间衔接接口 / 冒号句 / 三连同构），
交给会话内 Claude 按 references/semantic-criteria.md 判断，结果并入报告。

分级：
    A 机械改    固定句式/标点问题，模型复核后给建议，用户回复后改
    B 建议改    需要句式重组或换说法，模型逐条复核后给建议，用户回复后改
    C 只报告    结构/节奏类分布特征，默认不改
    F 指纹      分模型特征（破折号/分号/引号），解读必须带方向

人类参考值来自两轮实测（见 RESEARCH.md）：
- 第一轮 629 篇对照（5 模型各 60 篇 vs 329 篇人类，不配对）
- 第二轮 270 对同题同事实配对 + 43 万次语义判断
标 [可调] 的阈值是经验值，换语料后应重新标定。
"""
import argparse
import json
import re
import sys
from pathlib import Path

EXTS = {".md", ".txt"}

# ---------------- 正则指标（level, 名称, 模式, 人类参考/千字, 建议） ----------------

REGEX_HITS = [
    ("A", "翻案腔",
     r"(?:不是|并非|不在于|与其说)[^，。！？\n]{1,20}[，]?(?:而是|而在于|不如说)",
     "0.22", "正面直陈：删「不是A」，直接给B。见规则1"),
    ("A", "提示语冒号",
     r"(?:一句话(?:总结|说|概括)|简单说|说白了|总结|小结|结论|核心(?:是|在于|观点)?"
     r"|关键(?:是|在于)?|重点(?:是)?|原因(?:如下|有|在于)?|问题(?:是|在于)?"
     r"|答案(?:是)?|本质(?:是|上)?|具体(?:来说|如下|包括)?"
     r"|举例(?:来说)?|换句话说|也就是说|我的(?:观点|判断|结论)|建议(?:是)?)[：:]",
     "0.08", "删提示语直接写内容；前半句承接上文时只换标点。见规则2"),
    ("A", "起手式",
     r"(?:说白了|说穿了|先说结论)[，,]",
     "0.008", "删掉直接给判断。见规则3"),
    ("A", "当…时从句",
     r"当[^，。\n]{2,20}(?<!的时候)时，",
     "—", "删「当」和「时」，让从句直接作前一分句。见规则4"),
    ("A", "前置话题壳",
     r"(?:对于[^，。\n]{2,15}来说|对[^，。\n]{2,15}而言|就[^，。\n]{2,15}而言|在[^，。\n]{2,12}方面)",
     "—", "对象直接放到主语位，删壳子。见规则4"),
    ("A", "句首连接词",
     r"(?:^|\n)\s{0,3}(?:然而|因此|此外|与此同时|换言之|总而言之)[，、]",
     "—", "移到主语后，或换「不过」「其实」。见规则4"),
    ("B", "顿号并列≥3",
     r"[^，。！？；：、\n]{1,14}、[^，。！？；：、\n]{1,14}、[^，。！？；：、\n]{1,14}",
     "1.78", "能概括就概括；必须保留时打破其中一项的句法。见规则5"),
    ("B", "过长前置定语",
     r"(?:一个|一种|一套|这种|这个)[^，。、；：！？\n]{15,}的[一-鿿]{2,5}",
     "≈0.1", "拆成两个分句，「的」字连续两个以上同。见规则4"),
    ("H", "拟人化喻体",
     r"(?:像|如同|好比|犹如|相当于)[^，。！？\n]{0,6}一[位名个][^，。！？\n]{0,14}"
     r"(?:导师|秘书|助手|顾问|管家|审查员|实习生|军师|教练|伙伴|专家|舵手|灯塔)",
     "0.002", "换成这东西实际做了什么。见规则6"),
    ("X", "概括替代(已否决)",
     r"(?:显著(?:提升|提高|增长|改善|增加|优势)|大幅(?:提升|增长|提高|改善|下降|减少)"
     r"|明显(?:改善|提升|优势|变化)|效率的提升|众多|海量)",
     "—", "2026-10-13 对称口径复查净零（AI 更含糊 24.7% vs 更具体 26.0%，数字保留 98%），"
     "即使同段有具体数值也不改；改写的保真由信息守恒原则兜底"),
    # ---- 已否决特征：统计并展示，但明确标不改，防过度清理 ----
    ("X", "序数词小标题(已否决)",
     r"(?:^|\n)\s{0,3}#{1,6}\s{0,3}[一二三四五六七八九十][、.]",
     "—", "实测人类比 AI 更常用（8.6% vs 4.9%），不是 AI 味，不改"),
    ("X", "「这意味着」复述(已否决)",
     r"(?:这意味着|这表明|这说明)",
     "—", "配对复测人类更多，三项口径全反向，不改"),
    ("X", "空转句引列表(已否决)",
     r"[^，。！？\n]{0,25}[：:]\s*(?:\n|$)",
     "—", "配对复测人类高一个量级（目录式长文的正常写法），不改"),
]

# 分号/破折号/引号按字符计，不走逐行命中
CHAR_HITS = [
    ("F", "破折号", "——", "0.80", "密度>2/千字优先处理；可安全改的局部用法默认建议改，保留须说明功能"),
    ("F", "分号", "；", "—", "GPT 指纹（δ+0.80）；可安全拆句时默认建议改，保留须说明层级作用"),
    ("F", "引号", "“", "—", "Opus 偏少（δ−0.67）；引号少不必然是问题，报告用"),
]

# 同义词轮换组（用词不敢重复的启发式检测，B级）
SYN_GROUPS = [
    ("使用", "采用", "运用", "利用", "借助"),
    ("方法", "方式", "途径", "路径", "做法"),
    ("提升", "提高", "增强", "强化", "优化"),
    ("显示", "表明", "揭示", "反映", "说明"),
    ("重要", "关键", "核心", "至关重要"),
    ("问题", "难题", "挑战", "困境", "痛点"),
    ("帮助", "协助", "助力", "支持"),
]

# 阈值 [可调]：换语料后重标
TH_SENT_CV = 0.55      # 句长CV低于此 → 节奏偏均匀（v1实测 人类0.67 / AI0.58）
TH_SECT_CV = 0.45      # 节长CV低于此 → 节长偏均匀
TH_HEAD_KK = 0.50      # 每千字小标题超过此 → 切得偏碎
TH_ISO_100P = 8.0      # 每百段两句同构超过此 → 同构偏多（人类4.81 / AI9.41）

# 人类参考线（270 对配对实测中位值，见 Downloads/分析结果/配对指标结果-按模型分列.csv）。
# ref 形如 "0.80"（人类中位/千字）或 "4.81/AI9.41"；两侧超界都算偏离（双侧计分）。
HUMAN_REF = {
    "句长CV":      {"ref": "0.54",  "ai": "0.46",  "note": "人类忽长忽短；低于参考=节奏均匀", "方向": "低"},
    "节长CV":      {"ref": "0.83",  "ai": "0.31",  "note": "人类节长参差；低于参考=节节等长", "方向": "低"},
    "小标题/千字": {"ref": "0.32",  "ai": "1.26",  "note": "人类整篇连写；高于参考=切得碎", "方向": "高"},
    "两句同构/百段": {"ref": "5.52", "ai": "8.71", "note": "第一层指标4（两句版），中等效应", "方向": "高"},
    "三句同构/百段": {"ref": "0.41*","ai": "0.84*", "note": "*为启发式粗估，语义判读见判据文件", "方向": "高"},
    "mtld粗估":    {"ref": "143",    "ai": "227",  "note": "高=换词多；AI 高于人类=不敢重复", "方向": "高"},
    "破折号":      {"ref": "0.83",  "ai": "2.02",  "note": "Opus 指纹 +0.95 / GPT −0.54，方向相反", "方向": "分模型"},
    "分号":        {"ref": "0.77",  "ai": "1.51",  "note": "GPT 指纹 δ+0.80；Opus −0.11 无差", "方向": "分模型"},
    "引号":        {"ref": "20.0",  "ai": "2.7",   "note": "Opus 偏少 δ−0.67；报告用，不改", "方向": "低"},
    "顿号":        {"ref": "6.12",  "ai": "8.24",  "note": "第一层密集并列（句内塞多项）", "方向": "高"},
    "冒号":        {"ref": "3.59",  "ai": "2.70",  "note": "总量人类更多；只有「结论提示」子类是真信号，语义层判", "方向": "低"},
}

# ---------------- 切分 ----------------

HEADING = re.compile(r"^#{1,6}\s")
BOLD_LINE = re.compile(r"^\*\*[^*]{2,40}\*\*$")
LIST_LINE = re.compile(r"^\s{0,3}(?:[-*+]|\d+[.、)])\s")
QUOTE_LINE = re.compile(r"^>")
FENCE = re.compile(r"^```")
TABLE_LINE = re.compile(r"^\|")

COMMENT = re.compile(
    r"^(?:听起来|看起来|看上去|听上去|说白了|说到底|换句话说|意味着|值得注意|"
    r"不难看出|细看|再看|回过头看|问题在于|原因在于|结果是|有意思的是|"
    r"更重要的是|关键在于|真正的)")

def hanzi(s):
    return len(re.findall(r"[一-鿿]", s))

def split_sents(para):
    return [s.strip() for s in re.split(r"[。！？；]", para) if len(s.strip()) >= 4]

def signature(sent):
    """句结构指纹：逗号数、有无冒号、有无括号、长度档（沿用第一版，经复测）"""
    return (sent.count("，"), "：" in sent or ":" in sent,
            ("（" in sent or "(" in sent), len(sent) // 15)

def isomorphic_triples(text):
    """三连同构候选（供语义层判读）：signature 粗筛出的连续三句，
    每组带行号与三句原文。粗筛宽（部分同构也收），判读由 Claude 按
    「高度同构」判据收紧——270 对实测：宽口径 AI 71.1% vs 人类 56.2%
    无区分力，只有高度同构档有 2.76× 差异。"""
    out = []
    for kind, body, first_no in paragraph_blocks(text):
        if kind != "prose":
            continue
        sents = [s for s in split_sents(body) if len(s) > 10]
        for i in range(len(sents) - 2):
            sigs = [signature(s) for s in sents[i:i + 3]]
            if all(s == sigs[0] for s in sigs) and sigs[0][0] >= 1:
                out.append({"line": first_no,
                            "sents": sents[i:i + 3]})
    return out

def isomorphic_hits(para, n):
    sents = [s for s in split_sents(para) if len(s) > 10]
    hits = []
    for i in range(len(sents) - n + 1):
        sigs = [signature(s) for s in sents[i:i + n]]
        if all(s == sigs[0] for s in sigs) and sigs[0][0] >= 1:
            hits.append("／".join(sents[i:i + n]))
    return hits

def paragraph_blocks(text):
    """按空行切块并分类，返回 [(kind, block_text, first_line_no)]"""
    blocks, cur, cur_kind, start = [], [], None, None
    in_fence = False
    for no, line in enumerate(text.splitlines(), 1):
        if FENCE.match(line):
            in_fence = not in_fence
            cur.append(line)
            continue
        if not in_fence and not line.strip():
            if cur:
                blocks.append((cur_kind or "prose", "\n".join(cur), start))
                cur, cur_kind, start = [], None, None
            continue
        if not cur:
            start = no
        cur.append(line)
        if in_fence:
            cur_kind = cur_kind or "code"
        elif HEADING.match(line):
            cur_kind = "heading"
        elif QUOTE_LINE.match(line):
            cur_kind = cur_kind or "quote"
        elif TABLE_LINE.match(line):
            cur_kind = cur_kind or "table"
        elif LIST_LINE.match(line):
            cur_kind = cur_kind or "list"
        elif BOLD_LINE.match(line) and cur_kind is None:
            cur_kind = "heading"
    if cur:
        blocks.append((cur_kind or "prose", "\n".join(cur), start))
    return blocks

def mtld(toks, threshold=0.72, min_len=10):
    """词汇多样性 MTLD 的近似（中文无分词，用二字组当伪词，粗估）"""
    if len(toks) < min_len * 4:
        return None

    def pass_factors(seq):
        factors, types, count = 0.0, set(), 0
        for t in seq:
            count += 1
            types.add(t)
            if count >= min_len and len(types) / count <= threshold:
                factors += 1
                types, count = set(), 0
        if count:
            factors += (1 - len(types) / count) / (1 - threshold)
        return max(factors, 1e-9)

    f, r = pass_factors(toks), pass_factors(toks[::-1])
    return round(len(toks) / 2 * (1 / f + 1 / r))

def cv(vals):
    if len(vals) < 2:
        return None
    m = sum(vals) / len(vals)
    if m == 0:
        return None
    var = sum((v - m) ** 2 for v in vals) / len(vals)
    return (var ** 0.5) / m

# ---------------- 度量 ----------------

def measure_docs(docs):
    total_han = 0
    regex_hits = {name: [] for _, name, *_ in REGEX_HITS}
    char_counts = {name: 0 for _, name, *_ in CHAR_HITS}
    syn_hits = []
    n_para = n_head = 0
    iso2 = iso3 = 0
    sent_lens, sect_lens = [], []
    all_bigrams = []

    for fname, text in docs:
        lines = text.splitlines()
        # 逐行正则命中（跳过代码围栏内）
        in_fence = False
        for no, line in enumerate(lines, 1):
            if FENCE.match(line):
                in_fence = not in_fence
                continue
            if in_fence:
                continue
            for _, name, pat, *_ in REGEX_HITS:
                for m in re.finditer(pat, line):
                    excerpt = m.group(0)
                    regex_hits[name].append(
                        {"file": fname, "line": no, "excerpt": excerpt[:60]})
        for _, name, ch, *_ in CHAR_HITS:
            char_counts[name] += text.count(ch)

        # 结构
        blocks = paragraph_blocks(text)
        sect_chars = 0
        for kind, body, first_no in blocks:
            if kind == "heading":
                n_head += 1
                if sect_chars > 0:
                    sect_lens.append(sect_chars)
                sect_chars = 0
                continue
            if kind != "prose":
                continue
            n_para += 1
            h = hanzi(body)
            sect_chars += len(body)
            for s in split_sents(body):
                sent_lens.append(hanzi(s) or len(s))
            iso2 += len(isomorphic_hits(body, 2))
            iso3 += len(isomorphic_hits(body, 3))
            all_bigrams.extend(
                body[i:i + 2] for i in range(len(body) - 1) if hanzi(body[i:i + 2]) == 2)
        if sect_chars > 0:
            sect_lens.append(sect_chars)

        # 同义词轮换（段内 ≥2 个不同组员）
        for kind, body, first_no in blocks:
            if kind != "prose":
                continue
            for group in SYN_GROUPS:
                found = [w for w in group if w in body]
                if len(found) >= 2:
                    syn_hits.append({"file": fname, "line": first_no,
                                     "excerpt": "／".join(found),
                                     "context": body[:70]})
        total_han += hanzi(text)

    kk = total_han / 1000 or 1
    sent_cv = cv(sent_lens) if sent_lens else None
    sect_cv = cv(sect_lens) if len(sect_lens) >= 3 else None

    return {
        "meta": {
            "篇数": len(docs), "万汉字": round(total_han / 10000, 2),
            "段数": n_para, "小标题数": n_head,
        },
        "density": {name: round(n / kk, 3) for name, n in
                    [(nm, len(v)) for _, nm, *_ in REGEX_HITS for v in [regex_hits[nm]]]},
        "char_density": {name: round(n / kk, 3) for name, n in char_counts.items()},
        "hits": regex_hits,
        "syn_hits": syn_hits,
        "structure": {
            "句长CV": round(sent_cv, 3) if sent_cv else None,
            "节长CV": round(sect_cv, 3) if sect_cv else None,
            "小标题/千字": round(n_head / kk, 3),
            "两句同构/百段": round(iso2 / n_para * 100, 2) if n_para else None,
            "三句同构/百段": round(iso3 / n_para * 100, 2) if n_para else None,
            "mtld粗估": mtld(all_bigrams),
        },
    }

# ---------------- 语义层候选抽取 ----------------

def first_prose_blocks(text, max_gap=2):
    """按空行分块的 prose 块（去掉标题/代码/表格），max_gap 行以内算同块。"""
    return [(b, n) for kind, b, n in paragraph_blocks(text) if kind == "prose"]

NOISE_RE = re.compile(r"\]\(|\]\s*\(|\||^!|^中文\s*\|")

def clean_para(b):
    """去掉 markdown 强调/链接语法后返回纯文本，噪声行（导航/表格/图片）返回空。"""
    if NOISE_RE.search(b[:200]):
        return ""
    t = re.sub(r"!\[[^\]]*\]\([^)]*\)", "", b)
    t = re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", t)
    t = re.sub(r"[*`_#>]", "", t)
    return t.strip()

CAND_CAPS = {"rename": 60, "cohesion": 60, "colon": 80, "iso3": 60}  # 长文防爆，超出截断并标 truncated

def extract_candidates(docs):
    """四类语义层候选。每条带判据类型，供会话内 Claude 按
    references/semantic-criteria.md 逐条封闭判断（标签+置信度），
    判断结果写回同结构 JSON 的 label/confidence/reason 字段。"""
    rename, cohesion, colon, iso3 = [], [], [], []
    for fname, text in docs:
        blocks = [(clean_para(b), no) for b, no in first_prose_blocks(text)]
        blocks = [(b, no) for b, no in blocks if hanzi(b) >= 20]
        # 1) 同义重命名：段级（每段一条候选，判「换了几次实义说法」）
        for b, no in blocks:
            if hanzi(b) >= 30:
                rename.append({"type": "rename", "file": fname, "line": no, "para": b})
        # 2) 衔接连环：段间接口（上段末句 + 下段首句）
        for i in range(len(blocks) - 1):
            a, b = blocks[i][0], blocks[i + 1][0]
            tail = split_sents(a) or [a[-60:]]
            head = split_sents(b) or [b[:60]]
            cohesion.append({"type": "cohesion",
                             "file": fname, "line": blocks[i + 1][1],
                             "prev_tail": tail[-1], "next_head": head[0]})
        # 3) 冒号句：正文冒号（引号内/标题/列表行除外）
        in_fence = False
        for no, line in enumerate(text.splitlines(), 1):
            if FENCE.match(line):
                in_fence = not in_fence
                continue
            if in_fence or HEADING.match(line) or LIST_LINE.match(line) or NOISE_RE.search(line):
                continue
            for m in re.finditer(r"([^：:，。！？\n]{2,30})[：:](.{2,60})", line):
                colon.append({"type": "colon",
                              "file": fname, "line": no,
                              "colon_before": m.group(1), "colon_after": m.group(2)[:60],
                              "sentence": line.strip()[:120]})
        # 4) 三连同构：signature 粗筛 + Claude 判高度同构
        iso3.extend(dict(c, file=fname) for c in isomorphic_triples(text))
    all_c = {"rename": rename, "cohesion": cohesion, "colon": colon, "iso3": iso3}
    truncated = {k: len(v) > cap for k, v, cap in
                 ((k, v, CAND_CAPS[k]) for k, v in all_c.items())}
    meta = {"n_candidates": sum(min(len(v), CAND_CAPS[k]) for k, v in all_c.items())}
    meta.update({f"n_{k}": len(v) for k, v in all_c.items()})
    meta["truncated"] = {k: cap for k, cap in CAND_CAPS.items() if truncated[k]} or False
    if meta["truncated"]:
        # 均匀抽样保留候选（跳读不偏头部），判读覆盖率为截断后条数/总条数
        for k, cap in CAND_CAPS.items():
            if truncated[k]:
                step = len(all_c[k]) / cap
                all_c[k] = [all_c[k][int(i * step)] for i in range(cap)]
    return {"meta": meta,
            "rename": all_c["rename"], "cohesion": all_c["cohesion"],
            "colon": all_c["colon"], "iso3": all_c["iso3"]}

# ---------------- 报告 ----------------

def fmt_report(r, max_hits):
    out = ["去AI味检测报告（v2，只检测不改写）", ""]
    m = r["meta"]
    out.append(f"语料：{m['篇数']} 篇 / {m['万汉字']} 万汉字 / {m['段数']} 段 / {m['小标题数']} 个小标题")
    out.append("")

    def emit(level, title):
        rows = [(nm, ref, adv) for lv, nm, _, ref, adv in REGEX_HITS if lv == level]
        hits = r["hits"]
        dens = r["density"]
        any_row = False
        sec = [f"[{level}] {title}"]
        for nm, ref, adv in rows:
            n = len(hits.get(nm, []))
            d = dens.get(nm, 0)
            if n == 0:
                continue
            any_row = True
            ref_s = f"（人类≈{ref}/千字）" if ref != "—" else ""
            sec.append(f"  {nm}：{n} 处，{d}/千字{ref_s}")
            sec.append(f"    → {adv}")
            for h in hits[nm][:max_hits]:
                sec.append(f"      · {h['file']}:{h['line']}  {h['excerpt']}")
        if any_row:
            out.extend(sec)
            out.append("")
        return any_row

    emit("A", "机械改候选（模型复核后建议，用户回复后改）")
    emit("B", "建议改候选（模型逐条筛选，用户回复后改）")
    emit("C", "只报告（默认不改）")
    emit("H", "人审区（默认保留，用户主动要求时再审）")
    emit("X", "已否决特征（实测不是 AI 味，仅展示计数——不要改）")

    # 指纹
    sec = ["[F] 指纹（分模型特征，解读必须带方向）"]
    for _, nm, _, ref, adv in CHAR_HITS:
        d = r["char_density"].get(nm, 0)
        sec.append(f"  {nm}：{d}/千字" + (f"（人类≈{ref}）" if ref != "—" else ""))
        sec.append(f"    → {adv}")
    out.extend(sec)
    out.append("")

    # 同义词轮换
    if r["syn_hits"]:
        out.append("[B] 用词不敢重复（同义词轮换启发式，误报可能，逐条复核）")
        for h in r["syn_hits"][:max_hits * 2]:
            out.append(f"  · {h['file']}:{h['line']}  轮换：{h['excerpt']}")
            out.append(f"    {h['context']}")
        out.append("")

    # 结构
    s = r["structure"]
    out.append("[C] 结构与节奏（对照人类参考线，偏离才提示；箭头=往哪个方向偏算问题）")
    flags = []
    if s["句长CV"] is not None and s["句长CV"] < TH_SENT_CV:
        ref = HUMAN_REF["句长CV"]
        flags.append(f"句长CV={s['句长CV']}（人类中位{ref['ref']} / AI {ref['ai']}，偏低=节奏均匀）")
    if s["节长CV"] is not None and s["节长CV"] < TH_SECT_CV:
        ref = HUMAN_REF["节长CV"]
        flags.append(f"节长CV={s['节长CV']}（人类中位{ref['ref']} / AI {ref['ai']}，偏低=节长均匀）")
    if s["小标题/千字"] > TH_HEAD_KK:
        ref = HUMAN_REF["小标题/千字"]
        flags.append(f"小标题{s['小标题/千字']}/千字（人类中位{ref['ref']} / AI {ref['ai']}，偏高=切得碎）")
    if s["两句同构/百段"] is not None and s["两句同构/百段"] > TH_ISO_100P:
        ref = HUMAN_REF["两句同构/百段"]
        flags.append(f"两句同构{s['两句同构/百段']}/百段（人类{ref['ref']} / AI {ref['ai']}，偏高）")
    if s["三句同构/百段"] and s["三句同构/百段"] > 0.8:
        ref = HUMAN_REF["三句同构/百段"]
        flags.append(f"三句同构{s['三句同构/百段']}/百段（人类{ref['ref']} / AI {ref['ai']}，偏高；判读见判据文件）")
    for f_ in flags:
        out.append(f"  ⚠ {f_}")
    if not flags:
        out.append("  （结构节奏各项均在参考区间内）")
    if s["mtld粗估"]:
        ref = HUMAN_REF["mtld粗估"]
        out.append(f"  mtld粗估={s['mtld粗估']}（人类中位≈{ref['ref']} / AI≈{ref['ai']}；高于人类=换词多不敢重复；粗估，仅供参考）")
    out.append("")
    out.append("处理顺序建议：先A后B；C级项改写需要动结构或补信息，"
               "超出白名单边界，只在用户明确要求时另议。")
    return "\n".join(out)

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("target", help="文件或目录")
    ap.add_argument("--json", action="store_true", help="输出 JSON")
    ap.add_argument("--max-hits", type=int, default=5, help="每项最多列出的命中数")
    ap.add_argument("--candidates", action="store_true",
                    help="抽取语义层候选（rename/cohesion/colon/iso3），不跑常规检测")
    ap.add_argument("--out", help="候选 JSON 输出路径（默认 stdout）")
    args = ap.parse_args()

    p = Path(args.target)
    if not p.exists():
        print(f"路径不存在：{p}", file=sys.stderr)
        sys.exit(1)
    docs = []
    if p.is_file():
        docs.append((p.name, p.read_text(encoding="utf-8", errors="ignore")))
    else:
        for f in sorted(p.rglob("*")):
            if f.suffix.lower() in EXTS and f.is_file():
                docs.append((str(f.relative_to(p)),
                             f.read_text(encoding="utf-8", errors="ignore")))
    if not docs:
        print("未找到 .md/.txt 文件", file=sys.stderr)
        sys.exit(1)

    if args.candidates:
        c = extract_candidates(docs)
        payload = json.dumps(c, ensure_ascii=False, indent=1)
        if args.out:
            Path(args.out).write_text(payload, encoding="utf-8")
            n = c["meta"]["n_candidates"]
            print(f"候选 {n} 条 → {args.out}"
                  f"（rename {c['meta']['n_rename']} / cohesion {c['meta']['n_cohesion']}"
                  f" / colon {c['meta']['n_colon']} / iso3 {c['meta']['n_iso3']}）")
        else:
            print(payload)
        return

    r = measure_docs(docs)
    if r["meta"]["万汉字"] < 0.05:
        print("汉字过少（<500），检测无意义", file=sys.stderr)
        sys.exit(1)

    if args.json:
        print(json.dumps(r, ensure_ascii=False, indent=1))
    else:
        print(fmt_report(r, args.max_hits))

if __name__ == "__main__":
    main()
````

## File: scripts/report.py
size: 22037
sha: e4660e7e0a154233fe3cff864e17c7f129cd9204
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/scripts/report.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""去AI味 v2 · 前后对比报告：指标前后对比 + 分级问题清单 + 标记前后对照。

默认输出 Markdown 报告（与用户文稿同格式，md 标记原样保留，
可直接复制回写作流程；`--format html` 生成单文件网页版）。

用法（改动前后各跑一次 detect.py --json，再生成报告）：
    python3 scripts/detect.py 原文.md --json > /tmp/before.json
    python3 scripts/detect.py 改后.md --json > /tmp/after.json
    python3 scripts/report.py 原文.md 改后.md /tmp/before.json /tmp/after.json \
        [--semantic 判读结果.json] [--out 报告.md] [--format md|html]

--semantic 可选：detect.py --candidates 抽取的候选经 Claude 按
references/semantic-criteria.md 判读后的 JSON（条目带 label/confidence/reason）。

纯标准库，无外部依赖。
md 版对照约定：~~灰色删除~~ = 被改掉原文，**加粗** = 改后新文字。
"""
import argparse
import difflib
import html
import json
import re
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))
from detect import REGEX_HITS  # 名字 → 级别映射（A/B/H/X）

# ---------------- 指标呈现配置 ----------------

# HTML 顶部指标对比表：键 → (展示名, 方向说明, 人类参考)
# 参考值来自 270 对配对实测中位值（见 RESEARCH.md / 配对指标结果 CSV）。
METRIC_ROWS = [
    ("翻案腔", "不是A而是B 对举", "低", 0.22),
    ("提示语冒号", "结论提示冒号", "低", 0.08),
    ("顿号并列≥3", "密集并列", "低", 1.78),
    ("过长前置定语", "前置定语长", "低", 0.1),
]

STRUCT_ROWS = [
    ("句长CV", "句长起伏", "越高越参差", "人类≈0.54 / AI≈0.46"),
    ("节长CV", "节长参差", "越高越参差", "人类≈0.83 / AI≈0.31"),
    ("小标题/千字", "分节密度", "越低越整篇连写", "人类≈0.32 / AI≈1.26"),
    ("两句同构/百段", "相邻句同构", "越低越好", "人类≈5.52 / AI≈8.71"),
    ("三句同构/百段", "三连同构(粗筛)", "越低越好", "人类≈0.41 / AI≈0.84"),
    ("mtld粗估", "换词多样性", "低于人类≈自然", "人类≈143 / AI≈227"),
]

FINGERPRINT_ROWS = [
    ("破折号", "Opus 狂用 +0.95 / GPT 少用 −0.54，方向相反分模型看"),
    ("分号", "GPT 指纹 δ+0.80；Opus 无差"),
    ("引号", "Opus 偏少 δ−0.67，报告用不改"),
]

CSS = """
body{font-family:-apple-system,"PingFang SC",sans-serif;max-width:760px;margin:40px auto;line-height:1.9;font-size:16px;padding:0 20px;color:#222}
h1{font-size:22px}h2{font-size:19px;border-bottom:2px solid #ccc;padding-bottom:6px;margin-top:2.2em}
h3{font-size:16px;margin-bottom:0.4em}
table{border-collapse:collapse;width:100%;font-size:14px;margin:0.6em 0 1.4em}
th,td{border:1px solid #ddd;padding:5px 10px;text-align:left;vertical-align:top}
th{background:#f5f5f5}
.warn{background:#fff3cd;padding:14px 18px;border-radius:8px;margin-bottom:1.5em;font-size:14px}
.legend{color:#555;margin-bottom:2em;font-size:14px}
.chg,.ins{color:#d32f2f;font-weight:600}
.del{color:#aaa;text-decoration:line-through}
.up{color:#c62828;font-weight:600}.down{color:#2e7d32;font-weight:600}.flat{color:#777}
.tagA{background:#e3f2fd;padding:1px 7px;border-radius:4px;font-size:12px}
.tagB{background:#fff3e0;padding:1px 7px;border-radius:4px;font-size:12px}
.tagC{background:#f3e5f5;padding:1px;border-radius:4px;font-size:12px}
.tagF{background:#eceff1;padding:1px 7px;border-radius:4px;font-size:12px}
.tagX{background:#fafafa;color:#888;padding:1px 7px;border-radius:4px;font-size:12px}
.tagH{background:#fce4ec;padding:1px 7px;border-radius:4px;font-size:12px}
.small{color:#777;font-size:13px}
.human{color:#2e7d32}
details{margin:0.3em 0}
summary{cursor:pointer}
p{margin:0 0 1.1em}
"""

def esc(s):
    return html.escape(str(s), quote=False)

def arrow(before, after, better="low"):
    """better: 'low'=数值低更好, 'high'=数值高更好, None=不判方向"""
    if before is None or after is None or before == after:
        cls, mark = "flat", "→"
    elif better == "low":
        cls, mark = ("down", "↓") if after < before else ("up", "↑")
    elif better == "high":
        cls, mark = ("up", "↑") if after > before else ("down", "↓")
    else:
        cls, mark = "flat", "→"
    return f'<span class="{cls}">{mark}</span>'

# ---------------- 指标对比表 ----------------

def metric_table(d0, d1):
    rows = []
    for key, name, better, ref in METRIC_ROWS:
        v0 = d0["density"].get(key)
        v1 = d1["density"].get(key)
        rows.append(f"<tr><td>{esc(name)}</td>"
                    f"<td>{v0 if v0 is not None else '—'}</td>"
                    f"<td>{v1 if v1 is not None else '—'}</td>"
                    f"<td>{arrow(v0, v1, better)}</td>"
                    f'<td class="human">≈{ref}</td></tr>')
    for key, name, better, ref in STRUCT_ROWS:
        v0 = d0["structure"].get(key)
        v1 = d1["structure"].get(key)
        rows.append(f"<tr><td>{esc(name)}</td>"
                    f"<td>{v0 if v0 is not None else '—'}</td>"
                    f"<td>{v1 if v1 is not None else '—'}</td>"
                    f"<td>{arrow(v0, v1, better)}</td>"
                    f'<td class="human">{esc(ref)}</td></tr>')
    for key, note in FINGERPRINT_ROWS:
        v0 = d0["char_density"].get(key)
        v1 = d1["char_density"].get(key)
        rows.append(f"<tr><td>{esc(key)}<span class='small'>（指纹）</span></td>"
                    f"<td>{v0}</td><td>{v1}</td><td>{arrow(v0, v1, None)}</td>"
                    f'<td class="small">{esc(note)}</td></tr>')
    return ("<table><tr><th>指标</th><th>改前</th><th>改后</th><th>变化</th>"
            "<th>人类参考</th></tr>" + "".join(rows) + "</table>"
            '<p class="small">↓/↑ 绿色=向人类参考方向改善，红色=恶化；指纹行不判方向。'
            "参考值=270 对同题配对实测人类中位（每千字或 CV 值），见 RESEARCH.md。</p>")

# ---------------- 分级问题清单 ----------------

def findings_section(d):
    out = []
    for lvl, title, cls in [("A", "机械改（模型复核误报后处理）", "tagA"),
                            ("B", "建议改（模型逐条筛选后处理）", "tagB"),
                            ("H", "人审区（默认保留，用户主动要求时再审）", "tagH"),
                            ("X", "已否决特征（实测不是 AI 味——不要改）", "tagX")]:
        names = [nm for lv, nm, *_ in REGEX_HITS if lv == lvl]
        rows = []
        for nm in names:
            hs = d["hits"].get(nm, [])
            if not hs:
                continue
            rows.append(f"<div><strong>{esc(nm)}</strong> {len(hs)} 处")
            rows.append("<details><summary class='small'>展开命中</summary>")
            for h in hs[:20]:
                rows.append(f"<p class='small'>{esc(h['file'])}:{h['line']}　"
                            f"{esc(h['excerpt'])}</p>")
            rows.append("</details></div>")
        if rows:
            out.append(f'<h3><span class="{cls}">{lvl}</span> {esc(title)}</h3>')
            out.extend(rows)
    return "\n".join(out)

def semantic_section(sem):
    """语义层判读结果：四项各自小结 + 明细折叠。"""
    if not sem:
        return ""
    out = ['<h2>语义层判读（会话内模型按实验判据逐条判断）</h2>',
           '<p class="small">四项在 270 对配对语料统计显著；同义重命名为单模型判据（弱一档）。'
           '判据见 references/semantic-criteria.md。</p>']
    groups = {"rename": "同义重命名（段级）", "cohesion": "衔接方式（段间接口）",
              "colon": "冒号分类", "iso3": "高度同构三连"}
    for key, title in groups.items():
        items = [c for c in sem.get(key, []) if c.get("label")]
        if not items:
            continue
        counts = {}
        for c in items:
            counts[c["label"]] = counts.get(c["label"], 0) + 1
        stats = "，".join(f"{esc(k)} {v}" for k, v in sorted(counts.items(), key=lambda x: -x[1]))
        out.append(f"<h3>{esc(title)} <span class='small'>{len(items)} 条：{stats}</span></h3>")
        flagged = [c for c in items if c.get("label") in {
            "2组", "3组及以上",                      # 重命名重灾
            "明确承接",                              # 衔接连环（连续长度另算）
            "结论提示",                              # 冒号真信号
            "高度同构",                              # 同构真信号
        }]
        # 衔接连环长度
        chain_note = ""
        if key == "cohesion":
            labels = [c.get("label") for c in items]
            best = cur = 0
            for lb in labels:
                cur = cur + 1 if lb == "明确承接" else 0
                best = max(best, cur)
            chain_note = f"（最长连环 {best} 个接口；≥6 为 AI 特征，人类中位 2）"
            if best >= 6:
                chain_note = f'<span class="up">⚠ {chain_note}</span>'
        if key == "cohesion" and chain_note:
            out.append(f"<p>{chain_note}</p>")
        for c in flagged[:15]:
            text = c.get("para") or " → ".join(filter(None, [
                c.get("prev_tail"), c.get("next_head")])) or c.get("sentence") \
                or "／".join(c.get("sents") or [])
            conf = c.get("confidence", "")
            reason = c.get("reason", "")
            out.append(f"<p class='small'><strong>{esc(c['label'])}</strong>"
                       f"（置信:{esc(conf)}）{esc(c.get('file',''))}:{c.get('line','')}　"
                       f"{esc(text[:110])}"
                       + (f"<br>理由：{esc(reason[:100])}" if reason else "") + "</p>")
    return "\n".join(out)

# ---------------- 标红 diff ----------------

def para_split(text):
    """按空行分段，保留原文形态（不去 markdown 标记）。"""
    paras = [p for p in re.split(r"\n\s*\n", text) if p.strip()]
    return paras

def inline_diff(a, b):
    """段内字符级 diff：相同=黑，删=灰删除线，改/增=红。"""
    sm = difflib.SequenceMatcher(None, a, b, autojunk=False)
    out = []
    for tag, i1, i2, j1, j2 in sm.get_opcodes():
        if tag == "equal":
            out.append(esc(a[i1:i2]))
        elif tag == "delete":
            out.append(f'<span class="del">{esc(a[i1:i2])}</span>')
        elif tag == "insert":
            out.append(f'<span class="ins">{esc(b[j1:j2])}</span>')
        elif tag == "replace":
            out.append(f'<span class="del">{esc(a[i1:i2])}</span>'
                       f'<span class="chg">{esc(b[j1:j2])}</span>')
    return "".join(out)

def diff_section(text0, text1):
    p0, p1 = para_split(text0), para_split(text1)
    sm = difflib.SequenceMatcher(None, p0, p1, autojunk=False)
    body = []
    for tag, i1, i2, j1, j2 in sm.get_opcodes():
        if tag == "equal":
            for p in p0[i1:i2]:
                body.append(f"<p>{esc(p)}</p>")
        elif tag == "delete":
            for p in p0[i1:i2]:
                body.append(f'<p><span class="del">{esc(p)}</span></p>')
        elif tag == "insert":
            for p in p1[j1:j2]:
                body.append(f'<p><span class="ins">{esc(p)}</span></p>')
        elif tag == "replace":
            for pa, pb in zip(p0[i1:i2], p1[j1:j2]):
                body.append(f"<p>{inline_diff(pa, pb)}</p>")
            # 段数不等时多出的段落单独标
            for p in p0[i1 + (j2 - j1):i2]:
                body.append(f'<p><span class="del">{esc(p)}</span></p>')
            for p in p1[j1 + (i2 - i1):j2]:
                body.append(f'<p><span class="ins">{esc(p)}</span></p>')
    return "\n".join(body)

# ---------------- Markdown 报告 ----------------

def arrow_md(before, after, better="low"):
    if before is None or after is None or before == after:
        return "→"
    if better == "low":
        return "↓" if after < before else "↑"
    if better == "high":
        return "↑" if after > before else "↓"
    return "→"

def metric_table_md(d0, d1):
    rows = ["| 指标 | 改前 | 改后 | 变化 | 人类参考 |", "|---|---|---|---|---|"]
    for key, name, better, ref in METRIC_ROWS:
        v0 = d0["density"].get(key)
        v1 = d1["density"].get(key)
        rows.append(f"| {name} | {v0 if v0 is not None else '—'} | "
                    f"{v1 if v1 is not None else '—'} | {arrow_md(v0, v1, better)} | ≈{ref} |")
    for key, name, better, ref in STRUCT_ROWS:
        v0 = d0["structure"].get(key)
        v1 = d1["structure"].get(key)
        rows.append(f"| {name} | {v0 if v0 is not None else '—'} | "
                    f"{v1 if v1 is not None else '—'} | {arrow_md(v0, v1, better)} | {ref} |")
    for key, note in FINGERPRINT_ROWS:
        v0 = d0["char_density"].get(key)
        v1 = d1["char_density"].get(key)
        rows.append(f"| {key}（指纹） | {v0} | {v1} | {arrow_md(v0, v1, None)} | {note} |")
    rows.append("")
    rows.append("↓/↑ = 向人类参考方向改善/恶化；指纹行不判方向。"
                "参考值=270 对同题配对实测人类中位（每千字或 CV 值），见 RESEARCH.md。")
    return "\n".join(rows)

def findings_section_md(d):
    out = []
    for lvl, title in [("A", "机械改（模型复核误报后处理）"),
                       ("B", "建议改（模型逐条筛选后处理）"),
                       ("H", "人审区（默认保留，用户主动要求时再审）"),
                       ("X", "已否决特征（实测不是 AI 味——不要改）")]:
        names = [nm for lv, nm, *_ in REGEX_HITS if lv == lvl]
        blocks = []
        for nm in names:
            hs = d["hits"].get(nm, [])
            if not hs:
                continue
            lines = [f"**{nm}** {len(hs)} 处", ""]
            for h in hs[:20]:
                lines.append(f"- `{h['file']}:{h['line']}`　{h['excerpt']}")
            lines.append("")
            blocks.append("\n".join(lines))
        if blocks:
            out.append(f"### {lvl} 级 · {title}\n")
            out.extend(blocks)
    return "\n".join(out)

def semantic_section_md(sem):
    if not sem:
        return ""
    out = ["## 语义层判读（会话内模型按实验判据逐条判断）", "",
           "四项在 270 对配对语料统计显著；同义重命名为单模型判据（弱一档）。"
           "判据见 references/semantic-criteria.md。", ""]
    groups = {"rename": "同义重命名（段级）", "cohesion": "衔接方式（段间接口）",
              "colon": "冒号分类", "iso3": "高度同构三连"}
    for key, title in groups.items():
        items = [c for c in sem.get(key, []) if c.get("label")]
        if not items:
            continue
        counts = {}
        for c in items:
            counts[c["label"]] = counts.get(c["label"], 0) + 1
        stats = "，".join(f"{k} {v}" for k, v in sorted(counts.items(), key=lambda x: -x[1]))
        out.append(f"### {title}（{len(items)} 条：{stats}）")
        out.append("")
        if key == "cohesion":
            labels = [c.get("label") for c in items]
            best = cur = 0
            for lb in labels:
                cur = cur + 1 if lb == "明确承接" else 0
                best = max(best, cur)
            note = f"最长连环 {best} 个接口；≥6 为 AI 特征，人类中位 2。"
            if best >= 6:
                note = f"⚠ {note}"
            out.append(note)
            out.append("")
        flagged = [c for c in items if c.get("label") in {
            "2组", "3组及以上", "明确承接", "结论提示", "高度同构",
        }]
        for c in flagged[:15]:
            text = c.get("para") or " → ".join(filter(None, [
                c.get("prev_tail"), c.get("next_head")])) or c.get("sentence") \
                or "／".join(c.get("sents") or [])
            conf = c.get("confidence", "")
            reason = c.get("reason", "")
            out.append(f"- **{c['label']}**（置信:{conf}）`{c.get('file','')}:{c.get('line','')}`　{text[:110]}"
                       + (f"　理由：{reason[:100]}" if reason else ""))
        out.append("")
    return "\n".join(out)

def inline_diff_md(a, b):
    """段内字符级 diff 的 md 版：<del> = 原文，<ins> = 新文字。

    用 HTML 行内标签而非 ~~/**：改动经常落在原有 **加粗**、## 标题等
    md 标记内部或旁边，~~/** 会跟原文标记配对错乱（嵌套碎掉）；
    <del>/<ins> 是 md 合法行内 HTML，跟任何 md 标记零字符冲突，
    Typora/VS Code/GitHub 预览均正常渲染（删除线/下划线）。
    """
    sm = difflib.SequenceMatcher(None, a, b, autojunk=False)
    out = []
    for tag, i1, i2, j1, j2 in sm.get_opcodes():
        if tag == "equal":
            out.append(a[i1:i2])
        elif tag == "delete":
            out.append(f"<del>{a[i1:i2]}</del>")
        elif tag == "insert":
            out.append(f"<ins>{b[j1:j2]}</ins>")
        else:  # replace
            out.append(f"<del>{a[i1:i2]}</del><ins>{b[j1:j2]}</ins>")
    return "".join(out)

def diff_section_md(text0, text1):
    p0, p1 = para_split(text0), para_split(text1)
    sm = difflib.SequenceMatcher(None, p0, p1, autojunk=False)
    body = []
    for tag, i1, i2, j1, j2 in sm.get_opcodes():
        if tag == "equal":
            body.extend(p0[i1:i2])
        elif tag == "delete":
            body.extend(f"<del>{p}</del>" for p in p0[i1:i2])
        elif tag == "insert":
            body.extend(f"<ins>{p}</ins>" for p in p1[j1:j2])
        elif tag == "replace":
            for pa, pb in zip(p0[i1:i2], p1[j1:j2]):
                body.append(inline_diff_md(pa, pb))
            for p in p0[i1 + (j2 - j1):i2]:
                body.append(f"<del>{p}</del>")
            for p in p1[j1 + (i2 - i1):j2]:
                body.append(f"<ins>{p}</ins>")
    return "\n\n".join(body)

def build_report_md(t0, t1, d0, d1, sem, name0, name1):
    parts = [
        "# 去AI味 · 前后对比报告",
        "",
        f"{name0} → {name1}",
        "",
        "标记约定：<del>删除线</del> = 被改掉/删掉的原文；<ins>下划线</ins> = 改后的新文字；"
        "指标表 ↓/↑ = 相对人类参考的改善/恶化。",
        "",
        "## 一、指标前后对比",
        "",
        metric_table_md(d0, d1),
    ]
    sem_md = semantic_section_md(sem)
    if sem_md:
        parts.append(sem_md)
    parts.extend([
        "## 二、分级问题清单（改前检测）",
        "",
        findings_section_md(d0),
        "C 级（结构/节奏）见指标表；F 指纹见表内指纹行；"
        "比喻贴切度只能人审；本轮默认保留。用户主动要求时再列出相关原句供判断。",
        "",
        "## 三、前后对照（改后稿全文，改动处标记）",
        "",
        diff_section_md(t0, t1),
    ])
    return "\n\n".join(parts)

# ---------------- 组装 ----------------

def build_report(t0, t1, d0, d1, sem, name0, name1):
    parts = [
        "<!DOCTYPE html><html><head><meta charset=\"utf-8\">",
        f"<title>去AI味报告 · {esc(name0)}</title><style>{CSS}</style></head><body>",
        f"<h1>去AI味 · 前后对比报告</h1>",
        f'<p class="small">{esc(name0)} → {esc(name1)}</p>',
        '<div class="legend">图例：<span class="chg">红色</span> = 改后的新文字；'
        '<span class="del">灰色删除线</span> = 被改掉/删掉的原文；'
        '指标表 ↓/↑ = 相对人类参考的改善/恶化。</div>',
        "<h2>一、指标前后对比</h2>",
        metric_table(d0, d1),
        semantic_section(sem),
        "<h2>二、分级问题清单（改前检测）</h2>",
        findings_section(d0),
        '<p class="small">C 级（结构/节奏）见指标表；F 指纹见表内指纹行；'
        "比喻贴切度只能人审；本轮默认保留。用户主动要求时再列出相关原句供判断。</p>",
        "<h2>三、标红前后对照</h2>",
        diff_section(t0, t1),
        "</body></html>",
    ]
    return "\n".join(parts)

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("before", help="改前文本文件")
    ap.add_argument("after", help="改后文本文件")
    ap.add_argument("json_before", help="改前 detect --json 输出")
    ap.add_argument("json_after", help="改后 detect --json 输出")
    ap.add_argument("--semantic", help="语义判读结果 JSON（候选+label 字段）")
    ap.add_argument("--format", choices=["md", "html"], default="md",
                    help="报告格式：md=Markdown（默认，与文稿同格式可复制），html=单文件网页")
    ap.add_argument("--out", default=None,
                    help="输出路径；默认按格式取名 去AI味报告.md / .html")
    args = ap.parse_args()

    t0 = Path(args.before).read_text(encoding="utf-8", errors="ignore")
    t1 = Path(args.after).read_text(encoding="utf-8", errors="ignore")
    d0 = json.loads(Path(args.json_before).read_text(encoding="utf-8"))
    d1 = json.loads(Path(args.json_after).read_text(encoding="utf-8"))
    sem = None
    if args.semantic:
        sem = json.loads(Path(args.semantic).read_text(encoding="utf-8"))

    out = args.out or f"去AI味报告.{args.format}"
    if args.format == "md":
        page = build_report_md(t0, t1, d0, d1, sem, args.before, args.after)
    else:
        page = build_report(t0, t1, d0, d1, sem, args.before, args.after)
    Path(out).write_text(page, encoding="utf-8")
    n_han = lambda t: len(re.findall(r"[一-鿿]", t))
    print(f"报告 → {out}（改前 {n_han(t0)} 字 / 改后 {n_han(t1)} 字，"
          f"变化 {n_han(t1) - n_han(t0):+d}）")

if __name__ == "__main__":
    main()
```

## File: references/semantic-criteria.md
size: 8540
sha: 2683e24526ce538d98149557046c0e965241fe99
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/references/semantic-criteria.md

```text
# 语义层判据（四项）

检测分三层分工：数得出符号的归脚本（detect.py），要理解句意的归语义层（本文件，由会话内 Claude 逐条判断），机器间共识不够的归人审（比喻贴切度，见 SKILL.md 人审区）。

用法：先跑 `python3 scripts/detect.py <文件> --candidates --out <候选.json>`，对候选里的每一条按对应判据给出封闭标签（只能从判据列出的标签中选）+ 置信度（高/中/低）+ 一句话理由。判断完把 `label`/`confidence`/`reason` 三个字段写回该条候选，供 report.py 汇总。

**判断纪律**（来自 43 万次打标的教训）：
- 只按判据判，不按「像不像 AI」的整体感觉判——整体印象会被文风糊弄
- 每条独立判断，不看全文来源（候选里故意不给全文，防止模型靠整体文风猜）
- 拿不准就选判据里的兜底标签，不硬判
- 标签只能从该条判据列出的集合中选，禁止自造标签

---

## 1. 同义重命名（段级）——第一层第 2 条，最强可操作信号

**背景**：同一实体/概念在段内换实义说法，读者要做「X 就是 Y」的等同连接。AI 0.83-0.86 次/段 vs 人类 0.49；≥2 次的重灾段 AI 20.6-22.5% vs 人类 8.4%。**证据注记：Jev 单模型一轮判据，跨模型同向但判据未迭代，稳健性弱于其他三项，复测时优先重跑。**

**候选**：每段一条（`para` 字段）。

**判据**（对每段数「换实义说法」的连接次数；代词、省略不算）：

| 标签 | 判据 |
|---|---|
| 0组 | 段里每个实体/概念从头到尾用同一个（或字面几乎相同的）说法指称，或只出现一次，不存在换说法 |
| 1组 | 有一个实体/概念在段内换了 1 次实义说法，读者需要做 1 次「X 就是 Y」的等同连接 |
| 2组 | 有两个实体/概念各换了说法，或同一个换了 2 次 |
| 3组及以上 | 换说法的连接次数 3 次或更多 |
| 无法判断 | 段落无法分析 |

**典型例**：同一段里「优化／增强／提升／提高」轮着用；「版图→基地→项目→节点→本地制造安排」五个名字叫同一个电池工厂项目。人类会反复用同一个词。

**改写方向**（确认后）：同义链统一回原名词——零信息损失，人类范本即反复用原名的写法。

---

## 2. 衔接方式（段间接口）——第一层第 7 条

**背景**：AI 段段紧扣（明确承接 98.9% vs 人类 95.2%），人类自然跳跃（主题跳转 7.2% vs AI 2.1%）。真正差异不是承接词频率（两侧都低，无害），是**零跳转的背景概率**：≥6 连环 AI 93% 的文章有。连环数的是接口数不是段落数。

**候选**：每个段间接口一条（`prev_tail` = 上段末句，`next_head` = 下段首句）。

**判据**（判 a=prev_tail 到 b=next_head 的衔接方式；若 b 句首有连接词，先检查连接词标示的逻辑关系是否真的成立）：

| 标签 | 判据 |
|---|---|
| 表面有连接词实际关系不清 | b 开头用了连接词（但是/因此/于是/与此同时等），但读完 b 会发现连接词标示的逻辑关系并不成立或很勉强。**优先检查这一条** |
| 明确承接 | 前后围绕同一对象或同一论述关系继续展开，衔接自然，允许用同义词、代词、省略，不要求重复字面词语；有连接词时其逻辑关系也确实成立 |
| 有关但转换突然 | 前后确实有关联（同一话题域），但衔接方式突兀，中间缺了一步过渡，读者需要自己补上跳过的逻辑 |
| 主题跳转缺少说明 | b 换到了和前面基本不相关的新话题，没有任何衔接说明 |
| 无法判断 | 上下文不足以判断 |

**统计口径**：连续「明确承接」的接口数为连环长度；≥6 连环即报告（AI 短文中位 7 连环 vs 人类 2）。

**改写方向**（确认后）：在连环中选 1-2 个接口改成自然跳跃/断裂（人类话题跟着信源走，不替读者预先铺垫）；有连接词但不成立的接口优先处理。

---

## 3. 冒号分类——第一层第 6 条

**背景**：冒号总量人类反而多（δ−0.37/−0.31），只有「结论提示」子类是 AI 2.1-2.2 倍的真信号；「空转提示」反向（人类多一个量级）。

**候选**：正文每个冒号句一条（`colon_before` / `colon_after` / `sentence`）。

**判据**（按优先级从上往下判，命中即停）：

| 标签 | 判据 |
|---|---|
| 引语或人物发言 | 冒号前是人名/称呼+访谈体发言格式，或有「说/表示/写道/提出/宣布」等引出言论的词且紧跟该人物主语。**优先于其他类别** |
| 标题时间比例元数据或版式用途 | 冒号前是标题结构/时间戳/比例数字/来源作者等版式元数据（访谈体「人名：发言」不算，那属上一类） |
| 定义或解释 | 冒号前是术语/概念/功能名称，冒号后给出该术语的定义或具体内容 |
| 空转提示 | 冒号前只是空洞宣布「下面有几点」，不含论断，冒号后是纯列举。**已否决项：人类更多，不改** |
| 结论提示 | 冒号前给出一句独立、明确的结论性判断（含「是/在于/取决于/意味着」等论断谓语），冒号后是对这个结论的展开论证。**唯一真信号** |
| 其他正文冒号 | 不属于以上任何一类的正文冒号，默认落点 |
| 无法判断 | 上下文不足以判断。不要为了给出答案而滥用这一类 |

**典型例**：「这组数字传递出一个残酷的现实：……」——结论宣告+展开。

**改写方向**（确认后，只动「结论提示」类）：删提示语直接写内容，或前半句承接上文时只换标点。

---

## 4. 高度同构三连——第二层（指纹，证据强度弱于第一层）

**背景**：连续三句共用同一句式骨架。宽口径（结构相近即算）无区分力（AI 71.1% vs 人类 56.2%），只有**高度同构**档有 2.76× 差异（AI 29.4% vs 人类 10.7%）——AI 是排得更极端（骨架逐字复刻），不是更爱排比。三连里仅 30% 含顿号列举，七成是三连问句/同款长句的纯句法复用。

**候选**：signature 粗筛出的连续三句组（`sents` 字段三句原文）。粗筛宽（部分同构也收），判读收紧。

**判据**（只判这一组三句，不给全文）：

| 标签 | 判据 |
|---|---|
| 高度同构 | 三句的主语、谓语、宾语、补充成分在句子里的位置基本一一对应，句法框架几乎相同，只是填入的具体词不同 |
| 部分同构 | 句法结构有明显相似（比如都用了同样的主谓框架），但只是部分对应，不是每个成分都对得上，或多出/缺了一部分成分 |
| 只有词语重复句法不同 | 句子间重复了某些词或短语，但整体句法组织（谁是主语、谓语怎么摆放）并不相同 |
| 只有语义并列句法不同 | 句子间只是在内容/意思上构成并列关系（讲的是同类的几件事），但句法结构不同 |
| 无同构关系 | 句法与语义并列上都没有明显的重复或对应关系 |
| 无法判断 | 上下文不足以判断，或句子残缺 |

**典型例**：「叫什么名字？／承载什么功能？／嵌入哪个生态？」——句首各异骨架同款。「服务网络能不能覆盖到我春节回老家的那段路？／车的残值能不能经得起检验？／这家公司出了问题谁来管？」——三连问句。

**改写方向**（确认后）：拆掉其中一句（打破骨架复用），不是删掉一项内容。与顿号罗列分界：顿号管句内塞多项，本条管句间共用骨架。

---

## 汇总口径

判断完四类后按以下口径汇总进报告：

| 指标 | 计算 | 人类参考 | AI 参考 | 显著门槛 |
|---|---|---|---|---|
| 同义重命名 次/段 | Σ(各组标签数) / 段数 | 0.49 | 0.83-0.86 | ≥0.7 或重灾段（≥2组）占比 >15% |
| 衔接连环 | 最长连续「明确承接」接口数 | 中位 2 | 中位 7 | ≥6 连环 |
| 结论冒号占比 | 结论提示 / 正文冒号总数 | 低 | 2.1-2.2× 人类 | 相对比例高即列 B 级 |
| 高度同构三连数 | 「高度同构」标签计数 | 10.7%（占三连组） | 29.4% | 绝对数 ≥2 组即列 B 级 |

四项在 270 对配对语料统计显著（同义重命名为 Jev 单模型判据，稳健性弱于其他三项）。改写仍走 SKILL.md 的白名单+确认流程。
```

## File: assets/less-ai-tone-hero-en.png
size: 1526380
sha: 038fdbc58fced3a2cc5ab3c199fc8089cbadb11a
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/assets/less-ai-tone-hero-en.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/assets/less-ai-tone-hero-en.png

## File: assets/less-ai-tone-hero-zh.png
size: 1541148
sha: 45f0e681ec00cdd6b850d3fd668a1b97817ffe0e
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/assets/less-ai-tone-hero-zh.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/assets/less-ai-tone-hero-zh.png

## File: .gitignore
size: 151
sha: 7454f9acc511340fdd8e4497a20591eaffb49e0a
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/.gitignore

```text
.DS_Store
__pycache__/
*.pyc

# 语料不入库：可能含版权或隐私内容
corpus/
raw-corpus/
*-corpus/
ai-control-group*/
ai-samples/
private/
```

## File: DETECT.md
size: 6947
sha: 693038f5f9fd016e87f8a86df2912d78eb862394
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/DETECT.md

````text
# 检测协议（去AI味 v2 第一步）

本文定义检测阶段做什么、不改什么。改写规则见 [SKILL.md](./SKILL.md)。

## 为什么先检测再改写

两个原因，都来自实测。

一，AI 味的大部分特征是**分布特征**（句长均匀、节长均匀、用词不敢重复），单看一处看不出来，也不该逐处改。逐句"制造参差"会把文章改坏，这类特征只能整篇决策：要么用户接受结构级改写，要么不动。

二，第一版 skill 的教训：一次性改写时，模型倾向于把"感觉像 AI 味"的东西都动一遍，包括实测根本不是 AI 味的特征（序数词小标题、正文设问、比喻），改完反而更不像人写的。先交付有指标、例句和改法的报告，等用户回复后再动手，是防过度清理的闸门。

## 三层分工

检测不是一个脚本包打天下，是三层各管一段（方法论来自 43 万次打标的实验结论）：

| 层 | 管什么 | 谁 | 载体 |
|---|---|---|---|
| 脚本层 | 数得出符号的（正则命中、标点密度、结构 CV、mtld） | detect.py | 本文件 |
| 语义层 | 要理解句意的（同义重命名、衔接连环、冒号分类、同构三连） | 会话内模型 | [references/semantic-criteria.md](./references/semantic-criteria.md) |
| 人审层 | 机器间共识不够的（比喻贴切度、暗喻、拟人化喻体） | 用户 | SKILL.md 人审区 |

语义层原理：脚本先抽候选（每段、每个段间接口、每个冒号句、signature 粗筛的三连组），模型对每条候选按封闭判据判标签。正则只能命中固定表面形式，命中不了「同一个意思的不同写法」；但模型判「像不像 AI」带自我偏好，所以判据必须是封闭标签集+逐条独立判断，不允许整体感觉打分。

## 运行

```bash
python3 scripts/detect.py <文件或目录> [--max-hits 5] [--json]     # 脚本层
python3 scripts/detect.py <文件> --candidates --out 候选.json        # 语义层候选抽取
python3 scripts/report.py 原文 改后 before.json after.json \
    [--semantic 判读后.json] --out 报告.md                          # 默认 Markdown 前后对比
```

输出一份分级报告：

| 级 | 含义 | 改写策略 |
|---|---|---|
| **A 机械改** | 固定句式/标点，改动不触碰语义 | 模型复核误报后给出建议；用户回复后改 |
| **B 建议改** | 需句式重组或换说法 | 模型逐条筛选，报告典型例句和改法；用户回复后改 |
| **C 只报告** | 结构/节奏，超出白名单 | 默认不改；用户主动要求时再处理 |
| **H 人审区** | 模型判不准贴切度的（拟人化喻体；比喻/暗喻同理） | 默认保留；用户主动要求时再列清单 |
| **X 已否决** | 实测不是 AI 味（配对复测反向） | 永不改，报告里出现是为了防止误改 |
| **F 指纹** | 分模型特征（破折号/分号/引号） | 可定位且能安全改写的命中默认建议改；保留须给具体理由，密度用于排序，见 SKILL.md 指纹节 |

## 分级依据

分级不看特征强度，看**改动风险**：改这一处会不会碰到语义、会不会需要补信息、会不会越界。

- 删「说白了」零语义损失 → A。
- 打散顿号罗列要重排成分 → B。
- 句长均匀是整篇属性，逐句改必然过度 → C，只提示。
- 序数词小标题在第一轮实测是 3.1 倍 AI 味，270 对配对复测**方向反转**（人类 8.6% vs AI 4.9%）→ X。第一版按旧数据把它列为规则 6，v2 删除。
- 概括替代曾按语义层 24.7% 列为 v2 规则 9（同段有数则恢复数值），2026-10-13 对称口径复查**净零**（AI 更含糊 24.7% vs 更具体 26.0%）→ X。整条撤销，同段有具体数值也不改。

## X 级清单的来源（v1 → v2 的规则变动）

| v1 规则 | v1 依据（629 篇不配对） | 配对复测（270 对同题同事实） | v2 处置 |
|---|---|---|---|
| 规则6 序数词小标题 | AI 0.19 vs 人类 0.06，3.1× | **反转**：人类 8.6% vs AI 4.9% | 降为 X，不改 |
| 「这意味着」复述 | 翻译腔收录，2.6-5.3× | **反向**：人类 0.027 vs AI 0.016 每千字 | 降为 X，不改 |
| 空转句引列表 | 冒号滥用之一，9.4× | **反向**：人类高一个量级（目录式长文常态） | 降为 X，不改 |
| 规则8 材料密度 | 数字密度人类 2.8 倍 | 配对后 δ=−0.06 **无差异**；24.7% 概括替代后被对称口径复查否决（净零） | 再否决：v2 曾重写为"概括盖住同段数值"，2026-10-13 整条撤销，降 X |
| 规则4 破折号 | AI 2.38 vs 人类 0.80，3× | 分模型极端分化：GPT −0.54 / Opus +0.95 | 降级为 F 指纹；>2/千字优先处理，低密度仍逐处检查 |

其余 v1 规则（翻案腔、顿号罗列、相邻句同构、提示语冒号、拟人喻体、起手式、翻译腔四种）在配对复测中方向不变、量级相当，全部保留。

## 报告怎么读

脚本输出是**候选数据**，不是直接发给用户的结论。模型逐条复核后，改前报告要把“本篇命中 → 研究参照 → 例句 → 改法”连起来讲清楚。复核不得静默删除候选：对第一层、第二层中能定位到句子的指标列原始命中数、有效命中数、拟改数和保留数；误报与语义判读阴性也要留下数量和理由，若输入是文件则保存逐条结果。整篇分布指标只报实测值，不强造逐句命中数。研究语料中显著，不等于单篇文章完成了统计显著性检验；不得据此判定作者是 AI。

1. **A、B 与语义层四项**：先看本篇次数、密度或门槛，再看人类参考和配对复测证据。对拟处理的项给出可定位的原句与具体改法；脚本误报要剔除。
2. **X、F 与 C/H**：说明已否决特征、模型指纹、结构指标或比喻的去向。F 不推断文章来源模型；可定位且能安全改写的命中默认建议改，保留须说明该处的具体作用。C/H 按整篇指标与人审约束处理。
3. **口径核对**：不同轮次的指标定义或分母不同时，不能混算倍数。同义词轮换的脚本命中只是启发式，精判走语义层同义重命名。
4. **用户回复**：报告给出整套建议后停下。用户回复接受或调整方案，再进入改写；不要求逐条勾选。

## 检测层做不了、必须留给人的判断

- 比喻贴不贴切（模型间共识只有 0–40%，人审是唯一通道）；暗喻、拟人化喻体 2026-10-26 起并入人审区，不做候选判读
- 三个并列案例是否在凑数（叙事推进不算，要看语义）
- "参差"是否有质量——机械长短交替和自然节奏脚本分不开（v2.1 计划加句长序列自相关检查）
- 段首零主语评论不再检测（2026-10-26 裁定：第三层弱信号，与已反转的「句间指代不清」同族）
````

## File: examples/agent-memory-case/00-原稿.md
size: 9552
sha: bdf74fea68c9738a63fd45abcd39775b71d2cb27
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/00-%E5%8E%9F%E7%A8%BF.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/00-%E5%8E%9F%E7%A8%BF.md

## File: examples/agent-memory-case/01-改前检测与修改建议.md
size: 5380
sha: a914369dd1f6f53e53922c52fcf81925f565db45
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/01-%E6%94%B9%E5%89%8D%E6%A3%80%E6%B5%8B%E4%B8%8E%E4%BF%AE%E6%94%B9%E5%BB%BA%E8%AE%AE.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/01-%E6%94%B9%E5%89%8D%E6%A3%80%E6%B5%8B%E4%B8%8E%E4%BF%AE%E6%94%B9%E5%BB%BA%E8%AE%AE.md

## File: examples/agent-memory-case/02-改后全文.md
size: 9514
sha: 8cfdd01cb1702b9e96040700766938d778897f76
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/02-%E6%94%B9%E5%90%8E%E5%85%A8%E6%96%87.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/02-%E6%94%B9%E5%90%8E%E5%85%A8%E6%96%87.md

## File: examples/agent-memory-case/03-左右对照.html
size: 53131
sha: a2a56efb4b3765fc778ddd273e19769ff8e61e5a
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/03-%E5%B7%A6%E5%8F%B3%E5%AF%B9%E7%85%A7.html

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/03-%E5%B7%A6%E5%8F%B3%E5%AF%B9%E7%85%A7.html

## File: examples/agent-memory-case/04-复测结论.md
size: 1777
sha: 35f89c2628d9ef8d1886d4413a3ac3b4fe756280
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/04-%E5%A4%8D%E6%B5%8B%E7%BB%93%E8%AE%BA.md

```text
# 阶段三｜改后复测结论

本轮只改了 11 个段落。标题、段落顺序、分类清单、人物引文、关键数字和三个记忆层级保持原样。以下数字来自同一版 `detect.py` 对原稿与改稿的检测；它们是辅助检查，不等于文章质量分数。

| 检查项 | 改前 | 改后 | 复核结论 |
|---|---:|---:|---|
| “不是 A 而是 B”对举 | 2 处 | 0 处 | 两处套式转折已处理，原意保留。 |
| 密集并列 | 10 处 | 4 处 | 正文 6 处已处理；剩余 4 处在文件分类清单内，按规则保留。 |
| 提示语冒号（脚本粗筛） | 3 处 | 2 处 | 剩余是标题和普通引入句；语义判读认定的 4 处结论提示冒号已逐一改写。 |
| 过长前置定语（脚本粗筛） | 1 处 | 1 处 | 开头一句是误报，不为了清零硬改。 |
| 相邻句同构 / 百段 | 8.7 | 4.35 | 第 45 行三句比喻的句法已打散，喻体保留。 |
| 三句同构 / 百段 | 2.17 | 0 | 原来的高度同构三连已处理。 |
| 句长起伏（CV） | 0.559 | 0.545 | 变化很小，没有刻意制造长短参差。 |

## 人工复核

- 原稿与改稿均为 96 行；11 行发生变化，章节和段落位置未变。
- 10 小时、30 美元、9 分钟、0.9169、约 0.68、最近 7 天、79%、40–50 万日元等关键数字仍在改稿中。
- “这意味着什么”、清单引子和小标题编号按规则保留。比喻与引文本轮未作为待清除对象。
- 脚本把纯文本小节标题记为“0 个小标题”；原文实际有“01”至“04”和“最后”。因此不要用该指标判断本文有没有结构。

阅读具体改动请打开 [左右对照页](03-左右对照.html)；需要复制成稿请使用 [改后全文](02-改后全文.md)。
```

## File: examples/agent-memory-case/数据-改前检测.json
size: 3442
sha: 0a48a16411100a49310a3d14565e0a7e97cd2867
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/%E6%95%B0%E6%8D%AE-%E6%94%B9%E5%89%8D%E6%A3%80%E6%B5%8B.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/%E6%95%B0%E6%8D%AE-%E6%94%B9%E5%89%8D%E6%A3%80%E6%B5%8B.json

## File: examples/agent-memory-case/数据-改后复测.json
size: 2551
sha: ecd6da57a7672769af6e06c3e3962d8866e70919
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/%E6%95%B0%E6%8D%AE-%E6%94%B9%E5%90%8E%E5%A4%8D%E6%B5%8B.json

```text
{
 "meta": {
  "篇数": 1,
  "万汉字": 0.26,
  "段数": 46,
  "小标题数": 0
 },
 "density": {
  "翻案腔": 0.0,
  "提示语冒号": 0.765,
  "起手式": 0.0,
  "当…时从句": 0.0,
  "前置话题壳": 0.0,
  "句首连接词": 0.0,
  "顿号并列≥3": 1.53,
  "过长前置定语": 0.383,
  "拟人化喻体": 0.0,
  "概括替代(已否决)": 0.0,
  "序数词小标题(已否决)": 0.0,
  "「这意味着」复述(已否决)": 0.383,
  "空转句引列表(已否决)": 0.765
 },
 "char_density": {
  "破折号": 3.06,
  "分号": 0.765,
  "引号": 0.0
 },
 "hits": {
  "翻案腔": [],
  "提示语冒号": [
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 1,
    "excerpt": "问题："
   },
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 63,
    "excerpt": "问题："
   }
  ],
  "起手式": [],
  "当…时从句": [],
  "前置话题壳": [],
  "句首连接词": [],
  "顿号并列≥3": [
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 67,
    "excerpt": "料（raw）——用户访谈原话、数据截图、外部文章原文"
   },
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 68,
    "excerpt": "ed）——基于原始材料的分析、调研、思考"
   },
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 70,
    "excerpt": "space）——PRD 草稿、会议记录、RFC"
   },
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 70,
    "excerpt": "它们会\"毕业\"（上线、定稿、归档）"
   }
  ],
  "过长前置定语": [
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 3,
    "excerpt": "一个日本音乐人花了 10 小时向 AI 倾诉她的全部计划"
   }
  ],
  "拟人化喻体": [],
  "概括替代(已否决)": [],
  "序数词小标题(已否决)": [],
  "「这意味着」复述(已否决)": [
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 21,
    "excerpt": "这意味着"
   }
  ],
  "空转句引列表(已否决)": [
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 35,
    "excerpt": "现在的做法是分三层来解决："
   },
   {
    "file": "Agent的记忆问题_去AI味版.md",
    "line": 65,
    "excerpt": "在内部把团队空间里的所有文件按可信度分了四层："
   }
  ]
 },
 "syn_hits": [],
 "structure": {
  "句长CV": 0.545,
  "节长CV": null,
  "小标题/千字": 0.0,
  "两句同构/百段": 4.35,
  "三句同构/百段": 0.0,
  "mtld粗估": 1528
 }
}
```

## File: examples/agent-memory-case/数据-语义判读.json
size: 43691
sha: c4a60741039936d21a478d1ab5f78b31d38a4695
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/%E6%95%B0%E6%8D%AE-%E8%AF%AD%E4%B9%89%E5%88%A4%E8%AF%BB.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/examples/agent-memory-case/%E6%95%B0%E6%8D%AE-%E8%AF%AD%E4%B9%89%E5%88%A4%E8%AF%BB.json

## File: LICENSE
size: 1739
sha: 85c9318824c689434773c7897adf8e3bedb556dd
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/LICENSE

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/LICENSE

## File: README.en.md
size: 5715
sha: 36dd6d9fb15fe042eb6533ee4572903ba032f1ec
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/README.en.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/README.en.md

## File: RESEARCH.en.md
size: 25333
sha: 9c11150060e93d104b6d418e2933d9d33e047577
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/RESEARCH.en.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/RESEARCH.en.md

## File: RESEARCH.md
size: 24986
sha: 5689ef908cb6f55bd17e9ac857feb898c7099a9d
upstream: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/RESEARCH.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/larashero3-dotcom/lieflat-less-ai-tone/blob/HEAD/RESEARCH.md
