weflow-cli 1.8.2 → 1.10.0

package/bin/weflow-cli.ts

@@ -12,6 +12,7 @@ import { keyService } from '../src/core/keyService.js'
 import { NtCore } from '../src/core/ntCore.js'
 import { configService } from '../src/services/configService.js'
 import { chatService } from '../src/services/chatService.js'
+import { emptyMessagesNote, looksLikeTalkerId } from '../src/services/messageQuery.js'
 import { exportService } from '../src/services/exportService.js'
 import { writeEvidencePackage } from '../src/services/evidenceService.js'
 import { resolveTalker as resolveTalkerCore } from '../src/utils/talkerUtils.js'
@@ -21,8 +22,12 @@ import { DateRangeError, parseLocalDateOrIso, resolveExportDateRange } from '../
 import { resolvePackageRoot as resolvePackageRootFrom } from '../src/utils/packageRoot.js'
 import { WechatMessageService } from '../src/services/wechatMessageService.js'
 import { whitelistService, MAX_TEXT_LENGTH } from '../src/services/whitelistService.js'
+import { authorizeOutbound, parseOutboundPolicy, performOutbound } from '../src/services/outboundSend.js'
 import { applyDerivedNtKeys, enableFavorites, detectFavDbPath } from '../src/services/initKeyService.js'
 import type { ChatSession } from '../src/types.js'
+import { disabledIds, describeSkill, readSkillBody, scanSkills, skillRoots, skillState } from '../src/services/assistantSkills.js'
+import { assistantScenes, validateSceneId, type Scene } from '../src/services/assistantScenes.js'
+import { detectWechatClient, reportedDataDirs, samePath } from '../src/services/wechatClient.js'
 
 const program = new Command()
 
@@ -63,6 +68,22 @@ function parseCliInteger(value: unknown, field: string, minimum: number, maximum
   process.exit(1)
 }
 
+/** 校验一个"只能是这几个值之一"的参数。与 `parseCliInteger` / `requireCliDate` 同一约定：
+ * `--json` 时错误也得是一份 JSON —— 否则机器调用方在 stdout 上拿到的是彩色散文，解析不了。
+ *
+ * 抽成一个是有理由的：`--line` 的校验原本在四个命令里各写了一遍，其中三处只打散文（`vault rag`、
+ * 顶层 `search`、`chat`）—— 同一份判断写四遍，就有三遍漏掉了 `--json` 分支。
+ * 错误文案由 choices 生成，保证与原来逐字一致（'line 必须是 wiki、chat 或 all'）。
+ */
+function requireCliChoice(value: unknown, choices: readonly string[], field: string, json = false): string {
+  const text = String(value)
+  if (choices.includes(text)) return text
+  const error = `${field} 必须是 ${choices.slice(0, -1).join('、')} 或 ${choices[choices.length - 1]}`
+  if (json) console.log(JSON.stringify({ success: false, code: 'INVALID_ARGUMENT', field, error }))
+  else console.log(chalk.red(error))
+  process.exit(1)
+}
+
 function requireCliDate(value: string, json = false): string {
   try {
     parseLocalDateOrIso(value)
@@ -282,7 +303,7 @@ program
       read: {
         sessions: { cli: 'sessions --json', mcp: 'wechat.list_sessions' },
         messages: { cli: 'messages <talker> --json', mcp: 'wechat.export_messages' },
-        contacts: { cli: 'contacts --json' },
+        contacts: { cli: 'contacts --json', mcp: 'wechat.list_contacts', localIdentifiersInModelContext: false },
         exports: {
           cli: 'export <talker> <json|txt|html|excel>',
           mcp: 'wechat.export_messages',
@@ -316,8 +337,36 @@ program
         },
         dailyReader: { cli: 'daily-server --status --json' },
         dailyStats: { cli: 'daily-stats --json' },
+        // 只读、纯本地、不调模型。**故意没有 mcp 那一栏**（D-062）：它给的是关于第三方的推断
+        // ——谁在被冷落、你会失去谁 —— 所以不进助手、不进 MCP、不喂模型。
+        bonds: { cli: 'bonds --json', mcp: null, leavesTheMachine: false },
         diagnostics: { cli: 'check --json' },
         todos: { cli: 'todos list --json' },
+        // 2026-09-29 三个界面对齐时新开的读取能力（D-058）。逐个写清它会不会出境，
+        // 因为其中两个会——`fetch_article` 白名单 + 逐跳复检，`search_public` 没有任何守卫。
+        review: { cli: 'review ...', mcp: 'wechat.get_review', writesReport: true },
+        concepts: { cli: 'wiki ...', mcp: 'wechat.get_concepts' },
+        articleFetch: {
+          cli: null,   // 没有对应的 CLI 命令：它本来就是为模型准备的读取能力
+          mcp: 'wechat.fetch_article',
+          network: true,
+          allowlist: 'https only, host must be exactly mp.weixin.qq.com',
+          redirectsReValidatedPerHop: true,
+          confirmationRequired: false,
+        },
+        publicArticleSearch: {
+          mcp: 'wechat.search_public',
+          network: true,
+          // **这条是如实的**：搜索词由模型决定、发到第三方搜索页，没有白名单也没有预览。
+          // 它在该项目的边界内是被明确接受的残余风险（D-058），这里不能写成"无出境"。
+          allowlist: null,
+          modelAuthoredQueryLeavesTheMachine: true,
+          confirmationRequired: false,
+        },
+        articleFormatting: { mcp: 'wechat.format_article', cli: null, writesNothing: true, network: false },
+        themes: { mcp: 'wechat.list_themes', writesNothing: true },
+        wikiLint: { cli: 'wiki lint --json', mcp: 'wechat.lint_wiki', readsLocalChat: false, writesNothing: true },
+        skillCheck: { cli: 'skill check --json', mcp: 'wechat.check_skills', writesNothing: true },
         awaiting: {
           cli: 'awaiting --yes',
           preview: 'awaiting --dry-run --json',
@@ -400,6 +449,33 @@ program
           execute: 'todos <done|undone|rm> <id> --yes --json',
           confirmationRequired: true,
         },
+        skills: {
+          list: 'skill list [--query <q>] --json',
+          show: 'skill show <id> --json',
+          check: 'skill check --json',
+          readOnly: true,
+          // 技能是**资料**，不是插件：助手只把它当提示词/正文读，不执行里面的脚本，
+          // 也不因为装了技能就多出任何工具（P4 验收标准：扩展读不到配置与数据库）。
+          installsAnything: false,
+          executesSkillCode: false,
+          grantsTools: false,
+          directories: 'skillDirs config (default: ~/.claude/skills, ~/.weflow-cli/skills)',
+          disable: 'config set skillDisabled <id,...>（技能自己也能写 enabled: false）',
+        },
+        scenes: {
+          list: 'scene list --json',
+          show: 'scene show <id> --json',
+          preview: 'scene <add|remove|enable|disable|bind|unbind> … --dry-run --json',
+          execute: 'scene <add|remove|enable|disable|bind|unbind> … --yes --json',
+          confirmationRequired: true,
+          // 场景只改**本机提示词预设**，不发消息、不读聊天、不调模型
+          readsLocalChat: false,
+          invokesAI: false,
+          sendsNothing: true,
+          stateLocation: 'local-user-config-dir',
+          stateSchema: 'weflow-scenes/v1',
+          modelWritable: false,
+        },
         accessControlMutations: {
           preview: '<whitelist|blacklist> <add|rm> <target> --dry-run --json',
           execute: '<whitelist|blacklist> <add|rm> <target> --yes --json',
@@ -571,9 +647,11 @@ program
         // 读这一位的调用方按 false 走保守分支即可。
         mcpDefaultReadOnly: false,
         mcpSurface: {
-          // 原文只写了 "minus save_memory" —— 而那张表也排除了 `look_at_image`（MCP 只取文本，
-          // 它挂进侧信道的图没人接）。机器可读字段少说一句同样算不准，如实写全。
-          derivedFrom: 'assistant tools minus save_memory and look_at_image',
+          // 这句话**手工补过两回**：先是只写 save_memory，后来补上 `look_at_image`，第三次加
+          // `set_todo_status` 时又漏了 —— 每次都是"表变了、这句话没变"，而且没有任何东西会红。
+          // 现在名字**逐个与 `MCP_EXCLUDED` 对齐**，并由 `test/assistant-tools.test.ts` 从源码里核：
+          // 那张表再加一项而这里没跟，测试就红（同下面 requiresConfirm 的处理方式）。
+          derivedFrom: 'assistant tools minus save_memory, look_at_image and set_todo_status',
           writesFiles: ['export_chat'],
           // 逐个核实过（脚本里确实调云端模型的那些）：
           // who_owes_reply/search_chats → Jev；search_semantic → 阿里云百炼嵌入 + Jev 重排；draft_reply → Jev + DeepSeek。
@@ -725,8 +803,13 @@ program
         console.log(chalk.gray('  目录名未命中时将继续进行深度结构扫描，过程可能需要较长时间...'))
       }
       const detected = configuredDataRoot
-        ? { success: true, path: configuredDataRoot }
-        : await dbPathService.autoDetect({ searchDrives: opts.searchDrives, fullScan: opts.fullScan })
+        ? { success: true, path: configuredDataRoot, source: 'known' as const }
+        : await dbPathService.autoDetect({
+            searchDrives: opts.searchDrives, fullScan: opts.fullScan,
+            // **先问客户端自己**（它命令行上带着 `--wechat-files-path`）：这是唯一"来自
+            // 客户端自己"的来源，其余都是按目录名猜。取不到就是空数组，走老路。
+            hintedRoots: await reportedDataDirs(),
+          })
       if (!detected.success || !detected.path) {
         console.log(chalk.red('✗ 未检测到微信数据目录'))
         if (!opts.searchDrives && !opts.fullScan) {
@@ -744,7 +827,10 @@ program
         }
         process.exit(1)
       }
-      console.log(chalk.green(`✓ 检测到数据目录: ${detected.path}`))
+      // **说清是怎么找到的**：来源不同，可信度与后续排查都不同（"客户端自己说的"最硬）
+      const howFound = detected.source === 'client' ? '（客户端自己报的）'
+        : detected.source === 'scan' ? '（全盘扫描找到的）' : ''
+      console.log(chalk.green(`✓ 检测到数据目录: ${detected.path}${howFound}`))
       configService.set('dbPath', detected.path)
       configService.set('dataVersion', '4.x')
 
@@ -1011,8 +1097,10 @@ const configurableKeys = [
   'wereadApiKey',
   'assistantPrivacy', 'assistantWhitelist', 'assistantGroupWhitelist',
   'assistantGroupRequireMention', 'assistantFastRoute', 'assistantPanelUser', 'quickReplyContacts',
+  'skillDirs', 'skillDisabled',
   'dailySources', 'dailySourceCategories',
   'dailyExcludeTopics', 'dailyAiEnabled',
+  'wechatMediaDownload',
   'emoticonSeed',
 ] as const
 
@@ -1310,8 +1398,25 @@ program
       : await chatService.getMessages(talker, limit, offset)
 
     if (messages.length === 0) {
-      if (opts.json) { console.log(JSON.stringify({ success: true, talker, messages: [] })); return }
+      // 拼错的 ID 会被 resolveTalker 原样放行 ⇒ 取不到消息。这里补一句话把两种情况分开，
+      // 但**不改退出码、也不改 success**（"没有消息"不是错误，脚本与 MCP 依赖这一点）。
+      let note = ''
+      if (looksLikeTalkerId(talkerInput)) {
+        const [sessions, contacts] = await Promise.all([
+          chatService.listSessions(talkerInput, 5),
+          chatService.listContacts(talkerInput, 5),
+        ])
+        note = emptyMessagesNote(talkerInput, {
+          sessionUsernames: sessions.map(s => s.username),
+          contactUsernames: contacts.map(c => c.username),
+        })
+      }
+      if (opts.json) {
+        console.log(JSON.stringify({ success: true, talker, messages: [], ...(note ? { note } : {}) }))
+        return
+      }
       console.log(chalk.gray('未找到消息'))
+      if (note) console.log(chalk.yellow(note))
       return
     }
 
@@ -1620,6 +1725,51 @@ syncCmd
   })
 
 // ==================== contacts ====================
+// contact-schema：读 contact.db 里**群**的 ext_buffer（本地只读：不联网、不调模型）
+//
+// 只解**实测验证过**的那几个字段（成员 userName/displayName/status/inviter + `#5`）；
+// `#5` 曾经叫"附加参与者 id"，实测是**成员 status 位 11 置位的那批 id**（本机 77/77 集合相等），
+// 所以输出改用 `statusBit11Ids`、不再说"额外参与者"（见 D-070）。
+// 顶层 `#3`/`#4` 的语义在本机被三次证伪（不是成员 id / 房间 id / 消息侧 id），所以脚本把它们
+// 原样放进 `unrecognized`，**不猜名字** —— 拿猜出来的名字写逻辑，就是拿不确定当事实。
+// 结构笔记见 `docs/CONTACT_DB_SCHEMA.md`，取舍见 D-067 / D-068 / D-070。
+//
+// `--contacts`（2026-10-07 加）：同一个命令改读**联系人**的 `contact.extra_buffer`，输出这一轮验证的
+// 三个字段 —— `#5` 国家/地区码（ISO 3166-1 alpha-2）、`#13` = 该行 `biz_info.type`、`#41` = 资料最近更新时间。
+// `#4`/`#9` 已定性为"账号自身资料文本的汇集"，是**内容**不是字段名，**故意不打印**（见 D-088）。
+program
+  .command('contact-schema')
+  .description('读 contact.db 的 ext_buffer：默认读群（成员 + #5）；--contacts 读联系人（#5 地区码 / #13 服务类型 / #41 更新时间）—— 只解已验证字段，未识别的原样标注（本地、只读）')
+  .option('-n, --limit <n>', '最多看几个（群 / 联系人）', '20')
+  .option('--room <which>', '只看某个（群 / 联系人 的 username 或 id）')
+  .option('--contacts', '改读联系人的 extra_buffer，而不是群')
+  .option('--json', '输出机器可读结果')
+  .action(async (opts) => {
+    const { execFile } = await import('child_process')
+    const { promisify } = await import('util')
+    const execFileAsync = promisify(execFile)
+    const script = join(resolvePackageRoot(), 'scripts', 'contact_schema.py')
+    const limit = parseCliInteger(opts.limit, 'limit', 1, 100000, !!opts.json)
+    const args = [script, '--limit', String(limit),
+                  ...(opts.room ? ['--room', opts.room] : []),
+                  ...(opts.contacts ? ['--contacts'] : []),
+                  ...(opts.json ? ['--json'] : [])]
+    try {
+      const { stdout, stderr } = await execFileAsync(getPythonCommand(), args, {
+        timeout: 300_000, maxBuffer: 64 * 1024 * 1024, env: pythonProcessEnv(),
+      })
+      process.stdout.write(stdout)
+      if (stderr && !opts.json) process.stderr.write(stderr)
+    } catch (error) {
+      if (opts.json) {
+        console.log(JSON.stringify({ success: false, code: 'CONTACT_SCHEMA_FAILED', action: 'contact-schema', error: safeSubprocessError(error) }))
+      } else {
+        console.error(chalk.red(`\n✗ ${safeSubprocessError(error)}`))
+      }
+      process.exit(1)
+    }
+  })
+
 program
   .command('contacts')
   .description('查看联系人列表')
@@ -1968,7 +2118,10 @@ program
         process.exit(1)
       }
     } else {
-      const timeout = parseCliInteger(opts.timeout, 'timeout', 1000, 600000)
+      // `opts.json` 也要传：这一行在 `--json` 下**不可达**（上面就 `INTERACTIVE_REQUIRED` 退出了），
+      // 但少传一个是安静的 —— 规则统一成"校验 helper 一律带上它"，判据才写得出来
+      // （`test/json-error-surface.test.ts` 末尾那条静态检查）。
+      const timeout = parseCliInteger(opts.timeout, 'timeout', 1000, 600000, opts.json)
       const result = await keyService.autoGetDbKey(timeout, (msg) => {
         console.log(chalk.gray(`  ${msg}`))
       })
@@ -2191,7 +2344,7 @@ whitelistCmd
       wxid = target
     } else {
       try {
-        wxid = await resolveTalker(target)
+        wxid = await resolveTalker(target, !!opts.json, !!opts.json)
         const sessions = await chatService.listSessions(undefined, 50)
         const match = sessions.find(s => s.username === wxid)
         if (match) displayName = match.displayName || target
@@ -2378,7 +2531,7 @@ blacklistCmd
       wxid = target
     } else {
       try {
-        wxid = await resolveTalker(target)
+        wxid = await resolveTalker(target, !!opts.json, !!opts.json)
         const sessions = await chatService.listSessions(undefined, 50)
         const match = sessions.find(s => s.username === wxid)
         if (match) displayName = match.displayName || target
@@ -3237,54 +3390,45 @@ program
       process.exit(1)
     }
 
-    // 黑名单优先拦截
-    if (whitelistService.isBlocked(wxid)) {
-      if (opts.json) console.log(JSON.stringify({ success: false, code: 'TARGET_BLOCKED', error: '目标在黑名单中', target: { wxid, displayName } }))
-      else {
+    // 三道闸（黑名单 → 白名单 → 限速）与"每次尝试都写审计"在 `src/services/outboundSend.ts`
+    // 里**只有一份**，因为 2026-10-01 起有了第二条发送路（`draft --pick N --send`，见 D-063）。
+    // 两份写同一件事，分叉的后果具体是"某一条路绕过了白名单"。
+    const policy = parseOutboundPolicy(Number(opts.rateWindow), Number(opts.rateMax))
+    if ('code' in policy) {
+      if (opts.json) console.log(JSON.stringify({ success: false, code: policy.code, error: policy.error }))
+      else console.log(chalk.red('速率参数无效：rate-window 必须为 1000-3600000，rate-max 必须为 1-100'))
+      process.exit(1)
+    }
+    const attempt = {
+      wxid, displayName, kind, preview, text: message,
+      mediaPath: kind === 'text' ? undefined : String(opts.image || opts.file),
+    }
+    const decision = authorizeOutbound(attempt, policy)
+    if (!decision.ok) {
+      const { refusal } = decision
+      if (opts.json) {
+        console.log(JSON.stringify({
+          success: false, code: refusal.code, error: refusal.error,
+          ...(refusal.code === 'TARGET_BLOCKED' || refusal.code === 'TARGET_NOT_ALLOWED'
+            ? { target: { wxid, displayName } } : {}),
+          ...(refusal.rateLimit ? { rateLimit: refusal.rateLimit } : {}),
+        }))
+      } else if (refusal.code === 'TARGET_BLOCKED') {
         console.log(chalk.red('\n❌ 目标在黑名单中，绝对禁止发送'))
         console.log(chalk.gray(`  wxid: ${wxid}`))
         console.log(chalk.gray(`  解除: weflow-cli blacklist rm ${wxid}\n`))
-      }
-      whitelistService.auditSend({
-        timestamp: Date.now(), action: 'send', targetWxid: wxid, targetName: displayName,
-        kind, success: false, preview, error: 'blocked by blacklist',
-      })
-      process.exit(1)
-    }
-
-    // Whitelist check
-    if (!whitelistService.isAllowed(wxid)) {
-      if (opts.json) console.log(JSON.stringify({ success: false, code: 'TARGET_NOT_ALLOWED', error: '目标不在白名单中', target: { wxid, displayName } }))
-      else {
+      } else if (refusal.code === 'TARGET_NOT_ALLOWED') {
         console.log(chalk.red('\n❌ 目标不在白名单中，拒绝发送'))
         console.log(chalk.gray(`  先运行: weflow-cli whitelist add ${target}`))
         console.log(chalk.gray(`  查看名单: weflow-cli whitelist\n`))
-      }
-      process.exit(1)
-    }
-
-    // 速率限制 (dry-run 不计入, 不检查也行, 但保持一致检查)
-    const windowMs = Number(opts.rateWindow)
-    const max = Number(opts.rateMax)
-    if (!Number.isInteger(windowMs) || windowMs < 1000 || windowMs > 3_600_000 ||
-        !Number.isInteger(max) || max < 1 || max > 100) {
-      if (opts.json) console.log(JSON.stringify({ success: false, code: 'INVALID_RATE_LIMIT', error: 'rate-window 必须为 1000-3600000，rate-max 必须为 1-100' }))
-      else console.log(chalk.red('速率参数无效：rate-window 必须为 1000-3600000，rate-max 必须为 1-100'))
-      process.exit(1)
-    }
-    const rate = whitelistService.checkRateLimit(windowMs, max)
-    if (!rate.allowed) {
-      if (opts.json) console.log(JSON.stringify({ success: false, code: 'RATE_LIMITED', error: '触发发送速率限制', rateLimit: rate }))
-      else {
+      } else {
+        const rate = refusal.rateLimit!
         console.log(chalk.red(`\n❌ 触发速率限制: 最近 ${rate.windowMs / 1000}s 内已发送 ${rate.count} 条 (上限 ${rate.max})`))
         console.log(chalk.gray('  请稍后再试, 或调整 --rate-window / --rate-max\n'))
       }
-      whitelistService.auditSend({
-        timestamp: Date.now(), action: 'send', targetWxid: wxid, targetName: displayName,
-        kind, success: false, preview, error: `rate limited (${rate.count}/${rate.max})`,
-      })
       process.exit(1)
     }
+    const rate = decision.rate
 
     // 二次确认 — 同时显示 wxid + displayName + 消息预览
     const actionPreview = {
@@ -3338,41 +3482,8 @@ program
       process.exit(1)
     }
 
-    const service = new WechatMessageService({ token })
-
-    let success = false
-    let errorMsg: string | undefined
-    try {
-      if (opts.image) {
-        success = await service.sendImage(wxid, opts.image)
-      } else if (opts.file) {
-        success = await service.sendFile(wxid, opts.file)
-      } else {
-        success = await service.sendText(wxid, message)
-      }
-    } catch {
-      errorMsg = '消息通道调用失败'
-    }
-
-    if (!success && !errorMsg) {
-      // 检查是否因缺少 context_token
-      const hasToken = !!(configService.getContextTokens()[wxid])
-      errorMsg = hasToken
-        ? '发送失败 (接口返回错误, 可能 token 过期)'
-        : '缺少 context_token — 需先收到对方一条消息 (或运行 weflow-cli listen 等待对方消息)'
-    }
-
-    // 审计日志
-    whitelistService.auditSend({
-      timestamp: Date.now(),
-      action: 'send',
-      targetWxid: wxid,
-      targetName: displayName,
-      kind,
-      success,
-      preview,
-      error: success ? undefined : errorMsg,
-    })
+    // 真的发 + 按结果写审计，都在共享模块里（与 `draft --send` 同一份）
+    const { success, error: errorMsg } = await performOutbound(attempt)
 
     if (success) {
       if (opts.json) console.log(JSON.stringify({ success: true, ...actionPreview }))
@@ -3792,6 +3903,8 @@ program
         .option('--api-key <key>', 'DeepSeek API key')
         .option('--refresh-sources',
                 '只把已有概念页的"来源"段补齐成当前全部来源（本地重写，**不调用模型**）')
+        .option('--qualify-links',
+                '把跨线同名的概念链接改成带路径的形式（本地重写，**不调用模型**）')
         .option('--cards <dir...>', '产卡目录，可写多个；默认所有 output/*-notes（与索引的引用数同一口径）')
         .option('--dry-run', '仅预览，不读取文章、调用 AI 或写入概念页')
         .option('--yes', '确认调用 AI 并生成概念页')
@@ -3817,6 +3930,22 @@ program
             return
           }
 
+          if (opts.qualifyLinks) {
+            // 本地消歧：两条线同名的那些链接按名字带路径（`Chat/Concepts/DeepSeek|DeepSeek`），
+            // 免得 Obsidian 里那条裸链接命中另一条线的那张。**不调模型**，重跑幂等。
+            await runConfirmedPythonMutation({
+              action: 'wiki.qualifyLinks',
+              script,
+              args: ['--qualify-links', '--output', opts.output],
+              cliOptions: opts,
+              preview: { readsLocalKnowledge: true, rewritesExistingPages: true, usesAi: false },
+              confirmationMessage: `确认把 ${opts.output} 里跨线同名的概念链接改成带路径的形式？`
+                + '（本地重写，不调用 AI）',
+              apiKey: opts.apiKey,
+              timeout: 300_000,
+            })
+            return
+          }
           const limit = parseCliInteger(opts.limit, 'limit', 1, 1000, opts.json)
           const minRefs = parseCliInteger(opts.minRefs ?? '1', 'min-refs', 1, 50, opts.json)
           await runConfirmedPythonMutation({
@@ -3847,8 +3976,9 @@ program
         .option('--wiki-limit <n>', '概念编译数', '20')
         .option('--source <name>', '仅处理指定公众号，可重复使用', (value: string, previous: string[]) => [...previous, value], [] as string[])
         .option('--skip-classify', '跳过 AI 后处理')
-        .option('--skip-wiki', '跳过概念编译')
-        .option('--skip-vault', '跳过 Vault 副本同步')
+        // 这两个**默认不做**：Obsidian 自带的图谱视图是实时的，写一次 vault 图谱就重画一次。
+        .option('--with-wiki', '把概念页写进 Obsidian Vault（默认不写：图谱只在你说了才变）')
+        .option('--with-vault', '把当天内容副本同步进 Obsidian Vault（默认不写）')
         .option('--skip-html', '跳过 HTML 阅读器生成')
         .option('--skip-ai-report', '跳过 AI 深度阅读报告')
         .option('--no-ai', '关闭全部 AI 调用，保留抓取和本地输出')
@@ -3930,8 +4060,8 @@ program
           if (opts.date) args.push('--date', opts.date)
           for (const source of sources) args.push('--source', source)
           if (opts.skipClassify) args.push('--skip-classify')
-          if (opts.skipWiki) args.push('--skip-wiki')
-          if (opts.skipVault) args.push('--skip-vault')
+          if (opts.withWiki) args.push('--with-wiki')
+          if (opts.withVault) args.push('--with-vault')
           if (opts.skipHtml) args.push('--skip-html')
           if (opts.skipAiReport) args.push('--skip-ai-report')
           if (noAi) args.push('--no-ai')
@@ -4167,16 +4297,30 @@ program
         .description('Vault 搜索 — 文章+概念+笔记')
         .argument('<query>', '搜索关键词')
         .option('--type <type>', 'all / article / concept / note', 'all')
+        .option('--line <line>', 'wiki=文章线(默认) / chat=聊天线 / all=两条都搜', 'wiki')
         .option('--top-k <n>', '返回数量', '10')
+        // `vault_search.py` 一直有 `--days`（它的 docstring 自己就举 `--days 30`），CLI 从来没接 ——
+        // 于是"只搜最近一周"这件事在这条路上做不到，窗口被脚本默认值（90）钉死。与 `search-index --days`
+        // 同形：窗口的运行值由 CLI 说了算，默认值与脚本一致。
+        .option('--days <n>', '日报文章取最近多少天（默认 90）', '90')
+        // 这条 `--json` 曾经**不存在，而 JSON 又是唯一的输出**：参数里硬编码着 `'--json'`，
+        // 人类模式虽然脚本里写着（`vault_search.py` 不带 `--json` 时打印带相关度的可读列表）
+        // 却没有任何入口能到达，用户显式敲 `--json` 还会拿到 `unknown option` —— 与
+        // `docs/EXTENDING.md` 那条"脚本或 AI 会驱动的命令都有 `--json` 模式"正相反。
+        // 现在按兄弟命令（`vault rag`、顶层 `search`）的形状来：默认人类可读，`--json` 才转发。
+        .option('--json', '输出 JSON 格式（含本地路径与标题，供本机脚本/AI 使用）')
         .action(async (query, opts) => {
           const pkgRoot = resolvePackageRoot()
           const script = join(pkgRoot, 'scripts', 'vault_search.py')
-          if (!['all', 'article', 'concept', 'note'].includes(opts.type)) {
-            console.log(chalk.red('type 必须是 all、article、concept 或 note'))
-            process.exit(1)
-          }
-          const topK = parseCliInteger(opts.topK, 'top-k', 1, 100)
-          await runPythonCmd(script, [query, '--type', opts.type, '--top-k', String(topK), '--json'])
+          // 校验分支也要认 `--json`（`requireCliChoice` 里就带着这条约定）：
+          // 否则 JSON 模式下 stdout 是一行彩色散文，脚本解析不了。
+          requireCliChoice(opts.type, ['all', 'article', 'concept', 'note'], 'type', opts.json)
+          requireCliChoice(opts.line, ['wiki', 'chat', 'all'], 'line', opts.json)
+          const topK = parseCliInteger(opts.topK, 'top-k', 1, 100, opts.json)
+          const days = parseCliInteger(opts.days, 'days', 1, 3650, opts.json)
+          await runPythonCmd(script, [query, '--type', opts.type, '--line', opts.line,
+                                      '--top-k', String(topK), '--days', String(days),
+                                      ...(opts.json ? ['--json'] : [])])
         })
     )
 
@@ -4188,6 +4332,7 @@ program
         .description('Vault 问答 — 基于知识库的 AI 对话')
         .argument('<question>', '问题')
         .option('--top-k <n>', '检索条数', '8')
+        .option('--line <line>', 'wiki=文章线(默认) / chat=聊天线 / all=两条都搜', 'wiki')
         .option('--api-key <key>', 'DeepSeek API key')
         .option('--dry-run', '仅预览，不读取知识库或调用 AI')
         .option('--yes', '确认读取本地知识并发送筛选后的上下文到 AI')
@@ -4196,11 +4341,13 @@ program
           const pkgRoot = resolvePackageRoot()
           const script = join(pkgRoot, 'scripts', 'vault_rag.py')
           const topK = parseCliInteger(opts.topK, 'top-k', 1, 100, opts.json)
+          requireCliChoice(opts.line, ['wiki', 'chat', 'all'], 'line', opts.json)
           const preview = {
             success: true,
             dryRun: true,
             action: 'vault.rag',
             topK,
+            line: opts.line,
             readsLocalKnowledge: true,
             usesAi: true,
             sendsSelectedContextToAi: true,
@@ -4226,7 +4373,7 @@ program
               return
             }
           }
-          const args = ['--top-k', String(topK)]
+          const args = ['--top-k', String(topK), '--line', opts.line]
           if (opts.json) args.push('--json')
           const { execFile } = await import('child_process')
           const { promisify } = await import('util')
@@ -4520,6 +4667,7 @@ program
       }
 
       const child = spawn(getPythonCommand(), args, {
+        windowsHide: true,
         stdio: 'inherit',
         env: pythonProcessEnv(),
       })
@@ -4530,6 +4678,25 @@ program
     })
 
   // ==================== weread ====================
+
+  /** 微信读书服务失败时的统一出口。
+   *
+   * 9 个调用点（shelf / stats / notes×2 / search / book / review / discover / profile）原来都是一行式
+   * 分支：把彩色散文打在 stdout 上再 `process.exit(1)`，**没有** json 支，而各命令的 `if (opts.json)`
+   * 分支在它后面 ⇒ `weread shelf --json` 失败时 stdout 上只有一行 `✗ …`，调用方解析不了，也不知道
+   * 是哪个命令失败了。全库其余同类出口都是"机器支发 JSON + exit"。
+   *
+   * （这里刻意**不**把那行旧代码原样抄出来：`test/json-error-surface.test.ts` 有一条绊线在扫那个形状，
+   * 而注释里留一份字面量会让判据读到它 —— 今晚已经在另一条判据上踩过这个坑。）
+   *
+   * 人看的那一支保持原样（`console.log`，不动它的落点）：把 CLI 的**错误**统一改走 stderr 是另一件事，
+   * 现在库里两种都有（多数 `console.error`、少数 `console.log`），不在这条修复里顺手改。
+   */
+  function failWeread(res: { error?: string }, json = false): never {
+    if (json) console.log(JSON.stringify({ success: false, code: 'WEREAD_FAILED', error: res.error }))
+    else console.log(chalk.red(`✗ ${res.error}`))
+    process.exit(1)
+  }
   const wereadCmd = program
     .command('weread')
     .description('微信读书助手 — 书架、统计、笔记、搜索、书评、推荐')
@@ -4541,7 +4708,7 @@ program
     .action(async (opts) => {
       const weread = await getWereadService()
       const res = await weread.shelf()
-      if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+      if (!res.ok) failWeread(res, !!opts.json)
       const d = res.data!
       if (opts.json) { console.log(JSON.stringify(d, null, 2)); return }
 
@@ -4570,7 +4737,7 @@ program
     .action(async (opts) => {
       const weread = await getWereadService()
       const res = await weread.readData(opts.mode)
-      if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+      if (!res.ok) failWeread(res, !!opts.json)
       const d = res.data!
       if (opts.json) { console.log(JSON.stringify(d, null, 2)); return }
 
@@ -4618,7 +4785,7 @@ program
       const limit = parseCliInteger(opts.limit, 'limit', 1, 100, opts.json)
       if (opts.bookId) {
         const res = await weread.bookmarks(opts.bookId, limit)
-        if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+        if (!res.ok) failWeread(res, !!opts.json)
         const d = res.data!
         if (opts.json) { console.log(JSON.stringify(d, null, 2)); return }
         console.log(chalk.cyan(`📝 划线笔记 (${d.updated?.length || 0} 条):\n`))
@@ -4631,7 +4798,7 @@ program
         }
       } else {
         const res = await weread.notebooks(50)
-        if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+        if (!res.ok) failWeread(res, !!opts.json)
         const d = res.data!
         if (opts.json) { console.log(JSON.stringify(d, null, 2)); return }
         console.log(chalk.cyan(`📝 笔记本 (${d.books?.length || 0} 本有笔记):\n`))
@@ -4654,7 +4821,7 @@ program
       const weread = await getWereadService()
       const limit = parseCliInteger(opts.limit, 'limit', 1, 100, opts.json)
       const res = await weread.search(keyword, limit)
-      if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+      if (!res.ok) failWeread(res, !!opts.json)
       const d = res.data!
       if (opts.json) { console.log(JSON.stringify(d, null, 2)); return }
       console.log(chalk.cyan(`🔍 搜索: "${keyword}" (${d.books?.length || 0} 条):\n`))
@@ -4678,7 +4845,7 @@ program
         weread.bookInfo(bookId),
         weread.getProgress(bookId),
       ])
-      if (!infoRes.ok) { console.log(chalk.red(`✗ ${infoRes.error}`)); process.exit(1) }
+      if (!infoRes.ok) failWeread(infoRes, !!opts.json)
       const b = infoRes.data!
       if (opts.json) { console.log(JSON.stringify(b, null, 2)); return }
 
@@ -4704,7 +4871,7 @@ program
       const weread = await getWereadService()
       const limit = parseCliInteger(opts.limit, 'limit', 1, 100, opts.json)
       const res = await weread.reviews(bookId, limit)
-      if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+      if (!res.ok) failWeread(res, !!opts.json)
       const d = res.data!
       if (opts.json) { console.log(JSON.stringify(d, null, 2)); return }
       console.log(chalk.cyan(`💬 书评 (${d.reviews?.length || 0} 条):\n`))
@@ -4730,7 +4897,7 @@ program
       const res = opts.bookId
         ? await weread.similar(opts.bookId, limit)
         : await weread.recommend(limit)
-      if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+      if (!res.ok) failWeread(res, !!opts.json)
       const d = res.data!
       if (opts.json) { console.log(JSON.stringify(d, null, 2)); return }
       const label = opts.bookId ? '相似推荐' : '个性化推荐'
@@ -4751,7 +4918,7 @@ program
     .action(async (opts) => {
       const weread = await getWereadService()
       const res = await weread.profile()
-      if (!res.ok) { console.log(chalk.red(`✗ ${res.error}`)); process.exit(1) }
+      if (!res.ok) failWeread(res, !!opts.json)
       const p = res.data!
       if (opts.json) { console.log(JSON.stringify(p, null, 2)); return }
 
@@ -4794,6 +4961,8 @@ program
     .description('语义搜索知识库（聊天记录 + 文章）')
     .argument('<query>', '搜索关键词')
     .option('--top-k <n>', '返回数量', '10')
+    .option('--line <line>', 'wiki=文章线(默认) / chat=聊天记录 / all=两条都搜', 'wiki')
+    .option('--no-rerank', '不调用决策模型重排，只按向量/关键词相似度返回（回退到引入重排之前）')
     .option('--api-key <key>', 'DashScope embedding API key')
     .option('--dry-run', '仅预览，不读取索引或调用向量服务')
     .option('--yes', '确认执行可能调用云端向量服务的搜索')
@@ -4805,11 +4974,14 @@ program
     const pkgRoot = resolvePackageRoot()
       const script = join(pkgRoot, 'scripts', 'semantic_search.py')
       const topK = parseCliInteger(opts.topK, 'top-k', 1, 100, opts.json)
+      requireCliChoice(opts.line, ['wiki', 'chat', 'all'], 'line', opts.json)
       const preview = {
         success: true,
         dryRun: true,
         action: 'semantic-search.query',
         topK,
+        line: opts.line,
+        noRerank: opts.rerank === false,
         readsLocalIndex: true,
         mayUseCloudEmbedding: true,
       }
@@ -4834,7 +5006,11 @@ program
           return
         }
       }
-      const args: string[] = [script, 'search', '--top-k', String(topK)]
+      // `--no-rerank` 是**旗标**（不是密钥）⇒ 可以走 argv；查询本身仍然只走 env（见 `privacy-paths` 那条规矩）。
+      // 接这条通道之前，`OPERATIONS.md` 一直在教用户敲 `search --no-rerank`，而 CLI 会答 `unknown option`
+      // —— 同一份文档里 `--line` 是通的，所以它看起来像"能用的旗标"（2026-10-11 由文档命令面那道检查发现）。
+      const args: string[] = [script, 'search', '--top-k', String(topK), '--line', opts.line,
+        ...(opts.rerank === false ? ['--no-rerank'] : [])]
       try {
         const { stdout } = await execFileAsync(getPythonCommand(), args, {
           timeout: 60_000, maxBuffer: 10 * 1024 * 1024,
@@ -4932,6 +5108,7 @@ program
     .description('RAG 智能助手 — 基于聊天记录和公众号的对话式问答')
     .argument('[question]', '要问的问题（不传则进入交互模式）')
     .option('--top-k <n>', '检索数量', '10')
+    .option('--line <line>', 'wiki=文章/文章概念(默认) / chat=聊天记录 / all=两条都搜', 'wiki')
     .option('--talker <name>', '限定联系人/群聊')
     .option('--api-key <key>', 'AI API key')
     .option('--dry-run', '仅预览，不读取知识库或调用 AI')
@@ -4944,11 +5121,13 @@ program
     const pkgRoot = resolvePackageRoot()
       const script = join(pkgRoot, 'scripts', 'rag_chat.py')
       const topK = parseCliInteger(opts.topK, 'top-k', 1, 100, opts.json)
+      requireCliChoice(opts.line, ['wiki', 'chat', 'all'], 'line', opts.json)
       const preview = {
         success: true,
         dryRun: true,
         action: 'rag-chat.query',
         topK,
+        line: opts.line,
         interactiveRequired: !question,
         readsLocalKnowledge: true,
         usesCloudEmbedding: true,
@@ -4983,7 +5162,7 @@ program
       }
       const args: string[] = [script]
       if (question) {
-        args.push('--top-k', String(topK))
+        args.push('--top-k', String(topK), '--line', opts.line)
         if (opts.json) args.push('--json')
         try {
           const { stdout } = await execFileAsync(getPythonCommand(), args, {
@@ -5001,8 +5180,9 @@ program
         }
       } else {
         // 交互模式：使用 spawn 保持终端交互
-        args.push('--interactive', '--top-k', String(topK))
+        args.push('--interactive', '--top-k', String(topK), '--line', opts.line)
         const child = spawn(getPythonCommand(), args, {
+          windowsHide: true,
           stdio: 'inherit',
           env: {
             ...pythonProcessEnv(opts.apiKey),
@@ -5269,8 +5449,12 @@ program
   // draft：判断在前、起草在后、**绝不发送**
   program
     .command('draft <talker>')
-    .description('帮我起草回复：先判断（意图/风险/该不该给实质），再起草候选 —— **只产出文本，不发送**')
+    .description('帮我起草回复：先判断（意图/风险/该不该给实质），再起草候选 —— **默认只产出文本；给了 --pick N --send 才会替你发送**')
     .option('--count <n>', '要几条候选', '3')
+    .option('--pick <n>', '选第几条（从 1 数）；不带 --send 时只把那条的完整原文打出来')
+    .option('--send', '把选中的那条发出去 —— **必须同时给 --pick**（不允许"自己挑一条发"），仍需 --yes/--dry-run')
+    .option('--rate-window <ms>', '发送速率窗口毫秒（与 send 同一份策略）', '60000')
+    .option('--rate-max <n>', '窗口内最大发送条数', '10')
     .option('--gate-commitment', '承诺未兑现时也拒绝起草（默认只在提示词里约束）')
     .option('--dry-run', '仅预览会发多少字符给哪两个模型，不调用')
     .option('--yes', '确认把这段对话发送到判断模型与生成模型')
@@ -5279,9 +5463,20 @@ program
       const { execFile } = await import('child_process')
       const { promisify } = await import('util')
       const execFileAsync = promisify(execFile)
+      // **用法错误先报**，而且都在调模型之前报：`--send` 少了 `--pick` 是"你没说发哪条"，
+      // `--pick 9` 而只有 3 条是"那条根本不存在" —— 两者都不该先问一遍"要不要把对话发给云端模型"、
+      // 更不该先花掉模型调用再拒绝。
+      const count = parseCliInteger(opts.count, 'count', 1, 5, opts.json)
+      if (opts.send && opts.pick === undefined) {
+        const message = '--send 必须同时给 --pick <序号>：先看候选，再点名要发哪一条'
+        if (opts.json) console.log(JSON.stringify({ success: false, code: 'PICK_REQUIRED', error: message }))
+        else console.log(chalk.red(`
+❌ ${message}`))
+        process.exit(1)
+      }
+      const pick = opts.pick === undefined ? 0 : parseCliInteger(opts.pick, 'pick', 1, count, opts.json)
       const pkgRoot = resolvePackageRoot()
       const script = join(pkgRoot, 'scripts', 'draft_reply.py')
-      const count = parseCliInteger(opts.count, 'count', 1, 5, opts.json)
       // **"确认过了"只用一个变量表示**（`--yes` 或交互回答"是"），参数在确认之后才拼。
       // 原来的写法是先拼参数、再问，于是**交互确认那条路是坏的**：答了"是"，`args` 里
       // 却从没补上 `--yes`，脚本照样拒绝（用户看到的是"我确认了它却说没确认"）。
@@ -5309,6 +5504,149 @@ program
           return
         }
       }
+      // ---------------- 选中并（可选）发送 ----------------
+      //
+      // **只有给了 `--pick` 或 `--send` 才走这条分支**；不带它们的调用与以前逐字相同（原样透传脚本输出）。
+      //
+      // 这条分支存在的理由：起草那一半早就有了（判断 → 候选 → 排序），缺的是"人选定之后能真的发出去"。
+      // 而它的**要点是这个 `--pick`**：发送必须由人点名"第几条"。少了它，就成了"模型起草三条、
+      // 模型挑一条、模型发出去" —— 那正是本仓库划掉的那件事
+      // （docs/EXTENDING.md：sending is structurally unreachable from a model-driven path）。
+      if (opts.pick !== undefined || opts.send) {
+        // **`--dry-run` 的语义是"零出境"**，而候选必须由模型产出来 —— 两者不可兼得：不起草就没有
+        // 候选，"预览某一条会发什么"这件事本身不成立。所以这里只报"会发多少字符给哪两个模型"
+        // （脚本的 dry-run 本来就报这个），并把话说清楚，而不是假装预览了一条。
+        if (opts.dryRun) {
+          try {
+            const { stdout } = await execFileAsync(getPythonCommand(),
+              [script, '--talker', String(talker), '--count', String(count), '--dry-run',
+               ...(opts.json ? ['--json'] : [])],
+              { timeout: 120_000, maxBuffer: 20 * 1024 * 1024, env: pythonProcessEnv() })
+            process.stdout.write(stdout)
+          } catch (error) {
+            console.error(chalk.red(`\n✗ ${safeSubprocessError(error, '预览失败')}`))
+            process.exit(1)
+          }
+          if (!opts.json) {
+            console.log(chalk.gray('\n候选要由模型产出来，所以 --dry-run 下没有候选可挑。'
+              + '要预览"发第几条"：先起草一次（会调用模型），再用 --pick N --send。\n'))
+          }
+          return
+        }
+        // `--pick`/`--send` 的用法错误在 action 开头就报过了（那一段全在调模型之前）
+        // 内部一律用 `--json` 拿结构化结果（用户那侧的 `--json` 管的是最终输出，两回事）
+        const pickArgs = [script, '--talker', String(talker), '--count', String(count), '--json',
+                          ...(confirmed ? ['--yes'] : []),
+                          ...(opts.gateCommitment ? ['--gate-commitment'] : [])]
+        let drafts: Array<{ text: string }> = []
+        try {
+          const { stdout } = await execFileAsync(getPythonCommand(), pickArgs, {
+            timeout: 300_000, maxBuffer: 50 * 1024 * 1024, env: pythonProcessEnv(),
+          })
+          const parsed = JSON.parse(stdout)
+          if (parsed.gate === 'refused') {
+            // **不起草就不发**：那道闸（涉钱/风险高）拒绝时压根没有候选，这里也不能凭空发点什么
+            const message = `这次不起草：${parsed.reason || '判断层拒绝了'}`
+            if (opts.json) console.log(JSON.stringify({ success: false, code: 'DRAFT_REFUSED', error: message, advice: parsed.advice || [] }))
+            else {
+              console.log(chalk.yellow(`\n${message}`))
+              for (const item of parsed.advice || []) console.log(chalk.gray(`  · ${item}`))
+            }
+            process.exit(1)
+          }
+          drafts = parsed.drafts || []
+        } catch (error) {
+          const message = safeSubprocessError(error, '起草失败')
+          if (opts.json) console.log(JSON.stringify({ success: false, code: 'DRAFT_FAILED', error: message }))
+          else console.error(chalk.red(`\n✗ ${message}`))
+          process.exit(1)
+        }
+        const chosen = drafts[pick - 1]
+        if (!chosen) {
+          const message = `没有第 ${pick} 条候选（这次只有 ${drafts.length} 条）`
+          if (opts.json) console.log(JSON.stringify({ success: false, code: 'PICK_OUT_OF_RANGE', error: message }))
+          else console.log(chalk.red(`\n❌ ${message}`))
+          process.exit(1)
+        }
+        if (!opts.send) {
+          if (opts.json) console.log(JSON.stringify({ success: true, action: 'draft', sent: false, pick, text: chosen.text }))
+          else console.log(`第 ${pick} 条：\n${chosen.text}\n\n${chalk.gray('（没有发送任何东西；要发加 --send）')}`)
+          return
+        }
+
+        // 发送这一半走**与 `send` 命令完全相同的那份策略**（黑名单 → 白名单 → 限速 → 审计）
+        let wxid: string
+        try {
+          wxid = await resolveTalker(String(talker), !!opts.json, !!opts.json)
+        } catch (error: any) {
+          if (opts.json) console.log(JSON.stringify({ success: false, code: 'TALKER_RESOLUTION_FAILED', error: error.message }))
+          else console.log(chalk.red(`\n❌ ${error.message}`))
+          process.exit(1)
+        }
+        let displayName = whitelistService.lookupName(wxid)
+        if (displayName === wxid) {
+          try {
+            const sessions = await chatService.listSessions(undefined, 200)
+            const match = sessions.find(s => s.username === wxid)
+            if (match?.displayName) displayName = match.displayName
+          } catch { /* 拿不到名字就退回 wxid */ }
+        }
+        const policy = parseOutboundPolicy(Number(opts.rateWindow), Number(opts.rateMax))
+        if ('code' in policy) {
+          if (opts.json) console.log(JSON.stringify({ success: false, code: policy.code, error: policy.error }))
+          else console.log(chalk.red(`\n❌ ${policy.error}`))
+          process.exit(1)
+        }
+        const attempt = {
+          wxid, displayName, kind: 'text' as const,
+          preview: chosen.text.slice(0, 80) + (chosen.text.length > 80 ? '...' : ''),
+          text: chosen.text,
+        }
+        const decision = authorizeOutbound(attempt, policy)
+        if (!decision.ok) {
+          const { refusal } = decision
+          if (opts.json) {
+            // 这里**还没有** sendPreview（它在闸门通过之后才建），所以逐字段写
+            console.log(JSON.stringify({ success: false, code: refusal.code, error: refusal.error,
+              ...(refusal.rateLimit ? { rateLimit: refusal.rateLimit } : {}) }))
+          } else {
+            console.log(chalk.red(`\n❌ ${refusal.error}`))
+            if (refusal.code === 'TARGET_NOT_ALLOWED') console.log(chalk.gray(`  先运行: weflow-cli whitelist add ${talker}\n`))
+            if (refusal.code === 'TARGET_BLOCKED') console.log(chalk.gray('  这个人在黑名单里，任何一条命令行都不会发给他\n'))
+            if (refusal.rateLimit) console.log(chalk.gray(`  最近 ${refusal.rateLimit.windowMs / 1000}s 内已发 ${refusal.rateLimit.count} 条\n`))
+          }
+          process.exit(1)
+        }
+        const sendPreview = { success: true, action: 'draft-send', target: { wxid, displayName },
+                              pick, text: chosen.text, rateLimit: decision.rate }
+        // 两段式在这里：不给 `--yes` 时，JSON 模式回 `CONFIRMATION_REQUIRED`（**带着要发的原文**），
+        // 交互模式则问一句"确定把第 N 条发给 X？"。`--dry-run` 那条路在上面的分支入口就返回了
+        // （它意味着零出境，与"必须由模型产出候选"不可兼得），所以这里没有第三个预览分支。
+        if (opts.json && !opts.yes) {
+          console.log(JSON.stringify({ ...sendPreview, success: false, code: 'CONFIRMATION_REQUIRED', error: '使用 --yes 确认发送' }))
+          process.exit(1)
+        }
+        if (!opts.yes) {
+          const answer = await inquirer.prompt([{
+            type: 'confirm', name: 'send', default: false,
+            message: `确定把第 ${pick} 条发给 ${displayName}？`,
+          }])
+          if (!answer.send) {
+            console.log(chalk.gray('已取消，没有发送'))
+            return
+          }
+        }
+        const sent = await performOutbound(attempt)
+        if (sent.success) {
+          if (opts.json) console.log(JSON.stringify(sendPreview))
+          else console.log(chalk.green('✓ 发送成功'))
+          return
+        }
+        if (opts.json) console.log(JSON.stringify({ ...sendPreview, success: false, code: 'SEND_FAILED', error: sent.error }))
+        else console.log(chalk.red(`✗ 发送失败 — ${sent.error}`))
+        process.exit(1)
+      }
+
       const args = [script, '--talker', String(talker), '--count', String(count),
                     // 脚本自己有第二道闸门（`--yes` 才真的把对话发出去），所以要透传
                     ...(confirmed ? ['--yes'] : []),
@@ -5333,18 +5671,86 @@ program
       }
     })
 
+  // wiki graph：把概念图谱导成一张**自包含**的 3D 页面（全本地：只读 Vault、不联网、不调用模型）
+  //
+  // 自包含是硬要求，不是顺手：页面用 `file://` 双击打开，那时 `fetch` 会被 CORS 挡死，
+  // 所以库、数据、坐标全部内联进去 —— 也因此三个库随 npm 包发（见 resources/js/graph3d/NOTICE.txt）。
+  // 布局（250 tick 实测 55 秒）在构建期用 Node 算完并缓存，打开页面即用。
+  program.commands.find(c => c.name() === 'wiki')?.addCommand(
+    new Command('graph')
+      .description('把概念图谱导成一张自包含的图谱页面（只读本地、不联网；生成的 HTML 双击就能逛）。--flat 出 2D 版')
+      .option('--vault <dir>', 'Vault 根目录（默认 output/wechat-vault）')
+      .option('-o, --out <file>', '页面写到哪（默认 output/knowledge-graph-3d.html）')
+      .option('--ticks <n>', '力导向迭代次数（默认 250，越多越舒展也越慢）')
+      .option('--cache <dir>', '布局缓存目录（派生数据；测试/多份图分开放时用）')
+      .option('--flat', '2D 版：平面图（更像 Obsidian 那种），canvas 渲染，输出默认 knowledge-graph-2d.html')
+      .option('--min-degree <n>', '只画在原图里连接数 ≥N 的概念（去掉细枝看骨架；0 = 全画）')
+      .option('--line <which>', '只画一条线：all / wiki / chat')
+      .option('--dry-run', '只报概念与链接数：不写文件、也不算布局（本地，零改动）')
+      .option('--open', '生成后用默认浏览器打开它')
+      .option('--json', '输出机器可读结果')
+      .action(async (opts) => {
+        const { execFile } = await import('child_process')
+        const { promisify } = await import('util')
+        const execFileAsync = promisify(execFile)
+        // 2D 与 3D 是**两个入口脚本**：图怎么建共用（graph_2d 直接 import graph_3d），
+        // 换的是布局维度与渲染器 —— 两套渲染器塞一个文件就没人看得完了。
+        const script = join(resolvePackageRoot(), 'scripts', opts.flat ? 'graph_2d.py' : 'graph_3d.py')
+        const ticks = opts.ticks === undefined ? undefined : parseCliInteger(opts.ticks, 'ticks', 1, 100000, !!opts.json)
+        // `--json` 一律要：CLI 要拿到 out 路径与计数，才决定怎么印。开关只决定**给谁看**。
+        const minDegree = opts.minDegree === undefined
+          ? undefined : parseCliInteger(opts.minDegree, 'min-degree', 0, 100000, !!opts.json)
+        const args = [script,
+                      ...(opts.vault ? ['--vault', opts.vault] : []),
+                      ...(opts.out ? ['--out', opts.out] : []),
+                      ...(opts.cache ? ['--cache', opts.cache] : []),
+                      ...(ticks === undefined ? [] : ['--ticks', String(ticks)]),
+                      ...(minDegree === undefined || minDegree === 0 ? [] : ['--min-degree', String(minDegree)]),
+                      ...(opts.line ? ['--line', opts.line] : []),
+                      ...(opts.dryRun ? ['--dry-run'] : []),
+                      '--json']
+        try {
+          const { stdout } = await execFileAsync(getPythonCommand(), args, {
+            timeout: 900_000, maxBuffer: 64 * 1024 * 1024, env: pythonProcessEnv(),
+          })
+          const body = JSON.parse(stdout.slice(stdout.indexOf('{')))
+          if (opts.json) {
+            console.log(JSON.stringify(body))
+          } else if (body.dryRun) {
+            console.log(`概念 ${body.nodes} 个、链接 ${body.links} 条（--dry-run：没有写文件）`)
+          } else {
+            console.log(chalk.green(`✓ 已生成 ${body.out}`))
+            console.log(chalk.gray(`  概念 ${body.nodes} / 链接 ${body.links} / ${body.mb} MB · ${opts.flat ? '2D' : '3D'} · 双击就能逛，不需要服务器`))
+          }
+          if (!opts.dryRun && opts.open && body.out) await openLocalUrl(body.out)
+        } catch (error) {
+          if (opts.json) {
+            console.log(JSON.stringify({ success: false, code: 'GRAPH_FAILED', action: 'graph-3d', error: safeSubprocessError(error) }))
+          } else {
+            console.error(chalk.red(`\n✗ ${safeSubprocessError(error)}`))
+          }
+          process.exit(1)
+        }
+      })
+  )
+
   // wiki lint：知识库体检（全本地：不联网、不调用模型）
   program.commands.find(c => c.name() === 'wiki')?.addCommand(
     new Command('lint')
       .description('知识库体检：断链、孤儿、空页、同名（本地，不联网）')
-      .option('--dir <dir>', '概念页目录', './output/wechat-vault/Wiki/Concepts')
+      // 不给默认值：不传 `--dir` 时体检脚本自己的默认（清单里的**全部线**）。
+      // 这里曾经默认只给文章线，而脚本默认两条线都体检 ⇒"半开半合"：命令行跑出来
+      // 与脚本跑出来口径不同，而两边都不报错。
+      .option('--dir <dirs...>', '概念页目录（可重复；不传则体检清单里的全部线）')
       .option('--json', '输出机器可读结果')
       .action(async (opts) => {
         const { execFile } = await import('child_process')
         const { promisify } = await import('util')
         const execFileAsync = promisify(execFile)
         const script = join(resolvePackageRoot(), 'scripts', 'wiki_lint.py')
-        const args = [script, '--dir', String(opts.dir), ...(opts.json ? ['--json'] : [])]
+        const dirs = Array.isArray(opts.dir) ? opts.dir : (opts.dir ? [opts.dir] : [])
+        const args = [script, ...dirs.flatMap((d: string) => ['--dir', String(d)]),
+          ...(opts.json ? ['--json'] : [])]
         try {
           const { stdout } = await execFileAsync(getPythonCommand(), args, {
             timeout: 120_000, maxBuffer: 20 * 1024 * 1024, env: pythonProcessEnv(),
@@ -5366,6 +5772,8 @@ program
     .option('--limit <n>', '最多处理几个会话', '40')
     .option('--dry-run', '仅预览：几个会话、多少字符会发给生成模型（只读本地，零出境）')
     .option('--yes', '确认把对话发送给生成模型')
+    .option('--transcribe-voice',
+            '把缺转写的语音**本机**识别掉再产卡（本地 whisper，慢、吃 CPU、不出网；配合 --dry-run 就是只补转写、不调模型）')
     .option('--json', '输出机器可读结果；执行仍需 --yes')
     .action(async (opts) => {
       const { execFile } = await import('child_process')
@@ -5401,6 +5809,7 @@ program
       }
       const args = [script, '--days', String(days), '--limit', String(limit),
                     ...(confirmed ? ['--yes'] : []),
+                    ...(opts.transcribeVoice ? ['--transcribe-voice'] : []),
                     ...(opts.json ? ['--json'] : []),
                     ...(opts.dryRun ? ['--dry-run'] : [])]
       try {
@@ -5774,7 +6183,7 @@ program
     const isComplete = (targetDate: string): boolean => Object.values(artifactStatus(targetDate)).every(Boolean)
 
     const runPipeline = (targetDate: string): Promise<number> => new Promise((resolve) => {
-      const args = [pipeline, '--date', targetDate, '--engine', noAi ? 'local' : 'deepseek', '--interest', 'AI', '--skip-wiki']
+      const args = [pipeline, '--date', targetDate, '--engine', noAi ? 'local' : 'deepseek', '--interest', 'AI']
       if (noAi) args.push('--no-ai')
       // 与 --no-ai 不同：这一条保留判断（Jev），只关掉 LLM 的文字生成。
       if (opts.noSummary && !noAi) args.push('--no-summary')
@@ -5783,6 +6192,7 @@ program
 
       dailyLog(chalk.cyan(`\n📰 正在生成 ${targetDate} 公众号日报${noAi ? '（AI 已关闭）' : ''}...\n`))
       const child = spawn(getPythonCommand(), args, {
+        windowsHide: true,
         stdio: opts.json ? ['ignore', 'pipe', 'pipe'] : 'inherit',
         env: pythonProcessEnv(apiKey),
       })
@@ -5798,6 +6208,7 @@ program
       const dryRunArgs = [bizDaily, '--date', date, '--engine', 'local', '--dry-run']
       for (const source of opts.source || []) dryRunArgs.push('--source', source)
       const child = spawn(getPythonCommand(), dryRunArgs, {
+        windowsHide: true,
         stdio: opts.json ? ['ignore', 'pipe', 'pipe'] : 'inherit',
         env: pythonProcessEnv(),
       })
@@ -5959,6 +6370,349 @@ dailyFavoritesCmd
 
 program.commands.find(c => c.name() === 'daily')?.addCommand(dailyFavoritesCmd)
 
+// ==================== skill (本机技能包) ====================
+// 技能就是磁盘上的 `SKILL.md`，所以这里**没有安装/卸载**：读、看、体检三件事。
+// 体检（`check`）是最有用的一个 —— 它把"读不出来""不合规范""跨目录撞名"这些
+// 平时完全静默的问题一次报出来（少一个技能不会报错，只会少一个技能）。
+const skillCmd = program
+  .command('skill')
+  .description('本机技能包（SKILL.md）：列出、查看、体检')
+
+skillCmd
+  .command('list')
+  .description('列出扫描到的技能')
+  .option('--query <q>', '按关键词过滤（匹配 id、名称、说明、触发词）')
+  .option('--json', 'JSON 输出')
+  .action((opts) => {
+    const scan = scanSkills()
+    const disabled = disabledIds()
+    const q = String(opts.query || '').trim().toLowerCase()
+    const rows = scan.skills.filter(s => !q
+      || [s.id, s.name, s.description, ...s.triggers].some(x => String(x).toLowerCase().includes(q)))
+      .map(s => ({
+        id: s.id,
+        name: s.name,
+        description: s.description,
+        version: s.version,
+        state: skillState(s, disabled),
+        notes: s.notes,
+        // **不给路径**：这是机器输出，路径只有在用户明确要 `show` 时才出现
+      }))
+    if (opts.json) {
+      console.log(JSON.stringify({
+        success: true,
+        roots: skillRoots(),
+        missingRoots: scan.missingRoots,
+        total: rows.length,
+        skills: rows,
+      }))
+      return
+    }
+    if (!rows.length) {
+      console.log(chalk.gray(scan.skills.length ? `没有匹配「${opts.query}」的技能` : '没有扫描到技能'))
+      console.log(chalk.gray(`技能目录：${skillRoots().join('、')}`))
+      for (const dir of scan.missingRoots) console.log(chalk.gray(`  （不存在：${dir}）`))
+      return
+    }
+    for (const r of rows) {
+      const tag = r.state === 'disabled' ? chalk.gray('[已禁用] ') : ''
+      console.log(`${tag}${chalk.cyan(r.id)}${r.version ? chalk.gray(' v' + r.version) : ''}  ${r.name}`)
+      if (r.description) console.log(chalk.gray(`    ${r.description.slice(0, 100)}`))
+      for (const n of r.notes) console.log(chalk.yellow(`    ⚠ ${n}`))
+    }
+    console.log(chalk.gray(`\n共 ${rows.length} 个。正文：weflow-cli skill show <id>`))
+  })
+
+skillCmd
+  .command('show')
+  .argument('<id>', '技能 id')
+  .description('打印一个技能的 SKILL.md 正文')
+  .option('--json', 'JSON 输出')
+  .action((id, opts) => {
+    const body = readSkillBody(id)
+    if (!body.ok) {
+      if (opts.json) {
+        console.log(JSON.stringify({ success: false, code: 'SKILL_NOT_READABLE', error: body.text }))
+        process.exit(1)
+      }
+      console.log(chalk.red(body.text))
+      return
+    }
+    if (opts.json) {
+      const scan = scanSkills()
+      const info = scan.skills.find(s => s.id === id)
+      console.log(JSON.stringify({
+        success: true,
+        id,
+        name: info?.name ?? id,
+        version: info?.version ?? '',
+        truncated: !!body.truncated,
+        body: body.text,
+      }))
+      return
+    }
+    console.log(body.text)
+  })
+
+skillCmd
+  .command('check')
+  .description('体检：不可读的 SKILL.md、跨目录同名、非规范 id、被禁用的技能')
+  .option('--json', 'JSON 输出')
+  .action((opts) => {
+    const scan = scanSkills()
+    const disabled = disabledIds()
+    const disabledRows = scan.skills.filter(s => skillState(s, disabled) === 'disabled').map(s => s.id)
+    const warned = scan.skills.filter(s => s.notes.length).map(s => ({ id: s.id, notes: s.notes }))
+    const payload = {
+      success: true,
+      roots: skillRoots(),
+      missingRoots: scan.missingRoots,
+      total: scan.skills.length,
+      unreadable: scan.unreadable,
+      conflicts: scan.conflicts,
+      warned,
+      disabled: disabledRows,
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(payload))
+      // 不可读 = 真出事了（有文件却读不出来），体检失败；警告与冲突只提示，不算失败
+      if (scan.unreadable.length) process.exit(1)
+      return
+    }
+    console.log(`技能目录：${skillRoots().join('、')}`)
+    for (const dir of scan.missingRoots) console.log(chalk.gray(`  不存在：${dir}`))
+    console.log(`扫描到 ${scan.skills.length} 个技能`)
+    if (scan.unreadable.length) {
+      console.log(chalk.red(`\n不可读 ${scan.unreadable.length} 个：`))
+      for (const u of scan.unreadable) console.log(chalk.red(`  ✗ ${u.file}\n    ${u.reason}`))
+    }
+    if (scan.conflicts.length) {
+      console.log(chalk.yellow(`\n跨目录同名 ${scan.conflicts.length} 个（靠前的目录胜出，不会覆盖）：`))
+      for (const c of scan.conflicts) console.log(chalk.yellow(`  ! ${c.id}\n    用：${c.winner}\n    忽略：${c.loser}`))
+    }
+    if (warned.length) {
+      console.log(chalk.yellow(`\n有提醒的 ${warned.length} 个：`))
+      for (const w of warned) for (const n of w.notes) console.log(chalk.yellow(`  · ${w.id}：${n}`))
+    }
+    if (disabledRows.length) console.log(chalk.gray(`\n已禁用：${disabledRows.join('、')}`))
+    if (!scan.unreadable.length && !scan.conflicts.length) console.log(chalk.green('\n没有不可读或撞名的技能'))
+  })
+
+// ==================== scene (会话场景) ====================
+const sceneCmd = program
+  .command('scene')
+  .description('会话场景：按会话生效的提示词预设（绑定 → 关键词 → 上次用过的）')
+
+/** 写场景是**本机文件写**，不是 python mutation：同样两段式，措辞照 todos 那条 */
+async function confirmSceneWrite(
+  opts: { dryRun?: boolean; yes?: boolean; json?: boolean },
+  preview: Record<string, unknown>,
+  message: string,
+  apply: () => { ok: boolean; reason?: string },
+): Promise<void> {
+  if (opts.dryRun) {
+    if (opts.json) console.log(JSON.stringify({ success: true, dryRun: true, ...preview }))
+    else console.log(chalk.cyan('预览：') + message)
+    return
+  }
+  if (!opts.yes) {
+    if (opts.json) {
+      console.log(JSON.stringify({
+        success: false,
+        code: 'CONFIRMATION_REQUIRED',
+        error: '先使用 --dry-run --json 预览，再由用户确认后使用 --yes --json 执行',
+      }))
+      process.exit(1)
+    }
+    const { confirmed } = await inquirer.prompt([{ type: 'confirm', name: 'confirmed', message, default: false }])
+    if (!confirmed) {
+      console.log(chalk.gray('已取消'))
+      return
+    }
+  }
+  const result = apply()
+  if (result.ok) assistantScenes.save()
+  const saved = result.ok && !assistantScenes.lastSaveError
+  if (opts.json) {
+    if (!result.ok) {
+      console.log(JSON.stringify({ success: false, code: 'SCENE_OPERATION_FAILED', error: result.reason }))
+      process.exit(1)
+    }
+    // 写失败要说出来：`save()` 不抛异常，代价是必须有地方把它讲出来
+    console.log(JSON.stringify({
+      success: saved,
+      ...(saved ? {} : { code: 'SCENE_SAVE_FAILED', error: assistantScenes.lastSaveError }),
+      ...preview,
+    }))
+    if (!saved) process.exit(1)
+    return
+  }
+  if (!result.ok) {
+    console.log(chalk.red(`✗ ${result.reason}`))
+    process.exit(1)
+  }
+  if (!saved) console.log(chalk.red(`⚠ 已改动内存，但落盘失败：${assistantScenes.lastSaveError}`))
+  else console.log(chalk.green('✓ 完成'))
+}
+
+sceneCmd
+  .command('list')
+  .description('列出所有场景')
+  .option('--json', 'JSON 输出')
+  .action((opts) => {
+    const scenes = assistantScenes.list()
+    if (opts.json) {
+      console.log(JSON.stringify({ success: true, total: scenes.length, scenes }))
+      return
+    }
+    if (!scenes.length) {
+      console.log(chalk.gray('还没有场景。加一个：'))
+      console.log(chalk.gray('  weflow-cli scene add --id 日报 --keywords 日报,推文 --instruction "按主题分组" --dry-run'))
+      return
+    }
+    for (const s of scenes) {
+      console.log(`${s.enabled ? chalk.cyan(s.id) : chalk.gray(s.id + ' [已停用]')}  ${s.name}`)
+      if (s.keywords.length) console.log(chalk.gray(`    关键词：${s.keywords.join('、')}`))
+      if (s.instruction) console.log(chalk.gray(`    ${s.instruction.split('\n')[0].slice(0, 80)}`))
+    }
+  })
+
+sceneCmd
+  .command('show')
+  .argument('<id>', '场景 id')
+  .description('打印一个场景的全部字段')
+  .option('--json', 'JSON 输出')
+  .action((id, opts) => {
+    const scene = assistantScenes.get(id)
+    if (!scene) {
+      if (opts.json) console.log(JSON.stringify({ success: false, code: 'SCENE_NOT_FOUND', error: `没有场景「${id}」` }))
+      else console.log(chalk.red(`没有场景「${id}」`))
+      process.exit(1)
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ success: true, scene }))
+      return
+    }
+    console.log(`id        ${scene.id}`)
+    console.log(`名称      ${scene.name}`)
+    console.log(`状态      ${scene.enabled ? '启用' : '已停用'}`)
+    console.log(`关键词    ${scene.keywords.join('、') || '（无）'}`)
+    console.log(`所需技能  ${scene.skills.join('、') || '（无）'}`)
+    console.log(`附加指令  ${scene.instruction || '（无）'}`)
+    if (scene.outputSpec) console.log(`输出规范  ${scene.outputSpec}`)
+  })
+
+sceneCmd
+  .command('add')
+  .description('新增一个场景')
+  .requiredOption('--id <id>', '场景 id（字母数字开头，可用 . _ -）')
+  .option('--name <name>', '显示名（默认用 id）')
+  .option('--keywords <list>', '关键词，逗号分隔')
+  .option('--instruction <text>', '附加指令（长文本用 --from-file）')
+  .option('--from-file <path>', '从文件读附加指令（多行中文走这条）')
+  .option('--output-spec <text>', '输出规范')
+  .option('--skills <list>', '所需技能 id，逗号分隔')
+  .option('--dry-run', '仅预览，不写入')
+  .option('--yes', '确认写入')
+  .option('--json', 'JSON 输出')
+  .action(async (opts) => {
+    const id = String(opts.id || '').trim()
+    const idError = validateSceneId(id)
+    if (idError) {
+      if (opts.json) console.log(JSON.stringify({ success: false, code: 'INVALID_SCENE_ID', error: idError }))
+      else console.log(chalk.red(idError))
+      process.exit(1)
+    }
+    let instruction = String(opts.instruction || '')
+    if (opts.fromFile) {
+      const path = String(opts.fromFile)
+      if (!existsSync(path)) {
+        if (opts.json) console.log(JSON.stringify({ success: false, code: 'FILE_NOT_FOUND', error: `读不到 ${path}` }))
+        else console.log(chalk.red(`读不到 ${path}`))
+        process.exit(1)
+      }
+      instruction = readFileSync(path, 'utf8')
+    }
+    const splitList = (v: unknown): string[] => String(v || '').split(/[,;]/).map(s => s.trim()).filter(Boolean)
+    const scene: Scene = {
+      id,
+      name: String(opts.name || '').trim() || id,
+      keywords: splitList(opts.keywords),
+      instruction,
+      outputSpec: String(opts.outputSpec || ''),
+      skills: splitList(opts.skills),
+      enabled: true,
+    }
+    await confirmSceneWrite(opts, { action: 'scene.add', scene: { ...scene, instruction: `(${instruction.length} 字)` } },
+      `确认新增场景「${scene.name}」？`, () => assistantScenes.add(scene))
+  })
+
+sceneCmd
+  .command('remove')
+  .argument('<id>', '场景 id')
+  .description('删除一个场景（连同指向它的绑定）')
+  .option('--dry-run', '仅预览，不删除')
+  .option('--yes', '确认删除')
+  .option('--json', 'JSON 输出')
+  .action(async (id, opts) => {
+    const scene = assistantScenes.get(id)
+    if (!scene) {
+      if (opts.json) console.log(JSON.stringify({ success: false, code: 'SCENE_NOT_FOUND', error: `没有场景「${id}」` }))
+      else console.log(chalk.red(`没有场景「${id}」`))
+      process.exit(1)
+    }
+    await confirmSceneWrite(opts, { action: 'scene.remove', id }, `确认删除场景「${scene.name}」？`,
+      () => { assistantScenes.remove(id); return { ok: true } })
+  })
+
+const toggleScene = (on: boolean) => async (id: string, opts: { dryRun?: boolean; yes?: boolean; json?: boolean }) => {
+  const scene = assistantScenes.get(id)
+  if (!scene) {
+    if (opts.json) console.log(JSON.stringify({ success: false, code: 'SCENE_NOT_FOUND', error: `没有场景「${id}」` }))
+    else console.log(chalk.red(`没有场景「${id}」`))
+    process.exit(1)
+  }
+  await confirmSceneWrite(opts, { action: on ? 'scene.enable' : 'scene.disable', id },
+    `确认${on ? '启用' : '停用'}场景「${scene.name}」？`,
+    () => ({ ok: assistantScenes.setEnabled(id, on) }))
+}
+
+sceneCmd.command('enable')
+  .argument('<id>', '场景 id')
+  .description('启用一个场景')
+  .option('--dry-run', '仅预览').option('--yes', '确认').option('--json', 'JSON 输出')
+  .action(toggleScene(true))
+
+sceneCmd.command('disable')
+  .argument('<id>', '场景 id')
+  .description('停用一个场景（它不再参与匹配）')
+  .option('--dry-run', '仅预览').option('--yes', '确认').option('--json', 'JSON 输出')
+  .action(toggleScene(false))
+
+sceneCmd
+  .command('bind')
+  .argument('<conversation>', '会话 id（微信里就是 conversationId；本机面板用它的记忆桶）')
+  .requiredOption('--scene <id>', '要绑定的场景 id')
+  .description('把某个场景固定绑到一个会话')
+  .option('--dry-run', '仅预览').option('--yes', '确认').option('--json', 'JSON 输出')
+  .action(async (conversation, opts) => {
+    const id = String(opts.scene || '').trim()
+    await confirmSceneWrite(opts, { action: 'scene.bind', conversation, scene: id },
+      `确认把场景「${id}」绑到会话 ${conversation}？`,
+      () => assistantScenes.bind(conversation, id))
+  })
+
+sceneCmd
+  .command('unbind')
+  .argument('<conversation>', '会话 id')
+  .description('解绑：这个会话回到按关键词自动挑')
+  .option('--dry-run', '仅预览').option('--yes', '确认').option('--json', 'JSON 输出')
+  .action(async (conversation, opts) => {
+    await confirmSceneWrite(opts, { action: 'scene.unbind', conversation },
+      `确认解绑会话 ${conversation}？`,
+      () => assistantScenes.bind(conversation, null))
+  })
+
 // ==================== assistant (第二大脑持久化 Agent) ====================
 const assistantCmd = program
   .command('assistant')
@@ -6394,6 +7148,51 @@ program
     }
   })
 
+// ==================== bonds ====================
+program
+  .command('bonds')
+  .description('关系温度：谁在冷却、谁在变热、谁只有微信这一条线（只读本地库，不联网、不调模型）')
+  .option('--days <number>', '看最近多少天', '365')
+  .option('--limit <number>', '最多扫几个会话', '400')
+  .option('--top <number>', '每组列几条', '12')
+  .option('--skip <name>', '排除某个名字或 id（可重复）', (value: string, acc: string[]) => {
+    acc.push(value)
+    return acc
+  }, [] as string[])
+  .option('--json', '输出 JSON 格式')
+  .action(async (opts) => {
+    const { execFile } = await import('child_process')
+    const { promisify } = await import('util')
+    const execFileAsync = promisify(execFile)
+    const script = join(resolvePackageRoot(), 'scripts', 'bonds.py')
+    const days = parseCliInteger(opts.days, 'days', 1, 3650, opts.json)
+    const limit = parseCliInteger(opts.limit, 'limit', 1, 5000, opts.json)
+    const top = parseCliInteger(opts.top, 'top', 1, 200, opts.json)
+
+    try {
+      const args = [script, '--days', String(days), '--limit', String(limit), '--top', String(top)]
+      for (const name of (opts.skip as string[]) || []) args.push('--skip', name)
+      if (opts.json) args.push('--json')
+      const { stdout } = await execFileAsync(getPythonCommand(), args, {
+        timeout: 300_000,
+        maxBuffer: 10 * 1024 * 1024,
+        env: pythonProcessEnv(),
+      })
+      console.log(stdout)
+    } catch (e: any) {
+      if (opts.json) {
+        console.log(JSON.stringify({
+          success: false,
+          code: 'BONDS_FAILED',
+          error: '关系温度不可用，请运行 check --json 检查配置和依赖',
+        }))
+        process.exit(1)
+      }
+      console.error(chalk.red(`\n${safeSubprocessError(e, '统计失败')}`))
+      process.exit(1)
+    }
+  })
+
 // ==================== daily-server ====================
 program
   .command('daily-server')
@@ -6469,6 +7268,7 @@ program
     }
 
     const child = spawn(getPythonCommand(), [favServer, '--date', date, '--port', String(port)], {
+      windowsHide: true,
       stdio: 'inherit',
       env: pythonProcessEnv(),
     })
@@ -6527,6 +7327,10 @@ program
       console.log(chalk.gray('AI 助手现在可以使用以下工具：'))
     } else {
       console.log(json)
+      // 机器模式到这里就结束：下面那段工具清单与"复制以上 JSON…"是**给人看的**，原来无条件打在
+      // stdout 上 ⇒ `mcp-config --json-result | jq` 断在第 14 行（2026-10-12 由只读驱动扫描发现；
+      // 写路径本来就早退发 JSON，所以只有读路径这一处漏）。
+      if (opts.jsonResult) return
     }
     console.log(chalk.cyan('\n可用的 MCP 工具：'))
     const STATIC_TOOLS: Array<[string, string]> = [
@@ -6565,18 +7369,40 @@ program
   .description('检查运行环境（Python、pip 依赖、数据库配置）')
   .option('--json', '输出 JSON 格式，不包含数据库路径或密钥')
   .action(async (opts) => {
+    // 微信客户端的**版本**与它自报的**数据目录**：两个分支都要用，所以在这里算一次。
+    // 判据见 `wechatClient.ts`（版本取活进程的 `--user-lib-dir`；取不到就是"未知"，不是"没问题"）。
+    const client = await detectWechatClient()
+    // 客户端自报的数据目录 vs 配置里那个数据库推出来的根：**只比是不是同一份**，
+    // 路径本身不进机器可读输出（`wechat-check/v1` 一直是不含路径的）。
+    //
+    // **只在 4.x 上比**：这个根是从 `ntDbPath`（4.x 的库）推的，而客户端自报的那条来自 4.x 客户端
+    // —— 只用 3.x 的用户（`dbPath3x`）比出来的"不是同一份"没有意义，而这句话**只在 false 时打印**
+    // ⇒ 那就是一条假警告。判据不成立时给 null（"不知道"），不是 false。
+    const { dirname } = await import('node:path')
+    // **四层**：`…/xwechat_files/<wxid>/db_storage/message/message_0.db`
+    // → message → db_storage → <wxid> → xwechat_files。少一层就退到 `<wxid>` 目录，
+    // 于是两个路径永远不相等、永远报"不是同一份"（一个看着很合理的假警告）。
+    const dbPathConfigured = String(configService.get('dataVersion') || '') === '4.x'
+      ? String(configService.get('ntDbPath') || '')
+      : ''
+    const configuredRoot = dbPathConfigured
+      ? dirname(dirname(dirname(dirname(dbPathConfigured))))
+      : ''
+    const dataDirMatchesConfig = (client.dataDirs.length && configuredRoot)
+      ? client.dataDirs.some(dir => samePath(dir, configuredRoot))
+      : null
     if (opts.json) {
       const { execFileSync } = await import('child_process')
       const requiredDependencies = ['sqlcipher3', 'html2text', 'zstandard', 'cryptography']
       const optionalDependencies = ['scrapling']
       let pythonVersion = ''
       try {
-        pythonVersion = execFileSync(getPythonCommand(), ['--version'], { encoding: 'utf8', timeout: 5000 }).trim()
+        pythonVersion = execFileSync(getPythonCommand(), ['--version'], { windowsHide: true, encoding: 'utf8', timeout: 5000 }).trim()
       } catch {}
       const dependencyStatus = (name: string): boolean => {
         if (!pythonVersion) return false
         try {
-          execFileSync(getPythonCommand(), ['-c', `import ${name}`], { stdio: 'ignore', timeout: 5000 })
+          execFileSync(getPythonCommand(), ['-c', `import ${name}`], { windowsHide: true, stdio: 'ignore', timeout: 5000 })
           return true
         } catch {
           return false
@@ -6618,6 +7444,26 @@ program
           messageChannelLoggedIn: !!configService.get('wechatOcToken'),
           daemonRunning: daemonAlive,
         },
+        // `version` 只从活进程取；取不到就是 null + 一句 `note`（**不是**"没问题"）。
+        // `unusableVersionDirs` 是磁盘上的残留版本目录（没有 `Weixin.dll`）—— 指向它们的加载会失败。
+        wechatClient: {
+          running: client.running,
+          version: client.version,
+          loadedDirs: client.loadedDirs,
+          // 客户端自报的构建 token（并列的第二来源；**不拿它推版本号**，编码规则没解出来）
+          versionTokens: client.versionTokens,
+          note: client.note,
+          unusableVersionDirs: client.unusableVersionDirs,
+          // 客户端**自己说**数据目录在哪（与配置不一致时说明两边不是同一份库）
+          dataDirs: client.dataDirs,
+          // 只报结论（true/false/null），**不带路径** —— 这条 schema 一直是不含路径的
+          dataDirMatchesConfig,
+          // `update.data` 在场 ⇒ 加载路径可能不由命令行决定：这条不确定必须跟着版本一起出去
+          updateData: client.updateData,
+          // 只报条数与最近时间（不读崩溃内容）
+          crashRecords: client.crashRecords,
+          caveats: client.caveats,
+        },
       }
       console.log(JSON.stringify(data, null, 2))
       return
@@ -6632,7 +7478,7 @@ program
     const pythonCommand = getPythonCommand()
     let pythonOk = false
     try {
-      const pyVer = execFileSync(pythonCommand, ['--version'], { encoding: 'utf-8', timeout: 5000 }).trim()
+      const pyVer = execFileSync(pythonCommand, ['--version'], { windowsHide: true, encoding: 'utf-8', timeout: 5000 }).trim()
       console.log(chalk.white('Python: '), chalk.green(pyVer))
       pythonOk = true
     } catch {
@@ -6646,7 +7492,7 @@ program
       let allOk = true
       for (const dep of deps) {
         try {
-          execFileSync(pythonCommand, ['-c', `import ${dep}`], { stdio: 'ignore', timeout: 5000 })
+          execFileSync(pythonCommand, ['-c', `import ${dep}`], { windowsHide: true, stdio: 'ignore', timeout: 5000 })
           console.log(`  ${dep.padEnd(20)} ${chalk.green('✓')}`)
         } catch {
           console.log(`  ${dep.padEnd(20)} ${chalk.red('✗ 缺失')}`)
@@ -6667,7 +7513,7 @@ program
       console.log(chalk.white('\n可选依赖（提升抓取成功率）:'))
       for (const dep of optDeps) {
         try {
-          execFileSync(pythonCommand, ['-c', `import ${dep}`], { stdio: 'ignore', timeout: 5000 })
+          execFileSync(pythonCommand, ['-c', `import ${dep}`], { windowsHide: true, stdio: 'ignore', timeout: 5000 })
           console.log(`  ${dep.padEnd(20)} ${chalk.green('✓')}`)
         } catch {
           console.log(`  ${dep.padEnd(20)} ${chalk.gray('○ (pip install scrapling)')}`)
@@ -6702,7 +7548,38 @@ program
       }
     }
 
-    // 6. Assistant (第二大脑)
+    // 6. 微信客户端版本（`client` / `dataDirMatchesConfig` 在 action 开头已经算过）
+    console.log(chalk.white('\n微信客户端:'))
+    if (client.version) {
+      // 并列报上客户端自报的构建 token：这是"哪个构建"的第二个来源（**不用它推版本号**）
+      const token = client.versionTokens.length ? chalk.gray(`  · 自报构建 ${client.versionTokens.join('、')}`) : ''
+      console.log(chalk.green(`  ✓ 运行时加载 ${client.version}`) + chalk.gray(` (${client.loadedDirs[0]})`) + token)
+    } else {
+      // **说"未知"而不是"没问题"**：取不到就说取不到，别给人一个假的安心
+      console.log(chalk.gray(`  ○ 版本未知 — ${client.note}`))
+    }
+    for (const dead of client.unusableVersionDirs) {
+      console.log(chalk.yellow(`  ! 残留版本目录 ${dead.dir}：只剩 ${dead.files} 个文件（没有 Weixin.dll）`))
+      console.log(chalk.gray('    指向它的加载会失败；如果客户端起不来，先看这里'))
+    }
+    // `update.data` 在场时上面那个版本**未必**是加载的那个 —— 这句话要跟着它一起出现
+    for (const caveat of client.caveats) {
+      console.log(chalk.yellow(`  ⚠ ${caveat}`))
+    }
+    if (client.dataDirs.length) {
+      console.log(chalk.gray(`  · 客户端自报数据目录: ${client.dataDirs.join('、')}`))
+      if (dataDirMatchesConfig === false) {
+        // 不一致 = 两边可能不是同一份库（本机数据目录还有 D 盘软链，这条已经按真身比过）
+        console.log(chalk.yellow('    ⚠ 与配置里那个数据库推出来的根**不是同一份** —— 先确认你在读的是客户端正在写的那份'))
+      }
+    }
+    const crashes = client.crashRecords.reports + client.crashRecords.records
+    if (crashes > 0) {
+      const when = client.crashRecords.newest ? client.crashRecords.newest.slice(0, 16).replace('T', ' ') : '时间读不到'
+      console.log(chalk.gray(`  · 客户端崩溃记录 ${crashes} 份（最近 ${when}）—— 客户端崩过时数据读不出来，先看这条`))
+    }
+
+    // 7. Assistant (第二大脑)
     console.log(chalk.white('\n第二大脑 Agent:'))
     const aiKey = configService.get('deepseekApiKey')
     const aiBase = configService.get('aiBaseUrl')
@@ -6923,7 +7800,8 @@ async function showInteractiveMenu() {
       const { spawn } = await import('child_process')
       const pipeline = join(resolvePackageRoot(), 'scripts', 'pipeline.py')
       console.log(chalk.cyan(`\n📰 正在生成 ${dateStr} 公众号日报...\n`))
-      const child = spawn(getPythonCommand(), [pipeline, '--date', dateStr, '--interest', 'AI', '--skip-wiki'], {
+      const child = spawn(getPythonCommand(), [pipeline, '--date', dateStr, '--interest', 'AI'], {
+        windowsHide: true,
         stdio: 'inherit',
         env: pythonProcessEnv(apiKey),
       })