@topmindspace/topmind-skills 4.14.0 → 4.15.0

package/evals/evals.json

@@ -1,7 +1,7 @@
 {
   "skill_name": "topmind",
   "daily_entry": "topmind",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "evals": [
     {
       "id": 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topmindspace/topmind-skills",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "topmind Agent Skills pack — portable markdown skills for capture, organize, write, memory, maintain, loop.",
   "type": "module",
   "license": "MIT",

package/shared/auto-suggest.md

@@ -65,8 +65,10 @@ Host 能力映射：
 | 能力 | Desktop | UTR | 纯 Host Agent |
 |------|---------|-----|---------------|
 | 提取 | `add_todo` · `todo_maintain` | `memory.add-todo` | 读活动窗口 → 识别行动语 → 写 checklist |
-| 维护 | `toggle_todo` · `maintainTodos` | `memory.toggle-todo` | 对照周期本与 todo.md 做 diff 建议 |
+| 维护 | `toggle_todo` · `update_todo` · `set_todo_due` · `delete_todo` · `maintainTodos` | `memory.toggle-todo` | 对照周期本与 todo.md 做 diff 建议 |
 | 列表 | `list_todos` · Todo 面板 | `memory.list-todos` | 读 `memory/todo.md` 活跃段 |
+| 动态查询 | `list_recent_stream` | `workspace-read.list-recent-captures` | 读最近周期本日段 |
+| 记忆查询 | `list_recent_memories` | `memory.list-profile` 等 | 读 `memory/` 活跃段（勿整库倾倒） |
 | 分类/专题建议 | `topic_classify`（确认后 `create_topic`） | 文件工具 + role 路由 | 按 role + 内容性质给最多 3 候选 |
 | 记忆建议 | `memory_organize`（append/update/retire 建议） | `memory.append-profile` 等（确认后） | 识别稳定事实 → L1 候选 |
 

package/shared/long-url-capture.md

@@ -74,6 +74,9 @@ word_count: 1200
 - URL 类型提示（GitHub README / GitHub 原文 / X / 网页）  
 - Inbox：按 `source_type` 筛选「网页/摘录」  
 - AI `fetch_url` 支持 `maxLen` + `render`；Obsidian `fetch_url` 对 GitHub md 自动走 raw  
+- AI `capture_url`：一键抓取并入库（带 source URL + 标题）；Desktop 与 Obsidian 对齐（`forceInbox` / `forceAtom`）  
+- AI `web_search`：无需 Key 的网络搜索短列表（域名打分 + 同域去重）；命中后 `fetch_url` / `capture_url`  
+- 工具失败会返回**一条**具体恢复步骤（如 edit 失败 → 先 read_file 刷 contentHash）
 
 ## 不要做的事
 

package/shared/trigger-disambiguation.md

@@ -9,6 +9,8 @@
 |--------|--------------|------|
 | 总结要点 | organize vs memory | 默认 → `topmind-organize`。仅「更新我的情况 / 加到专题记忆 / 沉淀到记忆」→ memory |
 | 沉淀 | capture vs memory | 默认 → `topmind-capture`。仅「沉淀成稳定结论 / 更新我的情况」→ memory |
+| **记一下 / Note it** | capture 主入口 | **完整捕获**（笔记 / 链接 / 附件）→ `topmind-capture` |
+| **记下 / Log it** | capture（追加） | **写入当前周期本**（动态追加，同文件续写）→ `topmind-capture`，默认平铺到当前周期；不弹分类访谈 |
 | 记一下要做 X / 别忘了 X | capture vs todo | → `topmind-capture`（材料落盘）+ 待办写入/建议 `memory/todo.md`（见 `auto-suggest.md`） |
 | 待办 / 有什么要做的 | router 直达 | 读 `memory/todo.md` 活跃项；不新建概念、不进 organize |
 | X 做完了 / 这条不用了 | todo vs organize | 清单项 → 勾掉/归档 `memory/todo.md`；整周事项状态 → organize「整理本周」 |

package/topmind/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind
-version: 4.14.0
+version: 4.15.0
 description: >-
   topmind 总入口与多意图路由（类别/专题/笔记/待办/交付）。Use when 用户说 topmind、意图模糊、
   待办/有什么要做的/todo list、或需要收→整→写 分步。单意图明确时直接用 topmind-capture|organize|write|memory|maintain|loop|weread|x|ledger|wechat。
@@ -139,7 +139,7 @@ Connector：[`references/connector-resolution.md`](references/connector-resoluti
 主路径：host 文件工具 + project-model-brief。Skills pack **不依赖** Pi / `pi-agent-core`；不要编造 bash / shell。宿主若有唯一片段替换，中段改稿优先用它。  
 降级：[`../shared/capability-degradation.md`](../shared/capability-degradation.md)。
 
-UTR 可选（MCP primary+danger 共 26；注册表 35 = 8 域 / 35 命令，见 TOOLS.md）：`list-categories` · `list-topics` · `inspect-topic` · `list-topic-files` · `list-inbox` · `create-topic` · `capture-note` · `save-output` · `contract.validate` · `contract.reseed` · `memory.promote` · `memory.digest` · `memory.append-profile` · `memory.append-topic` · `memory.retire-profile` · `memory.update-profile` · `memory.compact-history` · `memory.restore-profile` · `memory.list-todos` · `memory.add-todo` · `memory.toggle-todo` · `doctor-workspace` · `plan-inbox-routing` · `archive-topic` · `archive-stream-year` · `restore-safety-receipt`。
+UTR 可选（MCP primary+danger 共 29；注册表 38 = 8 域 / 38 命令，见 TOOLS.md）：`list-categories` · `list-topics` · `inspect-topic` · `list-topic-files` · `list-inbox` · `create-topic` · `capture-note` · `save-output` · `contract.validate` · `contract.reseed` · `memory.promote` · `memory.digest` · `memory.append-profile` · `memory.append-topic` · `memory.retire-profile` · `memory.update-profile` · `memory.compact-history` · `memory.restore-profile` · `memory.list-todos` · `memory.add-todo` · `memory.toggle-todo` · `memory.update-todo` · `memory.set-todo-due` · `memory.delete-todo` · `doctor-workspace` · `plan-inbox-routing` · `archive-topic` · `archive-stream-year` · `restore-safety-receipt`。
 
 字段始终独立 **`category` + `topic`**（真实目录名，非写死编号）。
 

package/topmind/references/multi-intent.md

@@ -1,12 +1,12 @@
 # Multi-Intent Resolution
 
-当用户请求包含多个意图时，按以下矩阵裁决（与 `shared/trigger-disambiguation.md` 一致）：
+当用户请求包含多个意图时，按以下矩阵裁决（与 `../../shared/trigger-disambiguation.md` 一致）：
 
 | 意图组合 | 裁决 | 说明 |
 |---------|------|------|
 | capture + organize | 先 capture，回执中建议 organize | 先确保材料落地 |
 | capture + memory | 先 capture，回执中建议 memory | 先存笔记再更新我的情况 / 周期反思 |
-| capture + todo | 先 capture；显式行动语同轮写 `memory/todo.md`，隐含则 L1 建议 | 见 `shared/auto-suggest.md` |
+| capture + todo | 先 capture；显式行动语同轮写 `memory/todo.md`，隐含则 L1 建议 | 见 `../../shared/auto-suggest.md` |
 | organize + write | 先 organize 提炼，再 write 输出 | 分两步 |
 | organize + memory | 先 organize 候选，再 memory 落盘 | organize 产出列表 |
 | organize + todo | 整理本周后 L1 待办 diff 建议 | 不自动批量改清单 |

package/topmind-capture/SKILL.md

@@ -1,9 +1,10 @@
 ---
 name: topmind-capture
-version: 4.14.0
+version: 4.15.0
 description: >-
-  把链接、摘录、随手记收进动态周期本、Inbox 或专题；行动语自动提取/建议待办。Use when 记一下、收进、
-  剪藏、保存链接、记一下要做/别忘了、capture、save URL/idea。
+  把链接、摘录、随手记收进动态周期本、Inbox 或专题；行动语自动提取/建议待办。Use when 记一下、
+  收进、剪藏、保存链接、记一下要做/别忘了、capture、save URL/idea、Note it。
+  记下/Log it 是动态主区「写入当前周期本」——路由仍进本 skill，但不作 frontmatter 触发词（见 shared/trigger-disambiguation.md）。
   Do NOT use for 整理本周、出稿、写我的情况、doctor/loop、微信读书、X.
 action_category: capture
 triggers:
@@ -30,6 +31,7 @@ triggers:
   - capture
   - note
   - save
+  - "Note it"
 tags: [capture, inbox, note, material]
 entrypoint: false
 compatibility: topmind workspace. Host file tools or optional UTR capture-note.

package/topmind-ledger/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-ledger
-version: 4.14.0
+version: 4.15.0
 description: >-
   通用记账到记忆平面（默认个人/自己账本，用户自建账本与分类）。Use when 记账、记一笔、花了、存入、查看账单、账户余额。
   Do NOT use for 记一下到动态、待办、微信读书、发推、Feishu/lark-cli.

package/topmind-loop/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-loop
-version: 4.14.0
+version: 4.15.0
 description: >-
   可中断的工作区语义巡检（走专题/Inbox，.loop 断点续跑）。Use when 跑一遍 loop、巡检、整体体检、复盘、
   继续 loop、audit。Do NOT use for 快速 doctor（→maintain）、单专题整理、捕获、写作、仅记忆.

package/topmind-maintain/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-maintain
-version: 4.14.0
+version: 4.15.0
 description: >-
   确定性体检/清理/结构修复/回执恢复。Use when 快速体检、诊断、doctor、清理、修复、workspace check。
   Do NOT use for 整体巡检 loop、内容整理、捕获、写作、记忆.

package/topmind-memory/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-memory
-version: 4.14.0
+version: 4.15.0
 description: >-
   更新「我的情况」或周期反思。Use when 记住这个、更新我的情况、加到专题记忆、沉淀结论。
   Do NOT use for 捕获、仅总结（→organize）、整理本周正文、出稿、开/并专题、doctor/loop.

package/topmind-organize/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-organize
-version: 4.14.0
+version: 4.15.0
 description: >-
   整理本周动态、专题内整理/研究/分析/路由 Inbox。Use when 整理本周、整理、分析、研究、对比、总结要点、organize、summarize。
   Do NOT use for 首次捕获、最终出稿、仅写我的情况、快速 doctor、全库 loop.

package/topmind-pack.json

@@ -4,7 +4,7 @@
   "label": "topmind",
   "description": "topmind skill pack: single daily entry topmind + progressive disclosure (shared/ + references/), Agent Skills open-standard aligned, capture-first template-driven categories, optional connectors topmind-weread and topmind-x, optional topmind-ledger (记账), optional write sub-skill topmind-wechat. None of the optional skills is an extra user concept. File-system-first content truth; UTR optional.",
   "daily_entry": "topmind",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "updated": "2026-09-28",
   "license": "MIT",
   "locales": {
@@ -382,7 +382,10 @@
         "restore-profile",
         "list-todos",
         "add-todo",
-        "toggle-todo"
+        "toggle-todo",
+        "update-todo",
+        "set-todo-due",
+        "delete-todo"
       ],
       "lifecycle": [
         "scan"
@@ -391,8 +394,8 @@
         "rebuild"
       ]
     },
-    "command_count": 35,
-    "mcp_default_count": 26,
+    "command_count": 38,
+    "mcp_default_count": 29,
     "command_exposure": {
       "primary": [
         "workspace-read.list-categories",
@@ -416,7 +419,10 @@
         "memory.restore-profile",
         "memory.list-todos",
         "memory.add-todo",
-        "memory.toggle-todo"
+        "memory.toggle-todo",
+        "memory.update-todo",
+        "memory.set-todo-due",
+        "memory.delete-todo"
       ],
       "danger": [
         "workspace-maintain.archive-topic",

package/topmind-wechat/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-wechat
-version: 4.14.0
+version: 4.15.0
 description: >-
   公众号文章全生命周期子技能（write 族）：交付包、审校改写、质量三关、状态同步、微信内联排版与发布清单。
   支持 forward（底稿→公众号）、reverse（选题原创→回推）、站外拉取（在线精选站→reverse+pending）三条路径；
@@ -49,14 +49,15 @@ compatibility: topmind workspace. Writes via UTR workspace-write / Desktop Works
 | `scripts/push-to-topstream.py` | 可选回推：公众号稿降级为纯 Markdown notes |
 | `scripts/lint-wechat.py` | 排版体检 + 自动修复（中英文间距、段长、AI 腔…） |
 | `scripts/md2wechat.py` | Markdown → 全内联 HTML；**必加 `--embed-images`** |
-| `scripts/scan_ai_flavor.py` | 中文去 AI 味扫描（与 `qu-aiwei-zh` 同源） |
+| `scripts/scan_ai_flavor.py` | 中文去 AI 味扫描 —— **转发器**，实现在 canonical `qu-aiwei-zh`（`--which` 可查解析结果；本目录不含实现，避免副本漂移） |
+| `scripts/audit-provenance.py` | **改稿保真审计**：双向逐段溯源（本稿→源稿 / 源稿→本稿），抓悄悄扩写与被落下的段。有源稿时定稿必跑 |
 
 ```bash
 # 路径解析：CLI --base/--workspace → env TOPMIND_WECHAT_BASE / TOPMIND_WORKSPACE / TOPSTREAM_ROOT → 惯例
 export TOPMIND_WORKSPACE=/path/to/workspace   # 推荐
 python3 scripts/new-article.py --slug demo --title "标题" --direction reverse
 python3 scripts/lint-wechat.py --input <包>/公众号稿.md --fix
-python3 scripts/scan_ai_flavor.py <包>/公众号稿.md          # 目标 ≥85
+python3 scripts/scan_ai_flavor.py <包>/公众号稿.md          # 总分与作者姿态分都 ≥85
 python3 scripts/md2wechat.py --input <包>/公众号稿.md --out-dir <包> --slug demo \
   --asset-root <素材根> --embed-images
 python3 scripts/sync-status.py --set 定稿 <包> --apply
@@ -147,6 +148,13 @@ python3 scripts/sync-status.py --set 定稿 <包> --apply
 - 改稿续写：正文已有数字**回源重核**（上一轮文本最不可信）  
 - 多口径（主轮/复跑）显式拆开；表格从数据源生成，禁止手抄  
 - 外部工具改过的稿：**先核数字再动文字**；「比值对但绝对值错」= 全段重核  
+- **有源稿时（`reverse` / 站外拉取）跑一次双向溯源审计**，别靠「我记得只改了三处」：
+
+  ```bash
+  python3 scripts/audit-provenance.py --draft <包>/公众号稿.md --source <包>/源稿-*.md
+  ```
+
+  正向查「本稿有、源稿找不到」（扩写藏在这里），反向查「源稿有、本稿落下」。**退出码 1 不是失败，是「有待判定项」**——每一项要么归入已声明的修正/增补，要么就是不该有的改动；逐条在包内 README 声明后即收口。源稿里后加的块（勘误等）用 `--skip '^>\s*\[!'` 排除。  
 
 ### 关 2 · 逻辑
 
@@ -156,13 +164,16 @@ python3 scripts/sync-status.py --set 定稿 <包> --apply
 ### 关 3 · 文字（去 AI 味）
 
 ```bash
-python3 scripts/scan_ai_flavor.py <包>/公众号稿.md   # ≥85（人话）
+python3 scripts/scan_ai_flavor.py <包>/公众号稿.md   # 总分 ≥85（人话）
 ```
 
+- **同时看「作者姿态分」（E 类，与总分独立）**，目标同样 ≥85。实测两者会严重背离：同一篇 AI 完整版总分 92 / 姿态 21，手改发布版 100 / 100——**总分只差 8 分，姿态差 79 分**，只看总分会被骗
+- ⚠️ 这里调的是 canonical `qu-aiwei-zh` 的脚本（本目录的 `scripts/scan_ai_flavor.py` 是转发器）。**若输出里没有「作者姿态层」一节，说明拿到的是 E 类之前的旧版本**，分数不可信——先 `--which` 确认实际执行的是哪一份
 - 删套话/黑话/工程圈行话；降调段末加粗金句  
 - **满分 ≠ 有人味**：再查「段末金句癖 / 节奏过分整齐 / 没有场景与我 / 报告体标注」  
 - **口语化 ≠ 有人味**：删社交垫词（元叙述、空转过渡、姿态句）  
 - 判据：**这句话删掉之后，读者少知道了什么？**  
+- **姿态分只对文章有效**：清单 / 词表 / 说明书不适用（检测器会把被引用的反例当真命中），脚本命中 ≥70% 落在表格行时会提示「疑似清单文档」，看到提示先确认再改
 
 详见 [`references/writing-quality.md`](references/writing-quality.md)。
 

package/topmind-wechat/references/workflow.md

@@ -60,21 +60,32 @@ python3 scripts/sync-status.py --set 定稿 <包> --apply
 
 | 输出 | 口径 | 用途 |
 |------|------|------|
-| frontmatter `word_count` | 纯中文 `\[一-鿿\]` | 映射真源 |
+| frontmatter `word_count` | 正文**全文**的 `[\u4e00-\u9fff]` 计数 —— **frontmatter 之后的一切都算，含图注、也含图片路径里的中文** | 映射真源 |
 | lint「字数」 | 视觉长度（中 1 + 英数 ×0.6，URL 不计） | 阅读时长 / 段长 |
 | md2wechat「正文字数」 | 渲染后字符 | 仅展示 |
 
+⚠️ `word_count` **只能由 `sync-status.py --apply` 回写，禁止手算**。它的口径与直觉不同：一篇 9 图稿，光 `images/NN-中文名.png` 这一串路名就贡献 40+ 字。自制口径（如「剔掉图注与路径」）会得出一个更小、更像「正文字数」的值，写进 frontmatter 后会被 `sync-mapping.py` 判为漂移 —— 实测一篇 1,027 vs 1,450，而错值同时落进 `topic.md` 总表与包内 README，**一个错值三处落盘**。
+
 ## 定稿验收命令串
 
 ```bash
-python3 scripts/scan_ai_flavor.py <包>/公众号稿.md    # ≥85
+python3 scripts/scan_ai_flavor.py <包>/公众号稿.md    # 总分 ≥85 且「作者姿态分」≥85
 python3 scripts/lint-wechat.py --input <包>/公众号稿.md
+python3 scripts/audit-provenance.py --draft <包>/公众号稿.md --source <包>/源稿-*.md
 python3 scripts/sync-mapping.py --no-topstream
 python3 scripts/sync-status.py
 python3 scripts/md2wechat.py --input <包>/公众号稿.md --out-dir <包> \
   --slug <slug> --asset-root <素材根> --embed-images
 ```
 
+第 3 行只在**有源稿**时跑（`reverse` / 站外拉取；`forward` 的底稿在 `notes/` 也一样适用）。退出码 **0 = 双向干净**、**1 = 有待判定项**、2 = 参数错。**1 不等于稿子有问题**——它只是把「本稿有源稿找不到」和「源稿有本稿落下」两类段摆出来，由人逐条判：归入已声明的修正/增补，或改回去。判定完把结论写进包内 `README.md`，这一关才算收口。
+
+三个易踩的点：
+
+- **阈值别乱调**：默认 `0.72`。调高会把正常的改写（换词、调序）判成新增，调低会漏掉真扩写。
+- **源稿后加的块要 `--skip`**：若源稿顶部有本包后补的勘误/说明块（`> [!note] …`），它在本稿侧不存在，会恒定报一条反向待判定。用 `--skip '^>\s*\[!'` 排除，别去改稿子。
+- **图注不算遗漏**：脚本反向侧额外建了一个「去掉 `▲ 图 N` 前缀」的候选池，图注编号不会被误判为漏段。
+
 ## 收尾
 
 1. 更新专题 `topic.md` 总表（派生视图）  

package/topmind-wechat/references/writing-quality.md

@@ -44,7 +44,7 @@
 |---|---|---|
 | 中文长文 / 公众号改稿 | `humanizer-zh` + `qu-aiwei-zh` | 先立边界，再扫描定位（默认组合） |
 | 只要分数和命中清单 | `qu-aiwei-zh` | 跑脚本，不改稿 |
-| 随笔要「加声音」 | `qu-aiwei-zh` + `references/pan-style.md` | 用表达方式加，不编故事 |
+| 随笔要「加声音」 | `qu-aiwei-zh` + `qu-aiwei-zh/references/pan-style.md` | 用表达方式加，不编故事 |
 | 英文文本 | `humanizer` | `humanizer-zh` 只针对中文 |
 | 清单 / 词表 / 说明书 | 都不用 E 类姿态分 | 这类文体靠列举反例，检测器会把反例当真命中 |
 
@@ -70,12 +70,20 @@
 
 ### 第二步：扫描定位（`qu-aiwei-zh`）
 
-目标：`qu-aiwei-zh` 扫描 **≥ 85 分**。
+目标：`qu-aiwei-zh` 扫描 **总分 ≥ 85**，且**「作者姿态分」（E 类）也 ≥ 85**。两个分数独立，都要看。
 
 ```bash
+python3 scripts/scan_ai_flavor.py <稿>.md
+# 或直连 canonical（同一个脚本）
 python3 ~/.workbuddy/skills/qu-aiwei-zh/scripts/scan_ai_flavor.py <稿>.md
 ```
 
+`scripts/scan_ai_flavor.py` 是**转发器**，实现在 canonical `qu-aiwei-zh`，两条命令等价（`--which` 可查解析到哪一份）。
+
+⚠️ **认准「作者姿态层」这一节**：姿态分是后加的维度，早期版本没有。若输出里没有这一节，说明调用到了旧版脚本，**分数不可信**。实测同一篇稿：AI 完整版总分 92 / 姿态 21，手改发布版 100 / 100 —— 总分只差 8 分，姿态差 79 分，**只看总分会被骗**。
+
+⚠️ **姿态分只对文章有效**：清单 / 词表 / 说明书不适用——这类文体靠列举反例工作，检测器会把被引用的例子当成真命中。脚本命中 ≥70% 落在表格行时会提示「疑似清单文档」，看到提示先确认文体再改。
+
 ### 删套话
 
 值得注意 / 值得记录 / 值得单独强调 / 本质上 / 事实上 / 意味着 / 由此可见 / 不难看出 / 换句话说 / 换言之 / 殊途同归 / 显而易见 / 众所周知 / 更进一步说
@@ -114,7 +122,7 @@ python3 ~/.workbuddy/skills/qu-aiwei-zh/scripts/scan_ai_flavor.py <稿>.md
 
 有「我」、有具体场景、有具体数字与人名、有不确定性表达（「其实」「不过」「还在想」）、句子长短交替、有真实细节而不是「很多人」「大多数」。
 
-⚠️ 这一段说的是**表达方式**。原文没有第一人称、没有数字时，不许靠这一条去补——那正好踩中 `humanizer-zh` 的优先级第 1 条。加声音的手段是句长节奏、设问、括号自注（见 `pan-style.md`），配合删掉元叙述和教学腔。`humanizer-zh` 里写着同一句话：「用户要求增强个人风格时，用表达方式实现，不编故事。」
+⚠️ 这一段说的是**表达方式**。原文没有第一人称、没有数字时，不许靠这一条去补——那正好踩中 `humanizer-zh` 的优先级第 1 条。加声音的手段是句长节奏、设问、括号自注（见 `qu-aiwei-zh/references/pan-style.md`），配合删掉元叙述和教学腔。`humanizer-zh` 里写着同一句话：「用户要求增强个人风格时，用表达方式实现，不编故事。」
 
 英文文本才走 `humanizer`：它的取向是 **Add soul**（主动注入个性），与中文改稿的**保真优先**方向相反，别把它的思路套到中文稿上。
 

package/topmind-wechat/scripts/audit-provenance.py

@@ -0,0 +1,366 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""audit-provenance.py — 双向逐段溯源审计（改稿保真度的机械化检查）。
+
+## 它解决什么问题
+
+把一篇成稿改成另一种形态（X 长文 → 公众号、底稿 → 交付稿）时，最容易出的不是错别字，
+而是**悄悄扩写**和**悄悄漏掉**。人眼逐段比对一篇几千字的稿子既慢又不可靠。
+
+本脚本做**两个方向**的机械化检查：
+
+- **正向（本稿 → 源稿）**：`--draft` 的每一段，能否在 `--source` 里找到？找不到的即
+  「疑似新增」—— 扩写就藏在这里
+- **反向（源稿 → 本稿）**：`--source` 的每一段，有没有在本稿里落下？找不到的即「疑似遗漏」
+
+## 为什么不用 diff
+
+形态转换必然改变排版：断段、标题层级、`++` 标记层、图注加 `▲ 图 N` 编号。
+逐行 diff 会被这些噪声淹没，真正的问题（多出/少掉的事实句）反而看不见。
+
+所以这里**先归一化到「纯文字内容」再比对**，并显式放过几类合法差异：
+
+| 分类 | 含义 |
+|------|------|
+| `identical` | 归一化后完全相同 |
+| `rewritten` | 同段但有文字改动（图注编号、标点、已声明的事实修正都落这里） |
+| `merged` | 本稿把源稿的**几段并成了一段** |
+| `split` | 源稿的一段被本稿**拆成了几段** |
+| `caption` | 仅图注加了 `▲ 图 N：` 前缀，正文一字未改 |
+| `tail` | 结尾 CTA / 签名 / 「首发于公众号」类附加句 |
+| `unexplained` | **其余全部**，需要人工判定 —— 这是唯一会被报警的一类 |
+
+⚠️ **`merged` / `split` 两类是必须的**：源稿常把「正文末句 + 图注」挤在同一段，本稿拆开是
+正常排版。没有这两类，几乎每张图都会报一次假阳性；而只做段落级匹配则会把所有拆段都误报。
+所以候选池同时建两级窗口：**段窗口**（1~3 段合并）与**句窗口**（1~3 句合并，长度下限 12 字）。
+
+## 已知陷阱（踩过）
+
+不要用 `^---.*?^---` 配 `re.S` 剥 frontmatter —— 正文里常有 `---` 分隔线，
+那个正则会连带把中间正文吃掉，导致源稿被误判成「只剩几段」。
+本脚本只剥**文件头**的 frontmatter：`^---\\n.*?\\n---\\n` + `count=1`。
+
+源稿里后加的块（勘误、HTML 注释）默认会进待判定，用 `--skip` 排除：
+
+    --skip '^>\\s*\\[!'
+
+## 用法
+
+    python3 scripts/audit-provenance.py --draft <包>/公众号稿.md --source <包>/源稿-X长文.md
+    python3 scripts/audit-provenance.py --draft a.md --source b.md --skip '^>\\s*\\[!' --json
+    python3 scripts/audit-provenance.py --draft a.md --source b.md --threshold 0.8 --verbose
+
+退出码：0 = 无待判定项；1 = 有 `unexplained`（需人工看）；2 = 参数/文件错误。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from difflib import SequenceMatcher
+
+MAX_SPAN = 3          # 允许 1~MAX_SPAN 个相邻单位合并成一个窗口
+MIN_SENT_WIN = 12     # 句级窗口归一化后的最小长度，避免短句偶然命中
+
+# 元信息块（来源 / 抓取记录）——两侧都跳过
+META_RE = re.compile(
+    r"^>\s*(来源|实标题|标题|摘要|作者|站点|提取|约字数|说明|发布|原始)\s*[:：]"
+)
+IMG_ONLY_RE = re.compile(r"^\s*(!\[[^\]]*\]\([^)]*\)|!\[\[[^\]]*\]\])\s*$")
+HTML_COMMENT_RE = re.compile(r"^\s*<!--.*?-->\s*$", re.S)
+CAPTION_PREFIX_RE = re.compile(r"^▲\s*图\s*\d+\s*[：:\-–—]?\s*")
+SENT_RE = re.compile(r"[^。！？；!?;]*[。！？；!?;]|[^。！？；!?;]+")
+
+TAIL_HINTS = ("欢迎转发", "点个关注", "评论区", "不迷路", "首发于", "转载请注明",
+              "如果这篇", "如果对你有用")
+
+_TYPO = {
+    "\u201c": '"', "\u201d": '"', "\u2018": "'", "\u2019": "'",
+    "\u2014": "-", "\u2013": "-", "\u2026": "...",
+}
+
+
+# --------------------------------------------------------------------------- #
+# 切段与归一化
+# --------------------------------------------------------------------------- #
+
+def strip_fm(text: str) -> str:
+    """只剥文件头的 frontmatter。正文里的 --- 必须保留。"""
+    if text.startswith("---\n"):
+        m = re.match(r"^---\n.*?\n---\n", text, re.S | re.M)
+        if m:
+            return text[m.end():]
+    return text
+
+
+def blocks(text: str, skips):
+    """按空行切段；丢掉分隔线、纯图片、元信息块、HTML 注释块、--skip 命中的块。
+
+    代码块内部不切分，避免把一段代码拆散。
+    """
+    body = strip_fm(text).replace("\r\n", "\n")
+    out, buf, in_code = [], [], False
+    for line in body.split("\n"):
+        if line.strip().startswith("```"):
+            in_code = not in_code
+            buf.append(line)
+            continue
+        if in_code:
+            buf.append(line)
+            continue
+        if line.strip() == "":
+            if buf:
+                out.append("\n".join(buf))
+                buf = []
+        else:
+            buf.append(line)
+    if buf:
+        out.append("\n".join(buf))
+
+    keep = []
+    for b in out:
+        s = b.strip()
+        if not s or re.fullmatch(r"[-*_]{3,}", s) or IMG_ONLY_RE.match(s):
+            continue
+        if META_RE.match(s) or HTML_COMMENT_RE.match(s):
+            continue
+        if any(rx.search(s) for rx in skips):
+            continue
+        keep.append(s)
+    return keep
+
+
+def normalize(block: str) -> str:
+    """把一段 markdown 归一化成「可比较的纯文字内容」。"""
+    t = block
+    t = re.sub(r"^\s*>\s?", "", t, flags=re.M)
+    t = re.sub(r"^\s*#{1,6}\s*", "", t, flags=re.M)
+    t = re.sub(r"^\s*[-*+]\s+", "", t, flags=re.M)
+    t = re.sub(r"^\s*\d+[.)]\s+", "", t, flags=re.M)
+    t = re.sub(r"!\[[^\]]*\]\([^)]*\)", "", t)
+    t = re.sub(r"!\[\[[^\]]*\]\]", "", t)
+    t = re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", t)
+    t = re.sub(r"`{1,3}", "", t)
+    for a in ("**", "__", "==", "++", "~~"):
+        t = t.replace(a, "")
+    for a, b in _TYPO.items():
+        t = t.replace(a, b)
+    return re.sub(r"\s+", "", t)
+
+
+def block_windows(norms):
+    """段级窗口：(起始段, 结束段, 合并文本)。"""
+    n = len(norms)
+    for i in range(n):
+        acc = ""
+        for k in range(MAX_SPAN):
+            if i + k >= n:
+                break
+            acc += norms[i + k]
+            yield i, i + k, acc
+
+
+def sent_windows(norms):
+    """句级窗口：(所属段, 所属段, 合并文本)。用于识别「源稿一段被拆开」。"""
+    for i, blk in enumerate(norms):
+        sents = [s for s in SENT_RE.findall(blk) if s]
+        for a in range(len(sents)):
+            acc = ""
+            for k in range(MAX_SPAN):
+                if a + k >= len(sents):
+                    break
+                acc += sents[a + k]
+                if len(acc) >= MIN_SENT_WIN:
+                    yield i, i, acc
+
+
+def best(needle, win_list):
+    """返回 (最高相似度, 窗口起, 窗口止, 次高相似度)。"""
+    if not needle or not win_list:
+        return 0.0, -1, -1, 0.0
+    scored = []
+    for a, b, txt in win_list:
+        scored.append((SequenceMatcher(None, needle, txt).ratio(), a, b))
+    scored.sort(key=lambda x: x[0], reverse=True)
+    top = scored[0]
+    second = scored[1][0] if len(scored) > 1 else 0.0
+    return top[0], top[1], top[2], second
+
+
+def is_tail(text: str) -> bool:
+    return any(h in text for h in TAIL_HINTS)
+
+
+def snippet(text: str, n: int = 44) -> str:
+    one = re.sub(r"\s+", " ", text).strip()
+    return one if len(one) <= n else one[:n] + "…"
+
+
+# --------------------------------------------------------------------------- #
+# 审计
+# --------------------------------------------------------------------------- #
+
+def audit(draft_path, source_path, threshold, skips):
+    dblocks = blocks(open(draft_path, encoding="utf-8").read(), skips)
+    sblocks = blocks(open(source_path, encoding="utf-8").read(), skips)
+    dn = [normalize(b) for b in dblocks]
+    sn = [normalize(b) for b in sblocks]
+
+    s_blk = list(block_windows(sn))
+    s_sent = list(sent_windows(sn))
+    # 本稿侧额外把「去掉 ▲ 图 N 前缀」的版本算作候选，图注不算遗漏
+    dn_plus = list(dn) + [normalize(CAPTION_PREFIX_RE.sub("", b.strip()))
+                          for b in dblocks if CAPTION_PREFIX_RE.match(b.strip())]
+    dn_plus = [x for x in dn_plus if x]
+    d_blk = list(block_windows(dn_plus))
+    d_sent = list(sent_windows(dn_plus))
+
+    def judge(r_blk, r_sent, span_blk, span_sent):
+        """按「先段级、后句级」判定分类。"""
+        if r_blk >= threshold:
+            if r_blk >= 0.995:
+                return "identical", r_blk, span_blk
+            if span_blk[1] > span_blk[0]:
+                return "merged", r_blk, span_blk
+            return "rewritten", r_blk, span_blk
+        if r_sent >= threshold:
+            return "split", r_sent, span_sent
+        return "unexplained", max(r_blk, r_sent), span_blk
+
+    forward = []
+    for i, d in enumerate(dblocks):
+        if not dn[i]:
+            continue
+        rb, ab1, ab2, sb = best(dn[i], s_blk)
+        rs, as1, as2, ss = best(dn[i], s_sent)
+        capped = bool(CAPTION_PREFIX_RE.match(d.strip()))
+        r_nocap = -1.0
+        if capped:
+            alt = normalize(CAPTION_PREFIX_RE.sub("", d.strip()))
+            if alt:
+                r_nocap, *_ = best(alt, s_blk)
+        top = max(rb, rs, r_nocap)
+
+        if top >= threshold:
+            kind, _, span = judge(rb, rs, (ab1, ab2), (as1, as2))
+            if capped and r_nocap > max(rb, rs):
+                kind = "caption"
+            forward.append({"i": i, "kind": kind, "ratio": round(top, 3),
+                            "source_span": list(span), "text": snippet(d)})
+        elif is_tail(d):
+            forward.append({"i": i, "kind": "tail", "ratio": round(top, 3),
+                            "source_span": [-1, -1], "text": snippet(d)})
+        else:
+            forward.append({"i": i, "kind": "unexplained", "ratio": round(top, 3),
+                            "second": round(max(sb, ss), 3), "source_span": [ab1, ab2],
+                            "text": snippet(d)})
+
+    backward = []
+    for i, s in enumerate(sblocks):
+        if not sn[i]:
+            continue
+        rb, ab1, ab2, sb = best(sn[i], d_blk)
+        rs, as1, as2, ss = best(sn[i], d_sent)
+        kind, ratio, span = judge(rb, rs, (ab1, ab2), (as1, as2))
+        if kind == "identical":
+            kind = "found"
+        rec = {"i": i, "kind": kind, "ratio": round(ratio, 3),
+               "draft_span": list(span), "text": snippet(s)}
+        if kind == "unexplained":
+            rec["second"] = round(max(sb, ss), 3)
+        backward.append(rec)
+
+    return {"draft": draft_path, "source": source_path, "threshold": threshold,
+            "draft_blocks": len(dblocks), "source_blocks": len(sblocks),
+            "forward": forward, "backward": backward}
+
+
+def report(res) -> int:
+    f, b = res["forward"], res["backward"]
+    f_un = [x for x in f if x["kind"] == "unexplained"]
+    b_un = [x for x in b if x["kind"] == "unexplained"]
+
+    print("溯源审计：%s  ←  %s" % (res["draft"], res["source"]))
+    print("阈值 %.2f · 本稿 %d 段 · 源稿 %d 段" %
+          (res["threshold"], res["draft_blocks"], res["source_blocks"]))
+    print("-" * 78)
+
+    def tally(rows):
+        d = {}
+        for r in rows:
+            d[r["kind"]] = d.get(r["kind"], 0) + 1
+        return d
+
+    print("正向（本稿 → 源稿）：", "  ".join("%s %d" % kv for kv in sorted(tally(f).items())))
+    print("反向（源稿 → 本稿）：", "  ".join("%s %d" % kv for kv in sorted(tally(b).items())))
+
+    if f_un:
+        print("\n⚠ 正向待判定（本稿有、源稿找不到 —— 扩写藏在这里）：")
+        for r in f_un:
+            print("  段%-4d 相似度 %.2f（次高 %.2f）  「%s」" %
+                  (r["i"], r["ratio"], r.get("second", 0), r["text"]))
+    if b_un:
+        print("\n⚠ 反向待判定（源稿有、本稿落下了）：")
+        for r in b_un:
+            print("  段%-4d 相似度 %.2f（次高 %.2f）  「%s」" %
+                  (r["i"], r["ratio"], r.get("second", 0), r["text"]))
+
+    total = len(f_un) + len(b_un)
+    print("-" * 78)
+    if total == 0:
+        print("✓ 无待判定项：本稿相对源稿只剩排版差异、图注编号与结尾附加句")
+        return 0
+    print("✗ %d 项待人工判定（正向新增 %d · 反向遗漏 %d）" % (total, len(f_un), len(b_un)))
+    print("  判定口径：每一项要么归入「已声明的事实修正 / 已声明的增补」，")
+    print("  要么就是不该出现的改动 —— 见技能 SKILL.md「改稿底线」。")
+    print("  源稿里后加的块（勘误等）用 --skip '^>\\s*\\[!' 排除。")
+    return 1
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        description="双向逐段溯源审计：查改稿有没有悄悄扩写或漏掉")
+    ap.add_argument("--draft", required=True, help="派生稿（如 公众号稿.md）")
+    ap.add_argument("--source", required=True, help="源稿（如 源稿-X长文.md）")
+    ap.add_argument("--threshold", type=float, default=0.72,
+                    help="相似度阈值，低于它即待判定（默认 0.72）")
+    ap.add_argument("--skip", action="append", default=[],
+                    help="正则：命中的段直接排除（可重复，两侧都生效）")
+    ap.add_argument("--json", action="store_true", help="输出 JSON")
+    ap.add_argument("--verbose", action="store_true", help="打印逐段明细")
+    args = ap.parse_args()
+
+    for p in (args.draft, args.source):
+        try:
+            open(p, encoding="utf-8").close()
+        except OSError as e:
+            print("✗ 读不到文件：%s（%s）" % (p, e), file=sys.stderr)
+            return 2
+
+    try:
+        skips = [re.compile(rx) for rx in args.skip]
+    except re.error as e:
+        print("✗ --skip 正则非法：%s" % e, file=sys.stderr)
+        return 2
+
+    res = audit(args.draft, args.source, args.threshold, skips)
+
+    if args.verbose:
+        print("逐段明细：")
+        for tag, rows in (("正", res["forward"]), ("反", res["backward"])):
+            for r in rows:
+                print("  %s 段%-4d %-11s %.2f  %s" %
+                      (tag, r["i"], r["kind"], r["ratio"], r["text"]))
+        print("-" * 78)
+
+    if args.json:
+        print(json.dumps(res, ensure_ascii=False, indent=2))
+        return 0 if not any(x["kind"] == "unexplained"
+                            for x in res["forward"] + res["backward"]) else 1
+    return report(res)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/topmind-wechat/scripts/scan_ai_flavor.py

@@ -1,464 +1,101 @@
 #!/usr/bin/env python3
-"""
-scan_ai_flavor.py — 中文 AI 味检测脚本
-
-用法：
-  python3 scan_ai_flavor.py <file>            # 输出 Markdown 报告
-  python3 scan_ai_flavor.py --json <file>     # 输出 JSON
-  python3 scan_ai_flavor.py -o report.md <file>
-  cat article.md | python3 scan_ai_flavor.py - # 管道
-
-设计目标：纯 stdlib，无第三方依赖，能在普通 Mac / Linux 上直接跑。
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from collections import Counter
-from dataclasses import dataclass, field, asdict
-from pathlib import Path
-from typing import Iterable
+# -*- coding: utf-8 -*-
+"""scan_ai_flavor.py — 转发器：调用 qu-aiwei-zh 的 canonical 检测脚本。
 
+**本文件不含检测实现。** 原因见下。
 
-# --------------------------------------------------------------------------- #
-# 模式定义：每条 (类别代码, 类别名, 正则, 单次扣分, 严重度, 开头末尾加权, 备注)
-# --------------------------------------------------------------------------- #
+## 为什么是转发器而不是自带副本
 
+topmind-wechat 曾自带一份 463 行的实现副本，它是 `qu-aiwei-zh` 在加入「E 类 · 作者姿态层」
+**之前**的旧快照 —— 不输出姿态参考分，也识别不了姿态类 AI 痕迹。照 SKILL.md 跑它，会拿到一个
+**没有姿态维度的「100 分」**：看着干净，其实少了一整个维度。
 
-@dataclass
-class Pattern:
-    code: str          # e.g. "A1"
-    name: str          # e.g. "开头套话"
-    regex: str         # 正则字符串
-    penalty: int       # 单次扣分（绝对值）
-    severity: str      # high / mid / low
-    weighted: str = "" # "head" | "tail" | ""（加权区段）
-    note: str = ""
+两版实测差异：旧副本 0 处「姿态」相关代码，canonical 20 处。
 
-    def compiled(self) -> re.Pattern:
-        return re.compile(self.regex)
+副本必然再次漂移（一边改了另一边不知道），所以这里只保留入口，实现归 canonical 一处。
 
+## canonical 查找顺序（命中即用）
 
-# 头部加权的模式（命中位置 ≤ 200 字 权重 ×1.5）
-HEAD_PATTERNS: list[Pattern] = [
-    Pattern("A1", "开头套话", r"在当今(社会|时代)", 8, "high", "head"),
-    Pattern("A1", "开头套话", r"随着[^，。]{2,30}的(发展|日益|不断)", 8, "high", "head"),
-    Pattern("A1", "开头套话", r"众所周知[，,]", 7, "high", "head"),
-    Pattern("A1", "开头套话", r"毋庸置疑[，,]|不可否认[，,]", 7, "high", "head"),
-    Pattern("A1", "开头套话", r"近年来[^，。]{0,15}日益", 6, "high", "head"),
-    Pattern("A1", "开头套话", r"伴随着[^，。]{2,30}的(快速|迅猛)", 8, "high", "head"),
-    Pattern("A1", "开头套话", r"在[^，。]{2,20}的背景下", 5, "mid", "head"),
-    Pattern("A1", "开头套话", r"一直以来[^，。]{2,20}都", 4, "low", "head"),
-    Pattern("A10", "模板口水", r"大家好[，,]", 6, "high", "head"),
-    Pattern("A10", "模板口水", r"本文将从[^，。]{0,30}个方面", 7, "high", "head"),
-    Pattern("A10", "模板口水", r"希望本文能够", 5, "mid", "head"),
-    Pattern("A10", "模板口水", r"如(有不当|有疏漏|有错误)[，,]", 4, "low", "head"),
-]
-
-# 全文模式
-BODY_PATTERNS: list[Pattern] = [
-    # A2 转折连接
-    Pattern("A2", "转折连接", r"此外[，,]", 2, "low"),
-    Pattern("A2", "转折连接", r"与此同时[，,]", 2, "low"),
-    Pattern("A2", "转折连接", r"不仅如此[，,]", 2, "low"),
-    Pattern("A2", "转折连接", r"综上所述[，,]", 4, "mid"),
-    Pattern("A2", "转折连接", r"总而言之[，,]", 4, "mid"),
-    Pattern("A2", "转折连接", r"一方面[^，。]{1,15}[，,另一方面]", 3, "low"),
-    Pattern("A2", "转折连接", r"既[^，。]{1,12}又[^，。]{1,12}还", 3, "low"),
-    Pattern("A2", "转折连接", r"无可厚非", 4, "mid"),
-    Pattern("A2", "转折连接", r"瑕不掩瑜", 4, "mid"),
+1. `$QU_AIWEI_SCAN`                       显式指定（测试与非标准安装用）
+2. `~/.workbuddy/skills/qu-aiwei-zh/scripts/scan_ai_flavor.py`
+3. `~/.agents/skills/qu-aiwei-zh/scripts/scan_ai_flavor.py`
+4. `~/.claude/skills/qu-aiwei-zh/scripts/scan_ai_flavor.py`
+5. `~/.codex/skills/qu-aiwei-zh/scripts/scan_ai_flavor.py`
 
-    # A3 形容词/官腔
-    Pattern("A3", "官腔形容词", r"至关重要", 5, "high"),
-    Pattern("A3", "官腔形容词", r"举足轻重", 5, "high"),
-    Pattern("A3", "官腔形容词", r"不可或缺", 4, "mid"),
-    Pattern("A3", "官腔形容词", r"深入(探讨|分析|研究)", 5, "high"),
-    Pattern("A3", "官腔形容词", r"高度重视", 5, "high"),
-    Pattern("A3", "官腔形容词", r"深入推进", 5, "high"),
-    Pattern("A3", "官腔形容词", r"扎实开展", 5, "high"),
-    Pattern("A3", "官腔形容词", r"积极探索", 4, "mid"),
-    Pattern("A3", "官腔形容词", r"有效落实", 4, "mid"),
-    Pattern("A3", "官腔形容词", r"持续优化", 4, "mid"),
-    Pattern("A3", "官腔形容词", r"凝聚共识", 5, "high"),
-    Pattern("A3", "官腔形容词", r"汇聚合力", 5, "high"),
-    Pattern("A3", "官腔形容词", r"协同推进", 4, "mid"),
-    Pattern("A3", "官腔形容词", r"全方位(提升|推进|优化)", 4, "mid"),
-    Pattern("A3", "官腔形容词", r"多角度(分析|审视)", 4, "mid"),
-    Pattern("A3", "官腔形容词", r"立体化", 3, "low"),
-    # 注：数字化/智能化 是领域术语，不作为 AI 味标志，跳过
+## 行为
 
-    # A5 排比/三段式
-    Pattern("A5", "排比三段式", r"这不仅[^，。]{2,20}[，,][^，。]{2,15}也[^，。]{2,15}[，,更]?", 6, "high"),
-    Pattern("A5", "排比三段式", r"从[^，。]{2,15}到[^，。]{2,15}[，,从][^，。]{2,15}到", 4, "mid"),
+- 参数原样透传（位置参数 `<file>` / `--json` / `-o` / `-` 管道都可用），stdin / stdout / stderr 继承
+- 退出码取 canonical 的退出码
+- `--which` 只打印解析到的 canonical 路径并退出 0（转发器自有开关，canonical 无此参数）
+- **找不到 canonical 时报错退出（exit 3），不静默降级** —— 宁可这一步跑不了，
+  也不要给出一个没有姿态分的分数
 
-    # A6 营销体
-    Pattern("A6", "营销黑话", r"赋能", 5, "high"),
-    Pattern("A6", "营销黑话", r"加持", 5, "high"),
-    Pattern("A6", "营销黑话", r"引爆", 5, "high"),
-    Pattern("A6", "营销黑话", r"破圈", 5, "high"),
-    Pattern("A6", "营销黑话", r"一站式", 4, "mid"),
-    Pattern("A6", "营销黑话", r"全链路", 4, "mid"),
-    Pattern("A6", "营销黑话", r"闭环", 4, "mid"),
-    Pattern("A6", "营销黑话", r"抓手", 5, "high"),
-    Pattern("A6", "营销黑话", r"底层逻辑", 5, "high"),
-    Pattern("A6", "营销黑话", r"顶层设计", 5, "high"),
-    Pattern("A6", "营销黑话", r"(打造|构建|重塑)[^，。]{2,15}(方案|生态|体系|平台)", 3, "low"),
-    Pattern("A6", "营销黑话", r"拉通|对齐|复盘", 3, "low"),
-    # 工程圈行话：用户明确点过——「踩坑」这类词读起来像圈内口令，不像人在说话
-    Pattern("A6", "工程圈行话", r"踩坑|避坑|干货|踩出来的坑|踩过的坑", 3, "low"),
+## 用法
 
-    # A7 模糊归因
-    Pattern("A7", "模糊归因", r"专家指出", 5, "high"),
-    Pattern("A7", "模糊归因", r"业内人士表示", 5, "high"),
-    Pattern("A7", "模糊归因", r"据相关(研究|调查|数据)表明", 5, "high"),
-    Pattern("A7", "模糊归因", r"大量数据表明", 5, "high"),
-    Pattern("A7", "模糊归因", r"有学者认为", 4, "mid"),
-    Pattern("A7", "模糊归因", r"专家(普遍|一致)认为", 4, "mid"),
-    Pattern("A7", "模糊归因", r"大家普遍认为", 3, "low"),
+    python3 scripts/scan_ai_flavor.py <包>/公众号稿.md      # 目标 ≥85
+    python3 scripts/scan_ai_flavor.py --which
+"""
 
-    # A8 伪深度
-    Pattern("A8", "伪深度", r"(是|为)[^，。]{2,15}的(体现|证明|象征)", 5, "high"),
-    Pattern("A8", "伪深度", r"彰显了[^，。]{2,20}(意义|价值|精神)", 5, "high"),
-    Pattern("A8", "伪深度", r"凸显了[^，。]{2,20}(意义|价值)", 5, "high"),
-    Pattern("A8", "伪深度", r"反映了更深(层次)的", 4, "mid"),
+from __future__ import annotations
 
-    # A9 假大空成语
-    Pattern("A9", "假大空成语", r"博大精深", 4, "mid"),
-    Pattern("A9", "假大空成语", r"源远流长", 4, "mid"),
-    Pattern("A9", "假大空成语", r"历久弥新", 4, "mid"),
-    Pattern("A9", "假大空成语", r"与时俱进", 3, "low"),
-    Pattern("A9", "假大空成语", r"开拓创新", 3, "low"),
-    Pattern("A9", "假大空成语", r"锐意进取", 3, "low"),
-    Pattern("A9", "假大空成语", r"举世(瞩目|无双)", 4, "mid"),
+import os
+import sys
 
-    # A10 模板口水
-    Pattern("A10", "模板口水", r"感谢(您的)?(观看|阅读|支持)", 5, "high"),
-    Pattern("A10", "模板口水", r"以上就是[^，。]{2,30}(全部)?内容", 5, "high"),
-    Pattern("A10", "模板口水", r"欢迎(指正|交流|留言)", 4, "mid"),
-]
+REL = os.path.join("qu-aiwei-zh", "scripts", "scan_ai_flavor.py")
 
-# 尾部加权
-TAIL_PATTERNS: list[Pattern] = [
-    Pattern("A4", "结尾升华", r"让我们(共同|一起)", 8, "high", "tail"),
-    Pattern("A4", "结尾升华", r"未来可期", 6, "high", "tail"),
-    Pattern("A4", "结尾升华", r"任重道远", 6, "high", "tail"),
-    Pattern("A4", "结尾升华", r"砥砺前行|扬帆远航", 5, "high", "tail"),
-    Pattern("A4", "结尾升华", r"在[^，。]{2,20}的道路上(不断)?前行", 6, "high", "tail"),
-    Pattern("A4", "结尾升华", r"为[^，。]{2,15}贡献(自己)?的?力量", 6, "high", "tail"),
-    Pattern("A4", "结尾升华", r"谱写[^，。]{2,15}新篇章", 6, "high", "tail"),
-    Pattern("A4", "结尾升华", r"展望未来", 4, "mid", "tail"),
+CANDIDATES = [
+    os.path.join("~", ".workbuddy", "skills", REL),
+    os.path.join("~", ".agents", "skills", REL),
+    os.path.join("~", ".claude", "skills", REL),
+    os.path.join("~", ".codex", "skills", REL),
 ]
 
-ALL_PATTERNS = HEAD_PATTERNS + BODY_PATTERNS + TAIL_PATTERNS
-
-
-# --------------------------------------------------------------------------- #
-# 数据结构
-# --------------------------------------------------------------------------- #
-
-
-@dataclass
-class Hit:
-    code: str
-    name: str
-    pattern: str
-    text: str
-    line: int
-    column: int
-    severity: str
-    penalty: int
-    raw_penalty: int  # 加权前
-
-
-@dataclass
-class Report:
-    score: int
-    level: str
-    level_emoji: str
-    hits: list[Hit] = field(default_factory=list)
-    lexical_deduction: int = 0
-    structural_deduction: int = 0
-    stats: dict = field(default_factory=dict)
-    suggestions: list[str] = field(default_factory=list)
-
-
-# --------------------------------------------------------------------------- #
-# 扫描逻辑
-# --------------------------------------------------------------------------- #
-
-
-def scan_text(text: str) -> Report:
-    lines = text.splitlines()
-    total_chars = len(text)
-    total_lines = len(lines)
-    head_chars = "".join(lines[: max(1, total_lines // 5)])  # 前 20%
-    tail_chars = "".join(lines[-max(1, total_lines // 5):])  # 后 20%
-
-    hits: list[Hit] = []
-    seen_in_text: dict[tuple[str, str], int] = {}  # (pattern, exact_text) → 第 N 次出现
-
-    for p in ALL_PATTERNS:
-        regex = p.compiled()
-        for m in regex.finditer(text):
-            # 计算行号/列号
-            start = m.start()
-            line_no = text.count("\n", 0, start) + 1
-            col_no = start - (text.rfind("\n", 0, start) + 1) + 1
-
-            # 计算加权：位置决定
-            region = "body"
-            if p.weighted == "head" and start < len(head_chars):
-                region = "head"
-            elif p.weighted == "tail" and start >= len(text) - len(tail_chars):
-                region = "tail"
-
-            raw = p.penalty
-            if region != "body":
-                raw = int(raw * 1.5)
-
-            # 重复衰减：同一模式第 N 次出现
-            key = (p.regex, m.group(0))
-            n = seen_in_text.get(key, 0) + 1
-            seen_in_text[key] = n
-            multiplier = min(n, 3)  # 最多 3 次
+MISSING = """\
+✗ 找不到 qu-aiwei-zh 的 canonical 检测脚本，无法执行「文字关」。
 
-            final = raw * multiplier
+  本目录不再自带实现 —— 曾经那份是 E 类姿态检测之前的旧快照，会漏掉姿态维度。
+  已查找：
+{paths}
 
-            hits.append(
-                Hit(
-                    code=p.code,
-                    name=p.name,
-                    pattern=p.regex,
-                    text=m.group(0),
-                    line=line_no,
-                    column=col_no,
-                    severity=p.severity,
-                    penalty=final,
-                    raw_penalty=raw,
-                )
-            )
-
-    # 结构扣分
-    structural = 0
-    # 重复的段首加粗标签：**结论**：/ **踩坑提醒**：/ **注意**： …
-    # 这是模板化写作最典型的痕迹，词面词表抓不到，只能按"同一标签重复出现"判定。
-    # 判据取 ≥3 次：用两次属于正常强调，用三次以上就是在套模板。
-    lead_labels = re.findall(r"^\s*\*\*([^*\n]{1,10})\*\*\s*[：:]", text, re.M)
-    repeated_labels: list[str] = []
-    if lead_labels:
-        counts = Counter(lead_labels)
-        repeated_labels = [k for k, v in counts.items() if v >= 3]
-    if total_lines >= 5:
-        # 破折号过多
-        dash_count = text.count("——")
-        if dash_count >= max(3, total_chars // 200):
-            structural -= 5
-        # 感叹号过多
-        if text.count("！！！") >= 1 or text.count("!!") >= 3:
-            structural -= 3
-        # 缺乏具体细节（无任何数字）
-        if not re.search(r"\d", text):
-            structural -= 12
-        # 缺乏个性化声音（无第一人称）
-        if not re.search(r"[我我们]", text):
-            structural -= 8
-        # 标题 emoji 滥用
-        emoji_count = len(re.findall(r"[\U0001F300-\U0001FAFF\U00002600-\U000027BF]", text))
-        if emoji_count >= 3:
-            structural -= min(9, (emoji_count - 2) * 3)
-        # 段首加粗标签模板化
-        if repeated_labels:
-            structural -= min(12, sum(lead_labels.count(k) for k in repeated_labels) * 2)
-
-    # 词面扣分汇总
-    # 注意：structural 累加时是负数（structural -= n），必须取绝对值再相加。
-    # 若直接相加，lexical + structural 会变成"加分"，结构扣分整条维度静默失效。
-    lexical = sum(h.penalty for h in hits)
-    structural = abs(structural)
-    total_deduction = lexical + structural
-    score = max(0, min(100, 100 - total_deduction))
-
-    level, level_emoji = grade(score)
-
-    # 生成建议（Top 3）
-    suggestions = build_suggestions(hits, score)
-    if repeated_labels:
-        tips = "、".join(f"**{k}**：×{lead_labels.count(k)}" for k in repeated_labels)
-        suggestions.insert(0, f"段首加粗标签模板化 — {tips}，同一标签重复 3 次以上就是在套模板，改成直陈句")
-
-    return Report(
-        score=score,
-        level=level,
-        level_emoji=level_emoji,
-        hits=hits,
-        lexical_deduction=lexical,
-        structural_deduction=structural,
-        stats={
-            "total_chars": total_chars,
-            "total_lines": total_lines,
-            "ai_pattern_count": len(hits),
-            "repeated_lead_labels": repeated_labels,
-        },
-        suggestions=suggestions,
-    )
-
-
-def grade(score: int) -> tuple[str, str]:
-    if score >= 85:
-        return "人话", "🟢"
-    if score >= 70:
-        return "微 AI 味", "🟡"
-    if score >= 50:
-        return "中度 AI 味", "🟠"
-    if score >= 30:
-        return "重度 AI 味", "🔴"
-    return "完全 AI 体", "⚫"
-
-
-def build_suggestions(hits: list[Hit], score: int) -> list[str]:
-    """按类别聚类，给出 3 条优先建议。"""
-    by_code: dict[str, list[Hit]] = {}
-    for h in hits:
-        by_code.setdefault(h.code, []).append(h)
-
-    # 优先级：A4>A3>A6>A7>A1>A8>A10>A5>A9
-    priority = ["A4", "A3", "A6", "A7", "A1", "A8", "A10", "A5", "A9"]
-    tips_map = {
-        "A1": "开头套话 — 删掉'在当今社会'等模板开头，直接说事实",
-        "A2": "转折词 — 用句号断开，靠上下文自然过渡",
-        "A3": "官腔形容词 — 换成大白话或具体数字",
-        "A4": "结尾升华 — 删掉'让我们共同'等空话，给具体计划",
-        "A5": "排比三段式 — 砍到两项或四项，别硬凑三段",
-        "A6": "营销黑话 — 改为具体动词，如'做了一个工具'",
-        "A7": "模糊归因 — 给具体名字/出处/数字",
-        "A8": "伪深度 — 删除'是 XX 的体现/证明'句式",
-        "A9": "假大空成语 — 用白话翻译一遍",
-        "A10": "模板口水 — 删掉口水句，直接进入正文",
-    }
-
-    suggestions = []
-    for code in priority:
-        if code in by_code:
-            n = len(by_code[code])
-            suggestions.append(f"{tips_map[code]}（命中 {n} 处）")
-        if len(suggestions) >= 3:
-            break
-
-    if not suggestions:
-        suggestions.append("未发现明显 AI 模式，但建议人工通读检查结构/个性化声音")
-
-    return suggestions
-
-
-# --------------------------------------------------------------------------- #
-# 输出格式
-# --------------------------------------------------------------------------- #
-
-
-def render_markdown(report: Report, source: str) -> str:
-    md: list[str] = []
-    md.append(f"## AI 味检测报告\n")
-    md.append(f"**文件：** `{source}`  ")
-    md.append(f"**总分：** **{report.score}** / 100  {report.level_emoji} {report.level}\n")
-
-    md.append("### 分项评分")
-    md.append(f"- 词面命中扣分：**-{report.lexical_deduction}**")
-    md.append(f"- 结构问题扣分：**{report.structural_deduction}**")
-    md.append(f"- 总计：**-{report.lexical_deduction + abs(report.structural_deduction)}** → {report.score} 分\n")
-
-    md.append("### 基础统计")
-    md.append(f"- 字符数：{report.stats.get('total_chars', 0)}")
-    md.append(f"- 行数：{report.stats.get('total_lines', 0)}")
-    md.append(f"- AI 模式命中数：**{report.stats.get('ai_pattern_count', 0)}**")
-    reps = report.stats.get("repeated_lead_labels") or []
-    if reps:
-        md.append(f"- 重复段首加粗标签：**{'、'.join(reps)}**")
-    md.append("")
-
-    if report.hits:
-        md.append("### 命中位置（按严重度排序）")
-        md.append("| # | 类别 | 命中内容 | 位置 | 严重度 | 扣分 |")
-        md.append("|---|---|---|---|---|---|")
-        sorted_hits = sorted(report.hits, key=lambda h: -h.penalty)
-        for i, h in enumerate(sorted_hits[:30], 1):
-            preview = h.text if len(h.text) <= 25 else h.text[:25] + "…"
-            md.append(f"| {i} | {h.code} {h.name} | `{preview}` | 第 {h.line} 行 | {h.severity} | -{h.penalty} |")
-        if len(report.hits) > 30:
-            md.append(f"\n*（还有 {len(report.hits) - 30} 处命中未显示）*\n")
-    else:
-        md.append("### 命中位置")
-        md.append("无命中 🎉\n")
-
-    md.append("### Top 3 优先改写建议")
-    for s in report.suggestions:
-        md.append(f"1. {s}")
-    md.append("")
-
-    return "\n".join(md)
-
-
-def render_json(report: Report) -> str:
-    return json.dumps(
-        {
-            "score": report.score,
-            "level": report.level,
-            "level_emoji": report.level_emoji,
-            "deductions": {
-                "lexical": report.lexical_deduction,
-                "structural": report.structural_deduction,
-            },
-            "stats": report.stats,
-            "hits": [asdict(h) for h in report.hits],
-            "suggestions": report.suggestions,
-        },
-        ensure_ascii=False,
-        indent=2,
-    )
-
-
-# --------------------------------------------------------------------------- #
-# CLI
-# --------------------------------------------------------------------------- #
+  解决：安装 qu-aiwei-zh 技能，或用环境变量显式指定：
+      export QU_AIWEI_SCAN=/path/to/qu-aiwei-zh/scripts/scan_ai_flavor.py
+"""
 
 
-def main(argv: list[str]) -> int:
-    parser = argparse.ArgumentParser(
-        description="中文 AI 味检测器 — 给文章打 AI 味分数"
-    )
-    parser.add_argument("input", help="输入文件路径，或 '-' 表示 stdin")
-    parser.add_argument("--json", action="store_true", help="输出 JSON 格式")
-    parser.add_argument("-o", "--output", help="输出文件（默认 stdout）")
-    args = parser.parse_args(argv)
+def resolve():
+    """返回 canonical 脚本的绝对路径；找不到返回 None。"""
+    env = os.environ.get("QU_AIWEI_SCAN")
+    if env:
+        p = os.path.abspath(os.path.expanduser(env))
+        return p if os.path.isfile(p) else None
+    for c in CANDIDATES:
+        p = os.path.abspath(os.path.expanduser(c))
+        if os.path.isfile(p):
+            return p
+    return None
 
-    # 读取输入
-    if args.input == "-":
-        text = sys.stdin.read()
-        source = "<stdin>"
-    else:
-        p = Path(args.input)
-        if not p.exists():
-            print(f"❌ 文件不存在: {args.input}", file=sys.stderr)
-            return 1
-        text = p.read_text(encoding="utf-8")
-        source = str(p)
 
-    report = scan_text(text)
+def main():
+    args = sys.argv[1:]
 
-    if args.json:
-        out = render_json(report)
-    else:
-        out = render_markdown(report, source)
+    if args and args[0] == "--which":
+        target = resolve()
+        if target:
+            print(target)
+            return 0
+        print("✗ 未解析到 canonical 脚本；用 QU_AIWEI_SCAN 指定或安装 qu-aiwei-zh",
+              file=sys.stderr)
+        return 3
 
-    if args.output:
-        Path(args.output).write_text(out, encoding="utf-8")
-        print(f"✅ 已写入 {args.output}（{report.score} 分 / {report.level}）")
-    else:
-        print(out)
+    target = resolve()
+    if not target:
+        shown = [os.path.abspath(os.path.expanduser(c)) for c in CANDIDATES]
+        sys.stderr.write(MISSING.format(paths="\n".join("      " + p for p in shown)))
+        return 3
 
-    return 0
+    os.execv(sys.executable, [sys.executable, target] + args)
+    return 0  # 不会到达
 
 
 if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))
+    sys.exit(main())

package/topmind-weread/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-weread
-version: 4.14.0
+version: 4.15.0
 description: >-
   同步微信读书划线/想法/统计到专题。Use when 微信读书、划线同步、weread、读书笔记。
   Do NOT use for 普通 URL 捕获、仅整理、出稿、X.

package/topmind-write/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-write
-version: 4.14.0
+version: 4.15.0
 description: >-
   写作/润色/出稿到专题或交付层（role:delivery）。Use when 写、起草、续写、润色、出稿、交付、write、draft、deliver。
   Do NOT use for 仅捕获、仅结构整理、只写记忆、doctor/loop、社交连接器.

package/topmind-x/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: topmind-x
-version: 4.14.0
+version: 4.15.0
 description: >-
   X/Twitter：归档/搜索（Bearer）、发帖（xurl）、Agent 可用官方 MCP。Use when 发推、推特、twitter、x.com。
   Do NOT use for 微信读书、非 X 捕获、doctor、长文交付.