weflow-cli 1.8.2 → 1.10.0

package/dist/src/services/assistantTools.js

@@ -6,24 +6,99 @@ import { chatService } from './chatService.js';
 import { configService } from './configService.js';
 import { runPythonJson } from './pythonBridge.js';
 import { exportService } from './exportService.js';
+import { frameLocalData } from './assistantMemory.js';
+import { disabledIds, readSkillBody, scanSkills, skillRoots, skillState } from './assistantSkills.js';
 import { privacyGate } from './assistantPrivacy.js';
 import { existsSync, readFileSync, readdirSync } from 'fs';
-import { basename, join } from 'path';
+import { basename, dirname, join } from 'path';
 // 直接调进程的写法已收敛进 pythonBridge：这里不再 import child_process
 import { resolvePackageRoot } from '../utils/packageRoot.js';
 import { clipWithMarker } from '../utils/text.js';
 import { resolveSince, resolveUntil } from '../utils/dateRange.js';
+import { isAllowedWeChatArticleUrl, safeDate } from '../utils/mcpSecurity.js';
 const PKG_ROOT = resolvePackageRoot(import.meta.url);
-const BIZ_DAILY_DIR = join(PKG_ROOT, 'output', 'biz-daily');
+/**
+ * 日报目录。**可以用 `WEFLOW_ASSISTANT_BIZ_DAILY_DIR` 指到别处**。
+ *
+ * 为什么加这个注入点：`get_daily_report` 一直是本文件里**唯一从没被执行过的工具分支**，
+ * 原因写在测试文件头上——它读的是模块级常量路径，没有注入点，断言只能写成"没数据/有数据皆可"，
+ * 那种测试看着像覆盖、其实什么也没钉住。同 `WEFLOW_ASSISTANT_EXPORT_ROOT` 的先例（见 `export_chat`）。
+ */
+// 做成函数而不是模块常量：环境变量在**每次调用**时读，测试才能在同一进程里换夹具
+// （同 `export_chat` 的 `WEFLOW_ASSISTANT_EXPORT_ROOT` 做法）。常量只在 import 时求值，
+// 那会让「目录不存在」这类分支永远测不到——写出来的断言就只能是摆设。
+const bizDailyDir = () => process.env.WEFLOW_ASSISTANT_BIZ_DAILY_DIR || join(PKG_ROOT, 'output', 'biz-daily');
+/** 学习回顾目录。同样可注入：否则 `get_review` 的断言只能依赖这台机器上有没有跑过 `review`。 */
+const reviewsDir = () => process.env.WEFLOW_ASSISTANT_REVIEWS_DIR || join(PKG_ROOT, 'output', 'reviews', 'Daily');
 /** 单条聊天消息进上下文的字数上限（见 get_messages：引用消息要放得下正文+被引原文） */
 const MSG_BODY_CHARS = 160;
 // 知识页住在哪几个目录。**两个是有意的**：文章知识库与聊天知识库分开（用户 2026-09-27
 // 要求），所以读的一方要把**两个都读**——只读一个，分出去的那一半就静默地搜不到。
 // 与 Python 的 `_utils.CONCEPT_DIRS` 是同一份清单，有测试钉住两者一致（跨语言没法共用常量）。
-const VAULT_WIKI_DIRS = [
-    join(PKG_ROOT, 'output', 'wechat-vault', 'Wiki', 'Concepts'),
-    join(PKG_ROOT, 'output', 'wechat-vault', 'Chat', 'Concepts'),
-];
+/**
+ * 总览索引在哪：**在概念目录的上一层**——`Wiki/Concepts/` 的兄弟是 `Wiki/00-Overview.md`。
+ *
+ * 抽成函数是为了能直接测：这段路径写错过一次（写成 `join(dir, '00-Overview.md')`，于是一直读不到），
+ * 而当时那条测试只能断言「有内容或没有」这种形状——真实机器上有索引、CI 上没有，两条路都绿。
+ */
+export function wikiIndexPath(conceptDir) {
+    return join(conceptDir, '..', '00-Overview.md');
+}
+/**
+ * 知识库那两条线的 `Concepts` 目录。**同样可注入**（`WEFLOW_ASSISTANT_VAULT_DIR`），
+ * 与上面 `bizDailyDir` / `reviewsDir` 是同一条理由：评测跑在临时家目录里，包内那个
+ * `output/wechat-vault/` 必然为空，`get_concepts` 就只能测到「还没编译过」那一支——
+ * 要给它写用例，就得能把这个根换掉。（做成函数而不是常量：环境变量要在**每次调用**时读。）
+ */
+const vaultDirs = () => {
+    const root = process.env.WEFLOW_ASSISTANT_VAULT_DIR || join(PKG_ROOT, 'output', 'wechat-vault');
+    return [join(root, 'Wiki', 'Concepts'), join(root, 'Chat', 'Concepts')];
+};
+/**
+ * 线的展示名 —— **TS 侧只此一份**。原来有两处各自从路径里找 `Chat` 这个词猜
+ * （`wiki_health` 与 `get_vault_stats`），改词的那天只会改到一半。
+ *
+ * 与 Python 侧 `_utils.LINE_LABELS` 是同一份名单，靠 `test/concept-dirs-agreement.test.ts`
+ * 钉住一致（跨语言没法共享一个常量，这个仓库对这类常量的既有做法就是"各写各的、由测试钉住"）。
+ *
+ * **两条线各自一个根之后这里要跟着改**：路径里不会再有 `Wiki`/`Chat` 这一段。
+ * 到那时 `wiki_health` 已经直接取 Python 给的 `report.lineLabel`（认得线的目录它都会给），
+ * 这里只剩"认不出的目录"这一支要兜底。
+ */
+export const VAULT_LINE_LABELS = { wiki: '文章线', chat: '聊天线' };
+/** 概念目录 → 线 id（`wiki`/`chat`）。按**路径段**认（`…/Wiki/Concepts`）；认不出返回 null，不猜。 */
+export function vaultLineId(dir) {
+    const segments = dir.split(/[\\/]/).map(s => s.toLowerCase());
+    for (const id of Object.keys(VAULT_LINE_LABELS)) {
+        if (segments.includes(id))
+            return id;
+    }
+    return null;
+}
+/** 概念目录 → 线的展示名。**认不出线就返回目录名，不猜成某一条**。 */
+export function vaultLineLabel(dir) {
+    const id = vaultLineId(dir);
+    if (id)
+        return VAULT_LINE_LABELS[id];
+    return dir.split(/[\\/]/).filter(Boolean).pop() || dir;
+}
+/**
+ * 工具参数里的 `line`：`wiki` / `chat` / `all`，不传就是 `wiki`（两条线分开之后，
+ * **默认只看文章线**，要合起来看显式给 `all`）。
+ *
+ * 认不出的值返回 `null` 让调用方**报错**，而不是当 `all`：`line: 'wiki '` 或 `'Wiki'`
+ * 悄悄变成"两条线都搜"的话，"我限定住了"就是句假话，而结果里看不出来。
+ */
+export function toolLine(value) {
+    const raw = String(value ?? '').trim().toLowerCase();
+    if (!raw)
+        return 'wiki';
+    return raw === 'wiki' || raw === 'chat' || raw === 'all' ? raw : null;
+}
+/** 线 id → 展示名（工具输出里说"搜了哪条"用）。 */
+export function lineLabelOf(line) {
+    return line === 'all' ? '两条线' : (VAULT_LINE_LABELS[line] ?? line);
+}
 /**
  * 概念名 → 文件名。**与 `compile_wiki` 是同一套规则**（非法字符换下划线、截到 60 字）。
  *
@@ -71,21 +146,39 @@ function relatedNames(pagePath) {
  *   读不完的图等于没给。截断了要**说出来**（`truncated`），不能默默少给；
  * - **没建页的邻居照旧报数**（`missing`），不静默吞掉。
  */
-export function conceptSubgraph(pageName, depth = 2, maxNodes = 30, wikiDirs = VAULT_WIKI_DIRS) {
+export function conceptSubgraph(pageName, depth = 2, maxNodes = 30, wikiDirs = vaultDirs(), homeDir) {
     // 同 `conceptNeighbors`：传字符串会静默地按字符遍历，所以这里响，不猜。
     if (typeof wikiDirs === 'string') {
         throw new TypeError('conceptSubgraph 的 wikiDirs 要的是目录数组，不是单个字符串');
     }
-    // 邻居可能住在另一个目录（文章概念指向聊天概念、反之亦然），所以查找跨目录
-    const find = (name) => {
-        for (const dir of wikiDirs) {
+    // 邻居可能住在另一个目录（文章概念指向聊天概念、反之亦然），所以查找跨目录。
+    // `homeDir` 只影响**起点那一页**：两条线各有一张同名页时，"第一个有这个文件的目录"
+    // 永远选出文章线那张，于是聊天线那张根本走不到 —— 而调用方（`search_knowledge`）
+    // 正好知道这一趟命中的是哪条线。
+    const find = (name, from) => {
+        const dirs = from ? [from, ...wikiDirs.filter((d) => d !== from)] : wikiDirs;
+        for (const dir of dirs) {
             const candidate = join(dir, safeConceptFile(name));
             if (existsSync(candidate))
                 return candidate;
         }
         return null;
     };
-    if (!find(pageName))
+    // **这一趟在哪条线上**：起点由 `homeDir` 定，之后沿 BFS **往下继承** —— 与图谱那边
+    // "先在页自己那条线里解析、线里没有才回退到另一条"是**同一条规则**。不继承的话每一跳
+    // 都会重新按"第一个有这个文件的目录"选，于是聊天线那一支走着走着就窜到文章线去了。
+    const resolved = new Map();
+    const resolve = (name, from) => {
+        const hit = resolved.get(name);
+        if (hit)
+            return hit;
+        const path = find(name, from);
+        if (path)
+            resolved.set(name, path);
+        return path;
+    };
+    const start = resolve(pageName, homeDir);
+    if (!start)
         return { levels: [], truncated: false, missing: 0 };
     const seen = new Set([pageName]);
     const levels = [];
@@ -96,13 +189,14 @@ export function conceptSubgraph(pageName, depth = 2, maxNodes = 30, wikiDirs = V
         const level = [];
         const next = [];
         for (const from of frontier) {
-            const fromPath = find(from);
+            const fromPath = resolved.get(from) || resolve(from);
             if (!fromPath)
                 continue;
+            const home = dirname(fromPath);
             for (const name of relatedNames(fromPath)) {
                 if (seen.has(name))
                     continue;
-                const target = find(name);
+                const target = resolve(name, home);
                 if (!target) {
                     missing += 1;
                     continue;
@@ -142,7 +236,7 @@ export function conceptBrief(text) {
  *
  * 有页的邻居连定义一起给；没有页的只报个数（`missing`），免得模型去追一个取不到的名字。
  */
-export function conceptNeighbors(pageName, wikiDirs = VAULT_WIKI_DIRS) {
+export function conceptNeighbors(pageName, wikiDirs = vaultDirs()) {
     // **传字符串会静默地按字符遍历**（`for (const dir of 'D:\vault')` 挨个字符看过去），
     // 于是 `join('D', '某概念.md')` 不存在，函数安静地回一句「没有邻居」。2026-09-27 把参数
     // 从单个目录改成目录数组时，测试里正好踩到这个——类型拦得住 `src/`（`tsc` 覆盖它），
@@ -196,12 +290,20 @@ function fmtTime(ts) {
  *
  * 与 `fmtTime`（给用户看的工具输出用 `9/23 12:20`）**故意不同**：转录这一行的形状要和
  * Python 侧逐字一致，见 `transcriptLine`。改 `fmtTime` 会连带改用户看到的东西，所以这里单独一个。
+ *
+ * **时区也是契约的一部分，而且是固定 +8（北京时间），不是本机时区**：Python 那边写的是
+ * `TZ = timezone(timedelta(hours=8))`（`scripts/reply_debt.py:39`），同一段对话从面板进来
+ * 与从命令行进来必须是同一串字符。用 `getHours()` 取本机时区，在非 +8 的机器上两边会差几小时
+ * ——CI（UTC）实测差 8 小时：TS 出 `09-23 04:00`、Python 出 `09-23 12:00`。
+ * 中国没有夏令时，固定 +8 是精确的。要改成"跟随本机时区"，得连 Python 的欠账天数一起改
+ * （那里用同一个 TZ 算"等了多少天"），不是改这一行的事。
  */
 function transcriptTime(ts) {
     const n = Number(ts);
-    const d = n > 1e12 ? new Date(n) : new Date(n * 1000);
+    const shifted = new Date((n > 1e12 ? n : n * 1000) + 8 * 3600_000);
     const pad = (value) => String(value).padStart(2, '0');
-    return `${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+    return `${pad(shifted.getUTCMonth() + 1)}-${pad(shifted.getUTCDate())} `
+        + `${pad(shifted.getUTCHours())}:${pad(shifted.getUTCMinutes())}`;
 }
 /** 单条消息进转录的截断长度。**必须等于** `scripts/reply_debt.py` 的 `DRAFT_MSG_CHARS`。 */
 export const TRANSCRIPT_MSG_CHARS = 160;
@@ -393,16 +495,90 @@ export function extractText(html) {
     return stripTags(seg);
 }
 /** 确保数据库已连接 (connect 幂等, 已连接时直接返回) */
+/**
+ * 抓页面 HTML：微信内置浏览器 UA + Referer 绕 WAF，最多试两次。`read_favorite` 与 `fetch_article` 共用。
+ *
+ * `maxRedirects > 0` 时**自己跟跳转并逐跳复检白名单**：默认的 `redirect: 'follow'` 只看入口，
+ * 一次 302 就能把白名单绕过去（拿到一个被允许的入口，跳到内网地址）。`fetch_article`
+ * 收的是用户/模型给的任意 URL，所以要这道闸；`read_favorite` 收的是用户**自己收藏**的链接，
+ * 保持原行为不动（那里用 denylist，且收藏里本来就有各种站）。
+ */
+async function fetchArticleHtml(url, opts = {}) {
+    const maxRedirects = opts.maxRedirects ?? 0;
+    let current = url;
+    let lastStatus = 0;
+    for (let hop = 0; hop <= maxRedirects; hop++) {
+        if (maxRedirects > 0 && opts.allowHop && !opts.allowHop(current)) {
+            return { status: lastStatus, html: '' }; // 某一跳出了白名单：宁可空手而归
+        }
+        let html = '';
+        let status = 0;
+        let followed = false;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const res = await fetch(current, {
+                    headers: {
+                        'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.38(0x18002633) NetType/WIFI Language/zh_CN',
+                        'Referer': 'https://mp.weixin.qq.com/',
+                        'Accept': 'text/html,application/xhtml+xml',
+                        'Accept-Language': 'zh-CN,zh;q=0.9',
+                    },
+                    ...(maxRedirects > 0 ? { redirect: 'manual' } : {}),
+                    signal: AbortSignal.timeout(20_000),
+                });
+                status = res.status;
+                if (maxRedirects > 0 && status >= 300 && status < 400) {
+                    const location = res.headers.get('location');
+                    if (!location)
+                        return { status, html: '' };
+                    current = new URL(location, current).toString();
+                    followed = true;
+                    break; // 换一跳，重来
+                }
+                html = (await res.text()).slice(0, 500_000);
+                // 正文验证: 必须含 js_content (否则是验证页, 重试)
+                if (res.ok && html.includes('js_content'))
+                    break;
+            }
+            catch { /* 超时/网络错误 → 重试 */ }
+        }
+        if (html)
+            return { status, html };
+        lastStatus = status;
+        // 没跟跳转就走完了两次尝试：就是抓不到，别再拿同一个地址重试下去
+        if (!followed)
+            return { status, html: '' };
+    }
+    return { status: lastStatus, html: '' };
+}
+/** 读响应体但设上限：第三方搜索页可能很大，不让它把内存吃掉（超了就截断，不报错） */
+async function readTextLimited(response, maxBytes) {
+    const buf = await response.arrayBuffer();
+    return Buffer.from(buf).subarray(0, maxBytes).toString('utf8');
+}
+/**
+ * 从抓到的 HTML 里取正文：优先正常页面的 `js_content`，取不到再走 WAF 挑战页的 `content_noencode`。
+ * 返回的文本已按 `maxChars` 截断。
+ */
+function articleTextFromHtml(html, maxChars) {
+    let text = html.includes('js_content') ? extractText(html) : '';
+    if (!text || (text.match(/[一-鿿]/g) || []).length < 50) {
+        const decoded = extractFromChallengePage(html);
+        if (decoded)
+            text = stripTags(decoded);
+    }
+    return text.slice(0, maxChars);
+}
 async function ensureDb() {
     await chatService.connect();
 }
 /** 最近一份**有内容**的日报是哪天，以及那是几天前。算不出来就回空串——不猜。 */
 function lastDailyNote() {
     try {
-        const days = readdirSync(BIZ_DAILY_DIR)
+        const days = readdirSync(bizDailyDir())
             .filter(name => /^\d{4}-\d{2}-\d{2}$/.test(name)).sort().reverse().slice(0, 30);
         for (const day of days) {
-            const file = join(BIZ_DAILY_DIR, day, '.articles.json');
+            const file = join(bizDailyDir(), day, '.articles.json');
             if (!existsSync(file))
                 continue;
             const payload = JSON.parse(readFileSync(file, 'utf8'));
@@ -417,6 +593,14 @@ function lastDailyNote() {
 }
 class ToolInputError extends Error {
 }
+/**
+ * 把待办 id 露给模型。**不露出来它就指不到具体哪一条**——`set_todo_status` 只能靠 id
+ * 或唯一的任务文字定位，而任务文字常常是长句、几条之间又很像。
+ * 给完整 id（CLI 那边支持 id 前缀，但前缀要唯一才安全，这里不赌）。
+ */
+function idTag(t) {
+    return t?.id ? ` [id: ${t.id}]` : '';
+}
 export function boundedToolInteger(value, fallback, maximum, field = 'limit') {
     if (value === undefined || value === null || value === '')
         return fallback;
@@ -571,13 +755,19 @@ export const TOOL_DEFS = [
         type: 'function',
         function: {
             name: 'get_daily_report',
-            description: '获取公众号日报: 某天推送了哪些文章(标题/来源/分类/AI摘要)。适合「今天/某天公众号推了什么」「最近有哪些AI文章」类问题。',
+            description: '获取公众号日报: 推送了哪些文章(标题/来源/分类/AI摘要)。'
+                + '适合「今天/某天公众号推了什么」「最近有哪些AI文章」「搜一下关于X的文章」类问题。'
+                + '**给 date 就是那一天的；不给 date 只给关键词/分类就是跨日期搜**（默认最近 7 天，用 days 调）。'
+                + '要当天那份**人读的日报正文**（不是条目清单）加 full。',
             parameters: {
                 type: 'object',
                 properties: {
-                    date: { type: 'string', description: '日期 YYYY-MM-DD, 默认最新一期' },
+                    date: { type: 'string', description: '日期 YYYY-MM-DD；省略则最新一期（或配合关键词跨日期搜）' },
                     topic: { type: 'string', description: '分类过滤: AI | 学术 | 新闻 | 文学 | 投资' },
-                    keyword: { type: 'string', description: '标题/摘要关键词过滤' },
+                    keyword: { type: 'string', description: '标题/摘要/来源关键词。不给 date 时跨日期搜' },
+                    days: { type: 'number', description: '跨日期搜的时间窗(天), 默认 7, 上限 60' },
+                    full: { type: 'boolean', description: '返回当天日报的正文（人读的那份），而不是条目清单' },
+                    max_chars: { type: 'number', description: 'full 时正文上限, 默认 3000, 上限 6000' },
                     limit: { type: 'number', description: '返回条数, 默认15' },
                 },
             },
@@ -601,12 +791,16 @@ export const TOOL_DEFS = [
         type: 'function',
         function: {
             name: 'get_weread',
-            description: '查看用户微信读书数据: 书架(shelf)、笔记(notebooks)、搜索书(search)。适合「我在读什么书」「某本书的笔记」类问题。',
+            description: '查看用户微信读书数据。mode: shelf(书架) | notebooks(有笔记的书) | search(按书名搜) '
+                + '| stats(近期阅读时长) | book(某本书详情+我的进度) | review(某本书的热门书评) '
+                + '| discover(推荐/相似书) | profile(累计阅读画像)。适合「我在读什么书」「某本书讲什么」「读了多少」类问题。'
+                + 'book / review 需要先用 search 拿到 book_id。',
             parameters: {
                 type: 'object',
                 properties: {
-                    mode: { type: 'string', description: 'shelf | notebooks | search, 默认 shelf' },
+                    mode: { type: 'string', description: 'shelf | notebooks | search | stats | book | review | discover | profile, 默认 shelf' },
                     keyword: { type: 'string', description: 'search 模式的书名关键词' },
+                    book_id: { type: 'string', description: 'book / review 模式的书籍 id（search 或 shelf 的结果里有）' },
                 },
             },
         },
@@ -615,11 +809,13 @@ export const TOOL_DEFS = [
         type: 'function',
         function: {
             name: 'get_todos',
-            description: '查看用户从聊天记录提取的待办任务清单(含优先级和截止时间)。适合「我最近有什么待办」「有什么紧急的事」类问题。',
+            description: '查看用户从聊天记录提取的待办任务清单(含优先级和截止时间)。适合「我最近有什么待办」「有什么紧急的事」类问题。'
+                + '每条后面方括号里的 id 用来改某一条的状态（set_todo_status 需要它）。按紧急度分组看用 group_by。',
             parameters: {
                 type: 'object',
                 properties: {
                     status: { type: 'string', description: 'pending | done, 默认 pending' },
+                    group_by: { type: 'string', description: '传 urgency 就按紧急度分组列出' },
                 },
             },
         },
@@ -702,6 +898,12 @@ export const TOOL_DEFS = [
                 type: 'object',
                 properties: {
                     query: { type: 'string', description: '要找的意思，用自然语言描述' },
+                    line: {
+                        type: 'string',
+                        description: '搜哪一条知识库：wiki=公众号文章线与聊天记录里的文章（默认）、'
+                            + 'chat=你的微信聊天记录、all=两条都搜。**默认只搜 wiki**，'
+                            + '问"我们聊过什么"「上次说的那个」这类一定要给 chat 或 all，否则会搜不到。',
+                    },
                     top_k: { type: 'number', description: '要几条，默认 8，上限 20' },
                     confirm: {
                         type: 'boolean',
@@ -734,7 +936,8 @@ export const TOOL_DEFS = [
         type: 'function',
         function: {
             name: 'search_knowledge',
-            description: '搜索**本地知识库**（从公众号文章沉淀的 Wiki 概念页与学习日报），适合查概念解释、找之前整理过的知识。'
+            description: '搜索**本地知识库**的概念页（公众号文章沉淀的是一条线、你自己的微信对话沉淀的是另一条），'
+                + '适合查概念解释、找之前整理过的知识。**默认只搜文章那条线**，`line` 可以换成聊天那条或两条都搜。'
                 + '**返回时会一并给出这一页连到的相关概念（每个一句定义）**——可以顺着它们再用本工具逐跳查下去，'
                 + '这样一次追问能走开一小块知识，而不是停在一个孤立页面上。'
                 + '（聊天里说过什么用 search_chats；助手记得的关于你的事用 search_memory）',
@@ -742,6 +945,13 @@ export const TOOL_DEFS = [
                 type: 'object',
                 properties: {
                     keyword: { type: 'string', description: '概念名或关键词, 如 RAG、Agent' },
+                    line: {
+                        type: 'string',
+                        description: '搜哪一条知识库：wiki=公众号文章沉淀的概念（默认）、'
+                            + 'chat=你自己的微信对话沉淀的概念、all=两条都搜。'
+                            + '**默认只搜 wiki**；问"我们聊过的某个概念"要给 chat 或 all。'
+                            + '同一个概念名两条线可能各有一张页（那是设计），返回里会指明给的是哪一条。',
+                    },
                     depth: { type: 'integer', description: '沿「相关概念」走几跳：默认 1 只给直接邻居，2 能一次看到这个概念周围的生态（最多 3）' },
                 },
                 required: ['keyword'],
@@ -752,7 +962,8 @@ export const TOOL_DEFS = [
         type: 'function',
         function: {
             name: 'get_stats',
-            description: '获取用户本地微信数据统计(会话数/收藏总数等)。',
+            description: '本地数据总览：会话数、收藏总数、日报文章数与覆盖天数、主题分布、概念页数。'
+                + '适合「我一共有多少数据」这类总览问题；单看公众号推送用 get_reading_stats。',
             parameters: { type: 'object', properties: {} },
         },
     },
@@ -805,6 +1016,172 @@ export const TOOL_DEFS = [
             },
         },
     },
+    {
+        type: 'function',
+        function: {
+            name: 'list_skills',
+            description: '列出本机装好的技能包(名字+一句话说明+版本)。技能是一份说明文档,'
+                + '用 read_skill 读它的正文再照着做；不要凭名字猜它怎么用。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: '可选：按关键词过滤（匹配 id、名称、说明和触发词）' },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'read_skill',
+            description: '读取某个技能包的完整说明（SKILL.md 正文）。要用某个技能前先读它。'
+                + 'id 用 list_skills 查到的那个。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string', description: '技能 id，如 wechat-article-extract' },
+                },
+                required: ['id'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_contacts',
+            description: '列出通讯录里的联系人（显示名、备注、昵称）。**不含 wxid 等本机标识**，'
+                + '只有能叫得出名字的人。'
+                + '（要看最近跟谁聊过用 list_sessions；要按名字查某个会话的聊天用 get_messages）',
+            parameters: {
+                type: 'object',
+                properties: {
+                    keyword: { type: 'string', description: '按名字过滤（可省略）' },
+                    limit: { type: 'number', description: '最多几条, 默认 50, 上限 200' },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'get_review',
+            description: '读某一天的学习回顾（对当天日报文章做的二次整理：要点、联系、值得回看的）。'
+                + '**与 get_daily_report 不是一回事**：那个是当天日报的原始条目清单，这个是复盘。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    date: { type: 'string', description: '日期 YYYY-MM-DD，省略则取最近一份' },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'get_concepts',
+            description: '读知识库的两份总览索引（文章线、聊天线各一份）。这是**目录**，'
+                + '用来回答"我的知识库里都有什么"；要按名字找**某一页**的内容用 search_knowledge。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    limit: { type: 'number', description: '每份索引最多返回多少行, 默认 40' },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'fetch_article',
+            description: '抓取一篇公众号文章的正文（需要完整链接）。只接受 https 的 mp.weixin.qq.com 链接。'
+                + '与 read_favorite 的区别：那个从你自己的收藏里找，这个由用户给出链接。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: '公众号文章完整链接' },
+                    max_chars: { type: 'number', description: '正文上限, 默认 3000, 上限 6000' },
+                },
+                required: ['url'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'search_public',
+            description: '在公开的公众号文章里按关键词搜标题与摘要（走第三方搜索页）。'
+                + '只搜公开文章，搜不到你自己的收藏、聊天记录或知识库。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    keyword: { type: 'string', description: '搜索词' },
+                    limit: { type: 'number', description: '最多几条, 默认 8, 上限 20' },
+                },
+                required: ['keyword'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'format_article',
+            description: '把 Markdown 转成能直接粘进公众号编辑器的 HTML 片段（纯本地转换，不联网、不写文件）。'
+                + '主题名用 list_themes 查。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    // 参数名保持 `content` —— 这个名字在 MCP 那条路上已经被外部客户端用了，
+                    // 改名的代价是别人的调用直接失效（工具名不变、参数变了，最难查的那种坏法）
+                    content: { type: 'string', description: '要排版的 Markdown 正文' },
+                    theme: { type: 'string', description: '主题名（省略用 default）' },
+                },
+                required: ['content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_themes',
+            description: '列出可用的公众号排版主题（配合 format_article 用）。',
+            parameters: { type: 'object', properties: {} },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'lint_wiki',
+            description: '知识库体检：断链、孤儿页、空页、同名页。**只读**，不改任何页。',
+            parameters: { type: 'object', properties: {} },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'check_skills',
+            description: '技能体检：报出读不出来的 SKILL.md、跨目录同名、id 不合规范、被禁用的技能。'
+                + '与 list_skills 的区别：那个是清单，这个是**问题清单**。',
+            parameters: { type: 'object', properties: {} },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'set_todo_status',
+            description: '把一条待办标记为已完成 / 取消完成。**不能删除待办、不能新增**。'
+                + '要精确指到那一条：优先用 get_todos 给出的 id；也可以给一段任务文字，'
+                + '但**匹配到零条或多条都会被拒绝**（猜错条目比拒绝更糟）。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string', description: '待办 id（get_todos 输出里的那个）' },
+                    task: { type: 'string', description: '或用任务文字精确匹配（必须唯一）' },
+                    status: { type: 'string', description: 'done = 已完成, pending = 取消完成' },
+                },
+                required: ['status'],
+            },
+        },
+    },
 ];
 /**
  * MCP 那条路看得见的工具表。
@@ -825,6 +1202,10 @@ export const TOOL_DEFS = [
 export const MCP_EXCLUDED = {
     save_memory: 'MCP 没有微信用户身份，挂的记忆桶是单独一条，让它写没有意义',
     look_at_image: 'MCP 只把工具返回的文本交给客户端，它挂进侧信道的图没人接，回话会变成一句假话',
+    // 这条是**故意留在外面的**（docs/MCP.md 的天花板：「mutating todos ... stay out」）：
+    // 助手在微信/面板里可以替你翻转一条待办状态，但外部 MCP 客户端不行——
+    // 那条路上没有"你"，只有调用方；一条机器指令顺手改掉你的待办，不该是默认能力。
+    set_todo_status: '待办是本地状态，MCP 那条路上没有用户可确认；改状态请在微信/面板里说，或用 CLI 的两段式 todos done',
 };
 export const MCP_TOOL_DEFS = TOOL_DEFS.filter(tool => !(tool.function.name in MCP_EXCLUDED));
 /** 脚本类工具的失败回话：桥接层已经分好类（超时/退出码/没有 JSON/脚本自己报错），
@@ -1116,38 +1497,12 @@ export async function executeTool(name, args, ctx) {
                 }
                 if (!isSafeUrl(art.link))
                     return `(链接不安全, 拒绝抓取: ${art.link.slice(0, 60)})`;
-                // 微信内置浏览器 UA + Referer 绕 WAF (与 biz_daily.py 同策略)
-                let html = '';
-                let status = 0;
-                for (let attempt = 0; attempt < 2; attempt++) {
-                    try {
-                        const res = await fetch(art.link, {
-                            headers: {
-                                'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.38(0x18002633) NetType/WIFI Language/zh_CN',
-                                'Referer': 'https://mp.weixin.qq.com/',
-                                'Accept': 'text/html,application/xhtml+xml',
-                                'Accept-Language': 'zh-CN,zh;q=0.9',
-                            },
-                            signal: AbortSignal.timeout(20_000),
-                        });
-                        status = res.status;
-                        html = (await res.text()).slice(0, 500_000);
-                        // 正文验证: 必须含 js_content (否则是验证页, 重试)
-                        if (res.ok && html.includes('js_content'))
-                            break;
-                    }
-                    catch { /* 超时/网络错误 → 重试 */ }
-                }
+                // 微信内置浏览器 UA + Referer 绕 WAF（与 biz_daily.py 同策略）；
+                // 这段与 fetch_article 是同一份实现——两处各写一份必然会漂
+                const { status, html } = await fetchArticleHtml(art.link);
                 if (!html)
                     return `(抓取失败 HTTP ${status})`;
-                // 路径1: 正常页面 js_content; 路径2: WAF 挑战页 content_noencode 兜底
-                let text = html.includes('js_content') ? extractText(html) : '';
-                if (!text || (text.match(/[\u4e00-\u9fff]/g) || []).length < 50) {
-                    const decoded = extractFromChallengePage(html);
-                    if (decoded)
-                        text = stripTags(decoded);
-                }
-                text = text.slice(0, maxChars);
+                let text = articleTextFromHtml(html, maxChars);
                 if (html.includes('已被发布者删除'))
                     return `(「${art.title}」已被发布者删除)`;
                 if (!text.trim() || (text.match(/[\u4e00-\u9fff]/g) || []).length < 20) {
@@ -1156,17 +1511,76 @@ export async function executeTool(name, args, ctx) {
                 return `「${art.title || '无标题'}」(${art.source_name || '未知来源'}) 正文:\n${text}`;
             }
             case 'get_daily_report': {
-                const dates = existsSync(BIZ_DAILY_DIR)
-                    ? readdirSync(BIZ_DAILY_DIR).filter(d => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse()
+                const dates = existsSync(bizDailyDir())
+                    ? readdirSync(bizDailyDir()).filter(d => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse()
                     : [];
                 if (!dates.length)
                     return '(还没有日报数据, 先运行 biz_daily 生成)';
-                const date = String(args.date || dates[0]);
-                const articlesFile = join(BIZ_DAILY_DIR, date, '.articles.json');
-                if (!existsSync(articlesFile))
+                const readArticles = (date) => {
+                    const file = join(bizDailyDir(), date, '.articles.json');
+                    if (!existsSync(file))
+                        return null;
+                    try {
+                        const raw = JSON.parse(readFileSync(file, 'utf8'));
+                        return Array.isArray(raw) ? raw : (raw.articles || Object.values(raw));
+                    }
+                    catch {
+                        return null;
+                    }
+                };
+                const fmt = (a) => {
+                    const summary = (a.summary || '').replace(/\s+/g, ' ').slice(0, 80);
+                    const where = a.date ? `${a.date} ` : '';
+                    return `· ${where}[${a.topic}] ${a.title} (${a.source})${summary ? `\n  ${summary}` : ''}`;
+                };
+                const limit = boundedToolInteger(args.limit, 15, 30);
+                // 不给 date 但给了关键词 → 跨日期搜（MCP 那边原本叫 search_articles，两个工具搜的
+                // 是同一批文章、只是范围不同，模型无从判断该用哪个，所以合并成一个）。
+                const wantDate = args.date ? safeDate(args.date) : null;
+                if (args.date && !wantDate)
+                    return `(日期格式不对: ${args.date}，要 YYYY-MM-DD)`;
+                if (!wantDate && (args.keyword || args.topic)) {
+                    const days = boundedToolInteger(args.days, 7, 60);
+                    const window = dates.slice(0, days);
+                    const hits = [];
+                    let scanned = 0;
+                    for (const d of window) {
+                        const arts = readArticles(d);
+                        if (!arts)
+                            continue;
+                        scanned += arts.length;
+                        for (const a of arts) {
+                            if (args.topic && a.topic !== args.topic)
+                                continue;
+                            if (args.keyword) {
+                                const kw = String(args.keyword).toLowerCase();
+                                const hay = `${a.title || ''} ${a.summary || ''} ${a.source || ''}`.toLowerCase();
+                                if (!hay.includes(kw))
+                                    continue;
+                            }
+                            hits.push({ ...a, date: d });
+                        }
+                    }
+                    if (!hits.length) {
+                        return `(最近 ${window.length} 天的日报里（共 ${scanned} 篇）没有匹配`
+                            + `${args.keyword ? `「${args.keyword}」` : `主题 ${args.topic}`} 的文章)`;
+                    }
+                    return `最近 ${window.length} 天里匹配 ${hits.length} 篇（共扫 ${scanned} 篇）:\n`
+                        + hits.slice(0, limit).map(fmt).join('\n');
+                }
+                const date = wantDate || dates[0];
+                const all = readArticles(date);
+                if (!all)
                     return `(${date} 没有日报。可用日期: ${dates.slice(0, 5).join(', ')})`;
-                const raw = JSON.parse(readFileSync(articlesFile, 'utf8'));
-                const all = Array.isArray(raw) ? raw : (raw.articles || Object.values(raw));
+                // `full`：给的是当天那份人读的日报正文（README.md），不是条目清单。
+                // 不加这个参数，模型想"把那天的日报念一段"就只能拿到标题列表。
+                if (args.full) {
+                    const readme = join(bizDailyDir(), date, 'README.md');
+                    if (!existsSync(readme))
+                        return `(${date} 没有日报正文文件，只有条目)`;
+                    const maxChars = boundedToolInteger(args.max_chars, 3000, 6000);
+                    return `${date} 日报正文（${all.length} 篇）:\n${readFileSync(readme, 'utf8').slice(0, maxChars)}`;
+                }
                 let list = all;
                 if (args.topic)
                     list = list.filter(a => a.topic === args.topic);
@@ -1174,7 +1588,6 @@ export async function executeTool(name, args, ctx) {
                     const kw = String(args.keyword).toLowerCase();
                     list = list.filter(a => (a.title || '').toLowerCase().includes(kw) || (a.summary || '').toLowerCase().includes(kw));
                 }
-                const limit = boundedToolInteger(args.limit, 15, 30);
                 if (!list.length)
                     return `(${date} 日报共 ${all.length} 篇, 过滤后无匹配)`;
                 const byTopic = {};
@@ -1182,10 +1595,7 @@ export async function executeTool(name, args, ctx) {
                     byTopic[a.topic] = (byTopic[a.topic] || 0) + 1;
                 const topicStat = Object.entries(byTopic).map(([t, n]) => `${t}${n}篇`).join(' ');
                 return `${date} 日报共 ${all.length} 篇 (${topicStat}), 匹配 ${list.length} 篇:\n` +
-                    list.slice(0, limit).map(a => {
-                        const summary = (a.summary || '').replace(/\s+/g, ' ').slice(0, 80);
-                        return `· [${a.topic}] ${a.title} (${a.source})${summary ? `\n  ${summary}` : ''}`;
-                    }).join('\n');
+                    list.slice(0, limit).map(fmt).join('\n');
             }
             case 'get_sns': {
                 await ensureDb();
@@ -1240,6 +1650,60 @@ export async function executeTool(name, args, ctx) {
                         return `有笔记的书 ${r.data.books.length} 本:\n` +
                             r.data.books.slice(0, 15).map((b) => `· ${titleOf(b)} (${authorOf(b)}) — ${b.noteCount || 0} 条笔记`).join('\n');
                     }
+                    if (mode === 'profile') {
+                        const r = await wereadService.profile();
+                        if (!r.ok || !r.data)
+                            return `(读不到阅读画像: ${r.error || ''})`;
+                        const p = r.data;
+                        return `阅读画像: ${p.name || '(未给昵称)'}\n`
+                            + `累计阅读 ${Math.round((p.totalReadTime || 0) / 60)} 分钟、${p.totalReadDays || 0} 天\n`
+                            + `书架 ${p.totalBooks || 0} 本，读完 ${p.totalFinished || 0} 本`;
+                    }
+                    if (mode === 'stats') {
+                        const r = await wereadService.readData('monthly');
+                        if (!r.ok || !r.data)
+                            return `(读不到阅读统计: ${r.error || ''})`;
+                        const d = r.data;
+                        const top = (d.readLongest || []).slice(0, 5).map((x) => `· ${x?.book?.title || x?.albumInfo?.title || '(未知)'} ${Math.round((x?.readTime || 0) / 60)} 分钟`);
+                        return `近期阅读 ${Math.round((d.totalReadTime || 0) / 60)} 分钟、读了 ${d.readDays || 0} 天`
+                            + `，日均 ${Math.round((d.dayAverageReadTime || 0) / 60)} 分钟`
+                            + (top.length ? `\n读得最久的:\n${top.join('\n')}` : '');
+                    }
+                    if (mode === 'book') {
+                        const bookId = String(args.book_id || '').trim();
+                        if (!bookId)
+                            return '(book 模式需要 book_id —— 先用 search 模式按书名找到它)';
+                        const info = await wereadService.bookInfo(bookId);
+                        if (!info.ok || !info.data)
+                            return `(读不到这本书: ${info.error || ''})`;
+                        const b = info.data;
+                        const prog = await wereadService.getProgress(bookId);
+                        const pct = prog.ok && prog.data
+                            ? `\n我的进度: ${prog.data.progress}%${prog.data.chapterTitle ? `（${prog.data.chapterTitle}）` : ''}`
+                            : '';
+                        return `《${b.title}》${b.author || ''}\n评分 ${b.rating ?? '未知'}（${b.ratingCount || 0} 人）`
+                            + `| ${b.category || '未分类'} | ${b.wordCount || '未知'}字${pct}`;
+                    }
+                    if (mode === 'review') {
+                        const bookId = String(args.book_id || '').trim();
+                        if (!bookId)
+                            return '(review 模式需要 book_id —— 先用 search 模式按书名找到它)';
+                        const r = await wereadService.reviews(bookId, 5);
+                        if (!r.ok || !r.data?.reviews?.length)
+                            return `(这本书还没有热门书评: ${r.error || ''})`;
+                        return `热门书评 ${r.data.reviews.length} 条:\n`
+                            + r.data.reviews.map((v) => `· ${String(v.content || '').replace(/\s+/g, ' ').slice(0, 120)}`
+                                + `（${v.user?.name || '匿名'}，${v.rating ? `评 ${v.rating} 分` : '未评分'}，${v.likeCount || 0} 赞）`).join('\n');
+                    }
+                    if (mode === 'discover') {
+                        const bookId = String(args.book_id || '').trim();
+                        const r = bookId ? await wereadService.similar(bookId, 6) : await wereadService.recommend(8);
+                        if (!r.ok || !r.data?.books?.length)
+                            return `(读不到推荐: ${r.error || ''})`;
+                        return (bookId ? '与这本书相似的' : '为你推荐的') + `书 ${r.data.books.length} 本:\n`
+                            + r.data.books.map((b) => `· 《${b.title}》${b.author || ''}${b.rating ? ` 评分 ${b.rating}` : ''}`
+                                + (b.intro ? `\n  ${String(b.intro).replace(/\s+/g, ' ').slice(0, 80)}` : '')).join('\n');
+                    }
                     if (mode === 'search') {
                         const kw = String(args.keyword || '');
                         if (!kw)
@@ -1281,8 +1745,19 @@ export async function executeTool(name, args, ctx) {
                     }
                     return `(没有${status === 'done' ? '已完成' : '待办'}任务)`;
                 }
+                // 分组：`todos remind` 其实就是同一个文件按紧急度重排，所以不另开一个工具，
+                // 加个参数就够（多一个近义工具只会让模型在两者之间瞎挑）
+                if (String(args.group_by || '') === 'urgency') {
+                    const order = { 高: 0, 中: 1, 低: 2 };
+                    const sorted = [...todos].sort((a, b) => (order[a.urgency] ?? 3) - (order[b.urgency] ?? 3));
+                    const groups = {};
+                    for (const t of sorted)
+                        (groups[t.urgency || '未标'] = groups[t.urgency || '未标'] || []).push(t);
+                    return `${status === 'done' ? '已完成' : '待办'} ${todos.length} 项（按紧急度分组）:\n` +
+                        Object.entries(groups).map(([u, list]) => `【${u}】${list.length} 项\n` + list.slice(0, 10).map((t) => `· ${t.task || t.content || t.text || t.title}${t.deadline && t.deadline !== '未提及' ? ` (截止 ${t.deadline})` : ''}${idTag(t)}`).join('\n')).join('\n');
+                }
                 return `${status === 'done' ? '已完成' : '待办'} ${todos.length} 项:\n` +
-                    todos.slice(0, 15).map((t) => `· [${t.urgency || '中'}] ${t.task || t.content || t.text || t.title}${t.deadline && t.deadline !== '未提及' ? ` (截止 ${t.deadline})` : ''}`).join('\n');
+                    todos.slice(0, 15).map((t) => `· [${t.urgency || '中'}] ${t.task || t.content || t.text || t.title}${t.deadline && t.deadline !== '未提及' ? ` (截止 ${t.deadline})` : ''}${idTag(t)}`).join('\n');
             }
             case 'search_chats': {
                 // 跨会话检索：本机 message_fts 索引 + 判断模型挑查询词（**只发候选词与问题，不发聊天内容**）
@@ -1454,6 +1929,9 @@ export async function executeTool(name, args, ctx) {
                 const query = String(args.query || '').trim();
                 if (!query)
                     return '(缺少 query 参数)';
+                const line = toolLine(args.line);
+                if (!line)
+                    return `(line 只能是 wiki / chat / all，收到「${String(args.line)}」)`;
                 const topK = boundedToolInteger(args.top_k, 8, 20, 'top_k');
                 // 外部机器默认只给预览（`semantic_search.py` 没有 --dry-run，按入参说清）
                 if (ctx.requiresConfirm && args.confirm !== true) {
@@ -1461,13 +1939,26 @@ export async function executeTool(name, args, ctx) {
                         + `再把前 ${topK} 条命中的本地片段（可能含聊天或文章原文）发给判断模型 Jev 重排。`);
                 }
                 // **查询词走环境变量、不进 argv**：仓库写进测试的隐私纪律（进程列表里看不到正文）
-                const result = await runPythonJson('semantic_search.py', ['search', '--top-k', String(topK)], { env: { WEFLOW_SEARCH_QUERY: query }, timeoutMs: 90_000 });
+                const result = await runPythonJson('semantic_search.py', ['search', '--top-k', String(topK), '--line', line], { env: { WEFLOW_SEARCH_QUERY: query }, timeoutMs: 90_000 });
                 if (!result.ok)
                     return fail('语义检索失败（索引可能还没建：weflow-cli search-index）', result);
-                const rows = Array.isArray(result.data) ? result.data : [];
-                if (!rows.length)
-                    return `(语义检索没有结果「${query}」)`;
-                return `语义检索「${query}」前 ${rows.length} 条：` + String.fromCharCode(10) + rows.map((row) => {
+                if (result.data && typeof result.data.error === 'string') {
+                    return `(语义检索没跑成：${String(result.data.error).slice(0, 120)})`;
+                }
+                if (!result.data || !Array.isArray(result.data.results)) {
+                    // **形状不对要响，不能降级成"没有结果"**：脚本那边 `search` 的输出是一个带
+                    // `line` / `results` 的对象，而"读不到"和"搜不到"在界面上长得一模一样
+                    // （`(语义检索没有结果)`）—— 那正是这个仓库一直在防的那种静默。
+                    return `(语义检索返回了看不懂的形状：${JSON.stringify(result.data).slice(0, 120)})`;
+                }
+                const rows = result.data.results;
+                const note = String(result.data.note || '');
+                const scope = String(result.data.lineLabel || lineLabelOf(line));
+                if (!rows.length) {
+                    return `(语义检索在${scope}里没有结果「${query}」${note ? '：' + note : ''}`
+                        + `${line === 'all' ? ')' : '；`line: \'all\'` 两条线一起搜)'}`;
+                }
+                return `语义检索「${query}」（范围：${scope}）前 ${rows.length} 条：` + String.fromCharCode(10) + rows.map((row) => {
                     const title = String(row.title || row.source || '(无标题)').slice(0, 40);
                     const score = typeof row.score === 'number' ? `（${row.score.toFixed(2)}）` : '';
                     const text = privacyGate.maskMessageBody(String(row.text || row.content || '').replace(/\s+/g, ' ').slice(0, 80));
@@ -1516,16 +2007,24 @@ export async function executeTool(name, args, ctx) {
                 const kw = String(args.keyword || '');
                 if (!kw)
                     return '(缺少 keyword 参数)';
-                const liveDirs = VAULT_WIKI_DIRS.filter(dir => existsSync(dir));
-                if (!liveDirs.length)
+                const line = toolLine(args.line);
+                if (!line)
+                    return `(line 只能是 wiki / chat / all，收到「${String(args.line)}」)`;
+                const all = vaultDirs().filter(dir => existsSync(dir));
+                if (!all.length)
                     return '(知识库尚未生成, 先运行 weflow-cli wiki compile)';
-                // **两个目录一起搜**（文章知识库 + 聊天知识库）。分开是用户要求的，但"分开"
-                // 不该变成"搜不到"——只读一个的话，另一半会静默缺席。
+                // **默认只搜文章线**（两条线分开是用户要求的）；`line: 'all'` 才两条一起搜。
+                // 范围一定要写在输出里：不说的话，"这一条线里没有"会被读成"整个知识库里没有"。
+                const liveDirs = line === 'all' ? all : all.filter(dir => vaultLineId(dir) === line);
+                if (!liveDirs.length) {
+                    return `(${lineLabelOf(line)}还没有概念页——知识库里现在只有${all.map(vaultLineLabel).join('、')}；`
+                        + `要看那些用 line: 'all')`;
+                }
                 const entries = [];
                 let total = 0;
                 for (const dir of liveDirs) {
                     // 标注来源，好让模型（和读日志的人）知道这条来自哪个知识库
-                    const where = /[\\/]Chat[\\/]/.test(dir) ? '聊天' : '文章';
+                    const where = vaultLineId(dir) === 'chat' ? '聊天' : '文章';
                     for (const file of readdirSync(dir).filter(f => f.endsWith('.md'))) {
                         entries.push({ dir, file, where });
                         total += 1;
@@ -1545,24 +2044,34 @@ export async function executeTool(name, args, ctx) {
                         const at = text.toLowerCase().indexOf(kw.toLowerCase());
                         if (at === -1)
                             return null;
-                        const line = text.slice(Math.max(0, at - 80), at + 160)
+                        // （局部变量别叫 `line`：外层那个 `line` 是"搜哪条知识库"，同名会把它遮住）
+                        const snippetLine = text.slice(Math.max(0, at - 80), at + 160)
                             .split('\n').find(l => l.includes(kw)) || '';
-                        return { ...e, snippet: line.trim().slice(0, 180) };
+                        return { ...e, snippet: snippetLine.trim().slice(0, 180) };
                     }).filter((e) => e !== null)
                         .slice(0, 5);
-                    if (!contentHits.length)
-                        return `(知识库未收录「${kw}」, 共 ${total} 个概念页)`;
-                    return '正文提及「' + kw + '」的概念页:' + '\n'
+                    if (!contentHits.length) {
+                        // **说清是哪个范围里没收录**：只写"知识库未收录"会被读成整个知识库都没有
+                        return `(${lineLabelOf(line)}没收录「${kw}」, 这一趟看了 ${total} 个概念页`
+                            + (line === 'all' ? ')' : '；`line: \'all\'` 可以连另一条线一起搜)');
+                    }
+                    return `正文提及「${kw}」的概念页（${lineLabelOf(line)}）:` + '\n'
                         + contentHits.map(e => `· ${e.file.replace('.md', '')}（${e.where}）: ${e.snippet}`).join('\n');
                 }
                 const hit = hits[0];
                 const name = hit.file.replace('.md', '');
                 const page = readFileSync(join(hit.dir, hit.file), 'utf8');
+                // 两条线各有一张同名页是**设计**（两个命名空间分开）。只给第一条会让模型以为另一条
+                // 没有这个概念 —— 而它可能正是用户问的那一条（"我们聊过的"vs"公众号里读到的"）。
+                const alsoIn = hits.filter(h => h.where !== hit.where).map(h => h.where);
+                const alsoNote = alsoIn.length ? `（另一个同名页在${alsoIn.join('、')}知识库：line: 'all' 两条都看）` : '';
                 // **顺带把邻居给出去**（见 `conceptNeighbors`）：一次调用拿到"这个概念 + 连着它的一小块子图"。
                 // 不点明"可以再用本工具查其中任意一个"的话，模型会把它当装饰性文字读过去。
                 const depth = boundedToolInteger(args.depth, 1, 3, 'depth');
-                const { levels, truncated, missing } = conceptSubgraph(name, depth);
-                const out = [`「${name}」概念页（${hit.where}知识库）:`, page.slice(0, 2000)];
+                // **从命中的那一条线开始**（`hit.dir`）：同名概念两条线各一张，不指定起点的话
+                // 永远走文章线那张 —— 而上面刚刚才告诉模型"另一条线也有这个概念"
+                const { levels, truncated, missing } = conceptSubgraph(name, depth, 30, vaultDirs(), hit.dir);
+                const out = [`「${name}」概念页（${hit.where}知识库）${alsoNote}:`, page.slice(0, 2000)];
                 if (levels.length) {
                     out.push('', depth > 1
                         ? `—— 它周围的概念（${depth} 跳；「←」标出是从哪个概念连过来的）——`
@@ -1576,7 +2085,7 @@ export async function executeTool(name, args, ctx) {
                     });
                     // 封顶了要**说出来**：默默少给的话，模型会以为这就是全部
                     if (truncated)
-                        out.push(`（图太大，只给了前 ${levels.flat().length} 个概念；
+                        out.push(`（图太大，只给了前 ${levels.flat().length} 个概念；
 想看某个分支可以单独查它）`);
                 }
                 if (missing)
@@ -1587,7 +2096,48 @@ export async function executeTool(name, args, ctx) {
                 await ensureDb();
                 const sessions = await chatService.listSessions(undefined, 1000);
                 const fav = await chatService.getFavorites({ limit: 1 });
-                return `会话数: ${sessions.length}\n收藏总数: ${fav.success ? fav.total : '未知'}`;
+                const lines = [`会话数: ${sessions.length}`, `收藏总数: ${fav.success ? fav.total : '未知'}`];
+                // 知识库那一半：MCP 的手写 get_stats 一直有、助手这边缺。同一个工具名在两个界面
+                // 报的东西不一样，是最容易让人误判成数据丢了的那种不一致。
+                const dates = existsSync(bizDailyDir())
+                    ? readdirSync(bizDailyDir()).filter(d => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort()
+                    : [];
+                let articleCount = 0;
+                const topics = {};
+                for (const d of dates) {
+                    const file = join(bizDailyDir(), d, '.articles.json');
+                    if (!existsSync(file))
+                        continue;
+                    try {
+                        const raw = JSON.parse(readFileSync(file, 'utf8'));
+                        const arts = Array.isArray(raw) ? raw : (raw.articles || []);
+                        articleCount += arts.length;
+                        for (const a of arts)
+                            topics[a.topic || '未知'] = (topics[a.topic || '未知'] || 0) + 1;
+                    }
+                    catch { /* 某一天的文件坏了不该让整个统计失败 */ }
+                }
+                if (dates.length) {
+                    lines.push(`日报文章: ${articleCount} 篇，覆盖 ${dates.length} 天（${dates[0]} ~ ${dates[dates.length - 1]}）`);
+                    const top = Object.entries(topics).sort((a, b) => b[1] - a[1]).slice(0, 6);
+                    if (top.length)
+                        lines.push(`主题分布: ${top.map(([t, n]) => `${t}${n}`).join('、')}`);
+                }
+                else {
+                    lines.push('日报文章: 还没有日报数据');
+                }
+                const conceptCounts = [];
+                for (const dir of vaultDirs()) {
+                    const idx = wikiIndexPath(dir);
+                    if (!existsSync(idx))
+                        continue;
+                    const m = readFileSync(idx, 'utf8').match(/共\s*(\d+)\s*个概念/);
+                    if (m)
+                        conceptCounts.push(`${vaultLineLabel(dir)} ${m[1]}`);
+                }
+                if (conceptCounts.length)
+                    lines.push(`概念页: ${conceptCounts.join('、')}`);
+                return lines.join('\n');
             }
             case 'get_reading_stats': {
                 const days = boundedToolInteger(args.days, 7, 90, 'days');
@@ -1626,6 +2176,299 @@ export async function executeTool(name, args, ctx) {
                 const added = ctx.memory.addFact(ctx.userId, content);
                 return added ? '(已存入长期记忆)' : '(与已有记忆重复, 未保存)';
             }
+            case 'list_skills': {
+                const scan = scanSkills();
+                const q = String(args.query || '').trim().toLowerCase();
+                const hit = (s) => !q || [s.id, s.name, s.description, ...s.triggers].some(x => String(x).toLowerCase().includes(q));
+                const rows = scan.skills.filter(hit);
+                if (!rows.length) {
+                    // 一个技能都没有时**说清是"没装"还是"目录配错了"**：后者会把用户引到错的地方找
+                    if (!scan.skills.length) {
+                        return `本机没有扫描到技能。技能根目录：${skillRoots().join('、')}`
+                            + (scan.missingRoots.length ? `（其中这些目录不存在：${scan.missingRoots.join('、')}）` : '');
+                    }
+                    return `没有匹配「${args.query}」的技能（本机共有 ${scan.skills.length} 个）`;
+                }
+                const disabled = disabledIds();
+                const lines = rows.map(s => {
+                    const state = skillState(s, disabled);
+                    const tag = state === 'disabled' ? '[已禁用] ' : '';
+                    const ver = s.version ? ` v${s.version}` : '';
+                    return `· ${tag}${s.id}${ver}：${s.name} —— ${s.description || '（无描述）'}`;
+                });
+                lines.push(`（共 ${rows.length} 个，正文用 read_skill 读）`);
+                return lines.join('\n');
+            }
+            case 'read_skill': {
+                const id = String(args.id || '').trim();
+                if (!id)
+                    return '(参数错误: 缺少技能 id)';
+                const body = readSkillBody(id);
+                if (!body.ok)
+                    return body.text;
+                // 技能正文是**磁盘上的内容**，可能含 `</weflow-local-data>` —— 必须包起来再进上下文
+                return frameLocalData(`skill.${id}`, body.text);
+            }
+            case 'list_contacts': {
+                await ensureDb();
+                const keyword = String(args.keyword || '').trim();
+                const limit = boundedToolInteger(args.limit, 50, 200);
+                const contacts = await chatService.listContacts(keyword || undefined, limit);
+                if (!contacts.length) {
+                    return keyword
+                        ? `(通讯录里没有匹配「${keyword}」的名字)`
+                        : '(通讯录是空的或读不到——可以用 check 看本机数据源的状态)';
+                }
+                // **只给名字**：`username` 是 wxid，`avatarUrl` 里也可能带本机标识，
+                // 本仓的纪律是本机标识不进模型上下文（同 speakerLabel 那边的处理）
+                const names = [];
+                for (const c of contacts) {
+                    const n = String(c.remark || c.displayName || c.nickname || '').trim();
+                    if (n && !names.includes(n))
+                        names.push(n);
+                }
+                if (!names.length)
+                    return '(通讯录读到了, 但都没有可显示的名字)';
+                return `通讯录里 ${names.length} 个名字:\n` + names.slice(0, limit).map(n => `· ${n}`).join('\n');
+            }
+            case 'get_review': {
+                const dir = reviewsDir();
+                if (!existsSync(dir)) {
+                    // 说清"这个目录本来就还没生成"，而不是让模型以为"今天没有回顾"
+                    return '(还没有学习回顾——它不是日报自动产的，要单独跑 `weflow-cli review`)';
+                }
+                const files = readdirSync(dir).filter(f => /^Daily-\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+                if (!files.length)
+                    return '(学习回顾目录是空的)';
+                const want = args.date ? safeDate(args.date) : null;
+                if (args.date && !want)
+                    return `(日期格式不对: ${args.date}，要 YYYY-MM-DD)`;
+                const pick = want ? files.find(f => f.includes(want)) : files[0];
+                if (!pick) {
+                    return `(${want} 没有学习回顾。最近几份: ${files.slice(0, 3).map(f => f.slice(6, 16)).join(', ')})`;
+                }
+                const maxChars = boundedToolInteger(args.max_chars, 3000, 6000);
+                const body = readFileSync(join(dir, pick), 'utf8');
+                const date = pick.slice(6, 16);
+                return `${date} 学习回顾:\n${body.slice(0, maxChars)}`;
+            }
+            case 'get_concepts': {
+                const limit = boundedToolInteger(args.limit, 40, 120);
+                const out = [];
+                for (const dir of vaultDirs()) {
+                    const line = dir.split(/[\\/]/).includes('Chat') ? '聊天线' : '文章线';
+                    const index = wikiIndexPath(dir);
+                    if (!existsSync(index)) {
+                        out.push(`【${line}】还没有总览索引（还没编译过这一线的知识库）`);
+                        continue;
+                    }
+                    const text = readFileSync(index, 'utf8');
+                    const rows = text.split(/\r?\n/).filter(l => l.trim()).slice(0, limit);
+                    out.push(`【${line}】${rows.length} 行:\n${rows.join('\n')}`);
+                }
+                return out.join('\n\n');
+            }
+            case 'format_article': {
+                const content = String(args.content || '');
+                if (!content.trim())
+                    return '(参数错误: content 不能为空)';
+                const { formatWeChatArticle } = await import('./wechat-formatter.js');
+                const theme = String(args.theme || 'default');
+                const html = formatWeChatArticle(content, { theme: theme });
+                const preview = html.replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').slice(0, 200);
+                return `主题: ${theme}\n总长度: ${html.length} 字符\n正文预览: ${preview}…\n---\n${html}`;
+            }
+            case 'list_themes': {
+                const { listThemes } = await import('./wechat-formatter.js');
+                const themes = listThemes();
+                if (!themes.length)
+                    return '(没有可用主题)';
+                return `可用主题 ${themes.length} 个:\n`
+                    + themes.map(t => `· ${t.id} — ${t.name}: ${t.description}`).join('\n');
+            }
+            case 'lint_wiki': {
+                // 两个知识库都要查（本仓的分线纪律：只查一个，另一半的断链永远看不见）
+                const parts = [];
+                let totalBad = 0;
+                // **真正体检过几条线。"跳过"不算"没问题"**：CI 上（检出里没有 `output/wechat-vault`）
+                // 两条线都只打「目录不存在，跳过」，而下面那一支原来照样会加一句"两个知识库都没有断链…"
+                // —— 没看过却说干净。用户没编译过知识库时也会撞上同一句话。
+                let checked = 0;
+                for (const dir of vaultDirs()) {
+                    // **线名优先由 Python 那边给**（`report.lineLabel`，源头是 `_utils.LINE_LABELS`）：
+                    // 两条线各自一个根之后聊天线很可能不再叫 `Chat`，按路径猜会把聊天线报成
+                    // **文章线**，还不报错。`guess` 只在目录不存在（来不及问 Python）与自定义
+                    // `--dir` 认不出线时兜底。
+                    const guess = vaultLineLabel(dir);
+                    if (!existsSync(dir)) {
+                        parts.push(`【${guess}】目录不存在，跳过`);
+                        continue;
+                    }
+                    // 超时给 60 秒：本机最大的一条线（3,623 页）实测 **3.4 秒**（脚本里的 O(n²) 修掉之后，
+                    // 见 wiki_lint.py 那条注释），17 倍余量够用。默认的 30 秒曾经也超——那是因为脚本本身慢，
+                    // 不是超时给得小。
+                    const r = await runPythonJson('wiki_lint.py', ['--dir', dir, '--json'], { timeoutMs: 60_000 });
+                    if (!r.ok || !r.data) {
+                        // 失败要说出来：静默跳过会让"体检通过"变成一句假话
+                        parts.push(`【${guess}】体检失败: ${r.error || '读不到结果'}`);
+                        totalBad += 1;
+                        continue;
+                    }
+                    const d = r.data;
+                    const line = d.lineLabel || guess;
+                    const broken = (d.broken || []).length;
+                    const orphans = (d.orphans || []).length;
+                    const empty = (d.empty || []).length;
+                    const dup = Object.keys(d.duplicateTitles || {}).length;
+                    // 跨线同名**不计入问题数**：两条线各留一张同名页是设计（两个命名空间分开），
+                    // 把它算成"要修的"会让人去修一个设计如此的东西。
+                    const cross = (d.crossLineSameName || []).length;
+                    checked += 1;
+                    totalBad += broken + orphans + empty + dup;
+                    parts.push(`【${line}】${d.pages || 0} 张页：断链 ${broken}、孤儿 ${orphans}、空页 ${empty}、同名 ${dup} 组`
+                        + (cross ? `（另有 ${cross} 个概念两条线都有，设计如此）` : ''));
+                }
+                return (checked && !totalBad ? '两个知识库都没有断链/孤儿/空页/同名。\n' : '') + parts.join('\n');
+            }
+            case 'check_skills': {
+                const scan = scanSkills();
+                const disabled = disabledIds();
+                const lines = [`技能目录: ${skillRoots().join('、')}`, `扫描到 ${scan.skills.length} 个技能`];
+                for (const dir of scan.missingRoots)
+                    lines.push(`· 目录不存在: ${dir}`);
+                if (scan.unreadable.length) {
+                    lines.push(`读不出来的 ${scan.unreadable.length} 个（frontmatter 缺失或不闭合）:`);
+                    for (const u of scan.unreadable)
+                        lines.push(`· ${u.file} —— ${u.reason}`);
+                }
+                if (scan.conflicts.length) {
+                    lines.push(`跨目录同名的 ${scan.conflicts.length} 个（靠前的目录胜出）: ${scan.conflicts.map(c => c.id).join('、')}`);
+                }
+                const warned = scan.skills.filter(s => s.notes.length);
+                if (warned.length) {
+                    lines.push(`有提醒的 ${warned.length} 个:`);
+                    for (const w of warned)
+                        for (const n of w.notes)
+                            lines.push(`· ${w.id}: ${n}`);
+                }
+                const off = scan.skills.filter(s => skillState(s, disabled) === 'disabled').map(s => s.id);
+                if (off.length)
+                    lines.push(`已禁用: ${off.join('、')}`);
+                if (!scan.unreadable.length && !scan.conflicts.length && !warned.length) {
+                    lines.push('没有读不出来或撞名的技能。');
+                }
+                return lines.join('\n');
+            }
+            case 'fetch_article': {
+                const url = String(args.url || '').trim();
+                // **严格白名单，不是 denylist**：只认 https 的 mp.weixin.qq.com。
+                // 这条比 read_favorite 那条严，因为那里的链接是用户自己收藏的，这里的 URL 是别人给的。
+                if (!isAllowedWeChatArticleUrl(url)) {
+                    return `(只接受 https 的 mp.weixin.qq.com 文章链接，拒绝抓取: ${url.slice(0, 60)})`;
+                }
+                const maxChars = boundedToolInteger(args.max_chars, 3000, 6000);
+                // 逐跳复检：一次 302 就能把入口白名单绕过去
+                const { status, html } = await fetchArticleHtml(url, { maxRedirects: 3, allowHop: isAllowedWeChatArticleUrl });
+                if (!html)
+                    return `(抓取失败 HTTP ${status} —— 链接可能不是公众号文章，或者跳转到了别处)`;
+                if (html.includes('已被发布者删除'))
+                    return '(这篇文章已被发布者删除)';
+                const body = articleTextFromHtml(html, maxChars);
+                if (!body.trim() || (body.match(/[一-鿿]/g) || []).length < 20) {
+                    return '(抓到了页面但取不出正文——可能是验证页，或者这篇文章要登录/已失效)';
+                }
+                const title = html.match(/<meta[^>]*property="og:title"[^>]*content="([^"]+)"/i)?.[1]
+                    || html.match(/<title>([^<]+)<\/title>/i)?.[1]?.trim() || '';
+                const author = html.match(/var\s+nickname\s*=\s*"([^"]+)"/i)?.[1]
+                    || html.match(/<meta[^>]*property="og:article:author"[^>]*content="([^"]+)"/i)?.[1] || '';
+                // 配图只报数量与前几个链接：正文是纯文本，但图往往就是这篇文章的要点
+                const imgs = [...html.matchAll(/data-src="(https?:\/\/[^"]+)"/g)].map(m => m[1]).slice(0, 5);
+                const head = [title && `标题: ${title}`, author && `公众号: ${author}`].filter(Boolean).join(' | ');
+                const tail = imgs.length ? `\n\n配图 ${imgs.length} 张(前几张):\n${imgs.map(u => `· ${u}`).join('\n')}` : '';
+                return (head ? `${head}\n---\n` : '') + body + tail;
+            }
+            case 'search_public': {
+                const keyword = String(args.keyword || '').trim();
+                if (!keyword)
+                    return '(参数错误: 缺少 keyword)';
+                const limit = boundedToolInteger(args.limit, 8, 20);
+                let html = '';
+                try {
+                    const resp = await fetch(`https://weixin.sogou.com/weixin?type=2&query=${encodeURIComponent(keyword)}`, {
+                        headers: {
+                            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+                            'Referer': 'https://weixin.sogou.com/',
+                            'Accept': 'text/html',
+                            'Accept-Language': 'zh-CN,zh;q=0.9',
+                        },
+                        signal: AbortSignal.timeout(20_000),
+                    });
+                    html = await readTextLimited(resp, 2 * 1024 * 1024);
+                }
+                catch {
+                    return '(搜索失败——检查网络，或者稍后再试（第三方搜索页会限流）)';
+                }
+                const grab = (re, clean) => {
+                    const out = [];
+                    for (const m of html.matchAll(re)) {
+                        const v = clean(m[1]);
+                        if (v)
+                            out.push(v);
+                    }
+                    return out;
+                };
+                const titles = grab(/<h3[^>]*>\s*<a[^>]*>(.*?)<\/a>\s*<\/h3>/gs, s => s.replace(/<em[^>]*>/g, '').replace(/<\/em>/g, '').replace(/<!--[^>]*-->/g, '').trim());
+                const accounts = grab(/<span[^>]*class="[^"]*all-time-y2[^"]*"[^>]*>(.*?)<\/span>/gs, s => s.replace(/<[^>]+>/g, '').trim());
+                const descs = grab(/<p[^>]*class="[^"]*txt-info[^"]*"[^>]*>(.*?)<\/p>/gs, s => s.replace(/<[^>]+>/g, '').replace(/&hellip;/g, '…').replace(/&rarr;/g, '→').replace(/&mdash;/g, '—').trim())
+                    .filter(d => d.length > 10);
+                const count = Math.max(titles.length, accounts.length, descs.length);
+                if (!count) {
+                    return `(没搜到与「${keyword}」相关的公开文章。换个说法、或加上公众号名试试；`
+                        + '找到链接后可以用 fetch_article 抓全文)';
+                }
+                const rows = [];
+                for (let i = 0; i < Math.min(count, limit); i++) {
+                    rows.push(`${i + 1}. ${titles[i] || '(未知标题)'}\n   公众号: ${accounts[i] || '(未知)'}`
+                        + (descs[i] ? `\n   ${descs[i]}` : ''));
+                }
+                return `公开文章里搜「${keyword}」，命中 ${Math.min(count, limit)} 条:\n`
+                    + rows.join('\n')
+                    + '\n（这是第三方搜索页的标题与摘要，不是全文；要正文用 fetch_article 抓）';
+            }
+            case 'set_todo_status': {
+                const status = String(args.status || '');
+                if (status !== 'done' && status !== 'pending')
+                    return '(参数错误: status 只能是 done（已完成）或 pending（取消完成）)';
+                const id = String(args.id || '').trim();
+                const task = String(args.task || '').trim();
+                if (!id && !task)
+                    return '(参数错误: 要给 id 或 task 指到哪一条待办)';
+                let target = id;
+                if (!target) {
+                    // 按任务文字找：**只认唯一**。命中 0 条或 ≥2 条都拒绝——
+                    // 猜错条目比拒绝更糟（用户会以为自己的待办被改了，而改的是另一条）
+                    const listed = await runPythonJson('extract_todos.py', ['list', '--json']);
+                    if (!listed.ok)
+                        return fail('待办读取失败', listed);
+                    const items = Array.isArray(listed.data) ? listed.data : (listed.data?.items || []);
+                    const norm = (s) => String(s || '').replace(/\s+/g, '');
+                    const hit = items.filter(t => norm(t.task).includes(norm(task)));
+                    if (!hit.length)
+                        return `(没有任务文字包含「${task}」的待办)`;
+                    if (hit.length > 1) {
+                        return `(「${task}」匹配到 ${hit.length} 条待办，不能确定是哪一条，请用 id 指定:\n`
+                            + hit.slice(0, 5).map(t => `· ${t.task}`).join('\n') + ')';
+                    }
+                    if (!hit[0].id)
+                        return '(这条待办没有 id——本机的待办文件格式比预期旧，请在电脑上用 `todos done` 处理)';
+                    target = String(hit[0].id);
+                }
+                const r = await runPythonJson('extract_todos.py', [status === 'done' ? 'done' : 'undone', target, '--json']);
+                if (!r.ok)
+                    return fail(status === 'done' ? '标记完成失败' : '取消完成失败', r);
+                // 括号开头 = "没有产出内容"（本仓的约定，见 producedContent）：这条只报告动作做成了
+                return status === 'done' ? `(已标记完成: ${target})` : `(已取消完成标记: ${target})`;
+            }
             default:
                 return `(未知工具: ${name})`;
         }