weflow-cli 1.8.1 → 1.9.0

package/dist/bin/weflow-cli.js

@@ -21,7 +21,10 @@ 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 { disabledIds, readSkillBody, scanSkills, skillRoots, skillState } from '../src/services/assistantSkills.js';
+import { assistantScenes, validateSceneId } from '../src/services/assistantScenes.js';
 const program = new Command();
 function resolvePackageRoot() {
     return resolvePackageRootFrom(import.meta.url);
@@ -264,7 +267,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',
@@ -298,8 +301,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',
@@ -382,6 +413,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',
@@ -978,6 +1036,7 @@ const configurableKeys = [
     'wereadApiKey',
     'assistantPrivacy', 'assistantWhitelist', 'assistantGroupWhitelist',
     'assistantGroupRequireMention', 'assistantFastRoute', 'assistantPanelUser', 'quickReplyContacts',
+    'skillDirs', 'skillDisabled',
     'dailySources', 'dailySourceCategories',
     'dailyExcludeTopics', 'dailyAiEnabled',
     'emoticonSeed',
@@ -3379,57 +3438,50 @@ program
         });
         process.exit(1);
     }
-    // 黑名单优先拦截
-    if (whitelistService.isBlocked(wxid)) {
+    // 三道闸（黑名单 → 白名单 → 限速）与"每次尝试都写审计"在 `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: 'TARGET_BLOCKED', error: '目标在黑名单中', target: { wxid, displayName } }));
-        else {
+            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 {
+            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 = {
         action: 'send',
@@ -3480,41 +3532,8 @@ program
         }
         process.exit(1);
     }
-    const service = new WechatMessageService({ token });
-    let success = false;
-    let errorMsg;
-    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 }));
@@ -4694,6 +4713,7 @@ program
         await openLocalUrl(`http://localhost:${port}`);
     }
     const child = spawn(getPythonCommand(), args, {
+        windowsHide: true,
         stdio: 'inherit',
         env: pythonProcessEnv(),
     });
@@ -5241,6 +5261,7 @@ program
         // 交互模式：使用 spawn 保持终端交互
         args.push('--interactive', '--top-k', String(topK));
         const child = spawn(getPythonCommand(), args, {
+            windowsHide: true,
             stdio: 'inherit',
             env: {
                 ...pythonProcessEnv(opts.apiKey),
@@ -5514,6 +5535,10 @@ program
     .command('draft <talker>')
     .description('帮我起草回复：先判断（意图/风险/该不该给实质），再起草候选 —— **只产出文本，不发送**')
     .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', '确认把这段对话发送到判断模型与生成模型')
@@ -5522,9 +5547,22 @@ 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`，脚本照样拒绝（用户看到的是"我确认了它却说没确认"）。
@@ -5552,6 +5590,170 @@ 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 = [];
+        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;
+        try {
+            wxid = await resolveTalker(String(talker), !!opts.json, !!opts.json);
+        }
+        catch (error) {
+            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',
+            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'] : []),
@@ -6030,6 +6232,7 @@ program
             args.push('--skip-classify');
         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),
         });
@@ -6045,6 +6248,7 @@ program
         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(),
         });
@@ -6191,6 +6395,351 @@ dailyFavoritesCmd
     await runDailyFavorites(merged.date || defaultDailyDate(), merged.root, ['--remove', ...articles], 'daily.favorites.remove', merged);
 });
 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, preview, message, apply) {
+    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) => String(v || '').split(/[,;]/).map(s => s.trim()).filter(Boolean);
+    const 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) => 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: 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')
@@ -6643,6 +7192,52 @@ program
         process.exit(1);
     }
 });
+// ==================== bonds ====================
+program
+    .command('bonds')
+    .description('关系温度：谁在冷却、谁在变热、谁只有微信这一条线（只读本地库，不联网、不调模型）')
+    .option('--days <number>', '看最近多少天', '365')
+    .option('--limit <number>', '最多扫几个会话', '400')
+    .option('--top <number>', '每组列几条', '12')
+    .option('--skip <name>', '排除某个名字或 id（可重复）', (value, acc) => {
+    acc.push(value);
+    return acc;
+}, [])
+    .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 || [])
+            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) {
+        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')
@@ -6724,6 +7319,7 @@ program
         await openLocalUrl(`http://localhost:${port}`);
     }
     const child = spawn(getPythonCommand(), [favServer, '--date', date, '--port', String(port)], {
+        windowsHide: true,
         stdio: 'inherit',
         env: pythonProcessEnv(),
     });
@@ -6828,14 +7424,14 @@ program
         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) => {
             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 {
@@ -6891,7 +7487,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;
     }
@@ -6905,7 +7501,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 {
@@ -6928,7 +7524,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 {
@@ -7185,6 +7781,7 @@ async function showInteractiveMenu() {
             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'], {
+                windowsHide: true,
                 stdio: 'inherit',
                 env: pythonProcessEnv(apiKey),
             });