@huicai/cli 2026.814.0 → 2026.1021.0

package/bin/huicai.js

@@ -12,6 +12,12 @@ import { startRepl, runOnce } from '../src/repl.js';
 import { buildSystemPrompt } from '../src/context.js';
 import * as sessions from '../src/session.js';
 import { loadLocalSkills, skillDirs, writeSkillToDir, readSkillDirForPush } from '../src/skills.js';
+import { scanSkillPackage, formatScanReport } from '../src/skill-scan.js';
+import { refreshPlan, isPlanLimitError } from '../src/plan-limits.js';
+import fs from 'node:fs';
+import { lintSkillLibrary } from '../src/skill-lint.js';
+import { tokenize } from '../src/codeindex.js';
+import { createUpdater, displayVersion } from './update.js';
 
 // 版本从 package.json 读取（versionDisplay 年月日展示式，与 VSCode 扩展、IDEA 插件一致）；勿手改，用 scripts/next-version.cjs
 const _pkg = createRequire(import.meta.url)('../package.json');
@@ -63,6 +69,9 @@ function parse(argv) {
       case '--overwrite':
         flags.overwrite = true;
         break;
+      case '--force-unsafe':
+        flags.forceUnsafe = true;
+        break;
       case '--paste':
         flags.paste = true;
         break;
@@ -111,62 +120,63 @@ function parse(argv) {
 
 function usage() {
   process.stdout.write(`
-${c.bold('huicai')} — 终端智能体，以 HuiCai_AI 平台为模型后端，在本机执行工具。
+${c.bold('huicai')} — 终端智能体，以HuiCai_AI平台为模型后端，在本机执行工具。
 
 用法:
-  huicai                     进入交互式会话（当前目录）
+  huicai进入交互式会话（当前目录）
   huicai "帮我修复登录bug"     进入会话并先执行该指令
   huicai -p "运行测试并总结"   一次性执行后退出（脚本/CI；写/执行需 --yolo）
   cat err.log | huicai -p "分析这段日志"   管道内容自动作为上下文
   huicai --agent <id>        采用某已发布智能体的人格（工具仍在本机执行）
   huicai -c ["prompt"]       继续当前目录最近一次会话
-  huicai -r                  从当前目录历史会话中选择恢复
+  huicai -r从当前目录历史会话中选择恢复
   huicai resume <id>         恢复指定会话
-  huicai sessions [-a]       列出历史会话（-a 跨目录全部）
-  huicai login               浏览器授权登录（内置平台地址，无需输入网关）
-  huicai login --paste       无浏览器环境：手动粘贴 API 令牌
-  huicai logout              退出登录（清除本机保存的令牌）
-  huicai models              列出可用模型
-  huicai usage               查看 Token 用量窗口（5小时/7天，按会员等级）
-  huicai skills              列出本地 + 平台技能（Agent Skills）
-  huicai daemon              调度守护：按 cron 真正运行 /schedule 登记的定时任务
+  huicai sessions [-a]       列出历史会话（-a跨目录全部）
+  huicai login浏览器授权登录（内置平台地址，无需输入网关）
+  huicai login --paste无浏览器环境：手动粘贴API令牌
+  huicai logout退出登录（清除本机保存的令牌）
+  huicai models列出可用模型
+  huicai usage查看Token用量窗口（5小时/7天，按会员等级）
+  huicai skills列出本地 + 平台技能（Agent Skills）
+  huicai daemon调度守护：按cron真正运行 /schedule登记的定时任务
   huicai watch ["*.js"] [-p] 文件监听：变更即触发一个智能体任务（如保存即跑测试）
-  huicai pr [commit]         自动提交并开 PR（生成规范 commit→建分支→push→gh 开 PR）
-  huicai kb-sync <id> [ref]  配合 git diff 增量同步知识库，保鲜 RAG（--dry 试运行）
-  huicai skills pull [name]  平台技能 → 本地（默认 ~/.huicai/skills；--project 放入项目）
-  huicai skills push <name>  本地技能 → 平台（默认同名跳过；--overwrite 覆盖）
-  huicai python [setup]      托管 Python 运行时：状态/预装/整包打包(pack)/重置（数据分析与办公文档的地基）
-  huicai uninstall [--yes]   清理本机所有 CLI 数据（~/.huicai：配置/令牌/会话/记忆/技能…）
-  huicai help                显示本帮助
+  huicai pr [commit]         自动提交并开PR（生成规范commit→建分支→push→gh开PR）
+  huicai kb-sync <id> [ref]  配合git diff增量同步知识库，保鲜RAG（--dry试运行）
+  huicai skills lint校验本地技能（结构 + 触发路由；离线，不改文件）
+  huicai skills pull [name]  平台技能 → 本地（默认 ~/.huicai/skills；--project放入项目）
+  huicai skills push <name>  本地技能 → 平台（默认同名跳过；--overwrite覆盖）
+  huicai python [setup]      托管Python运行时：状态/预装/整包打包(pack)/重置（数据分析与办公文档的地基）
+  huicai uninstall [--yes]   清理本机所有CLI数据（~/.huicai：配置/令牌/会话/记忆/技能…）
+  huicai help显示本帮助
 
 选项:
   -m, --model <id>       指定模型（覆盖配置）
-  --agent <id>           采用平台智能体人格（分享令牌或 agent-xxx）
+  --agent <id>           采用平台智能体人格（分享令牌或agent-xxx）
   --consult <ref>        混合模式：本机驱动模型 + 平台智能体/工作流/数字人/专家团(agent-/workflow-/datahuman-/squad-xxx)作咨询工具
-  -c, --continue         继续最近一次会话（当前目录）
-  -r, --resume           选择并恢复历史会话（当前目录）
+  -c, --continue继续最近一次会话（当前目录）
+  -r, --resume选择并恢复历史会话（当前目录）
   --base <url>           覆盖内置平台地址（自建 / 联调用）
-  --key <sk-...>         API 令牌（覆盖配置）
+  --key <sk-...>         API令牌（覆盖配置）
   --cwd <dir>            指定工作目录（默认当前目录）
-  --yolo                 自动放行写/执行工具（谨慎）
-  --tui / --plain        强制富 TUI（ink）/ 普通 REPL（默认 TTY 下自动用 TUI）
-  -p, --print            一次性非交互模式
-  --output-format <fmt>  -p 输出格式：text（默认）| json（结构化，脚本集成）
+  --yolo自动放行写/执行工具（谨慎）
+  --tui / --plain全屏工作台 / 普通REPL（默认TTY下全屏，非TTY使用普通模式）
+  -p, --print一次性非交互模式
+  --output-format <fmt>  -p输出格式：text（默认）| json（结构化，脚本集成）
   --max-turns <n>        单回合最大工具轮数（默认 60）
   --system-prompt <s>        完全替换系统提示词（-p/新会话）
   --append-system-prompt <s> 在系统提示词末尾追加指示
-  -h, --help             帮助
-  -v, --version          版本
+  -h, --help帮助
+  -v, --version版本
 
 交互技巧:
-  /help 查看命令 · @文件 引用文件（PDF/Word/Excel 等自动解析为文本、图片作为视觉输入） · !命令 直通 shell（输出进上下文）
-  模型 -m auto 或 /model auto：按账号自动选择可用模型（与 VSCode 扩展一致）
-  自定义命令：.huicai/commands/<名>.md（$ARGUMENTS 为参数占位符）
+  /help查看命令 · @文件 引用文件（PDF/Word/Excel等自动解析为文本、图片作为视觉输入） · !命令 直通shell（输出进上下文）
+  模型 -m auto或 /model auto：按账号自动选择可用模型（与VSCode扩展一致）
+  自定义命令：.huicai/commands/<名>.md（$ARGUMENTS为参数占位符）
   权限规则：.huicai/settings.json {"permissions":{"allow":["run_bash(git *)"]}}
 
-会话默认自动保存到 ~/.huicai/sessions（按项目目录归属），随时可 -c/-r 恢复。
+会话默认自动保存到 ~/.huicai/sessions（按项目目录归属），随时可 -c/-r恢复。
 
-配置: ${CONFIG_PATH}（或环境变量 HUICAI_BASE_URL / HUICAI_API_KEY / HUICAI_MODEL / HUICAI_MAX_TURNS）
+配置: ${CONFIG_PATH}（或环境变量HUICAI_BASE_URL / HUICAI_API_KEY / HUICAI_MODEL / HUICAI_MAX_TURNS）
 `);
 }
 
@@ -178,17 +188,17 @@ async function login(flags = {}) {
   let key = cur.apiKey;
   if (!flags.paste) {
     // 默认：直接打开浏览器授权（设备码流），无需任何输入
-    process.stdout.write(c.bold('\n登录 huicai') + c.gray(` · ${normBase}`) + '\n');
+    process.stdout.write(c.bold('\n登录huicai') + c.gray(` · ${normBase}`) + '\n');
     try {
       key = await deviceLogin(normBase);
     } catch (e) {
-      process.stdout.write(c.yellow(`浏览器授权未完成（${e.message}），可改用 huicai login --paste 手动粘贴令牌。`) + '\n');
+      process.stdout.write(c.yellow(`浏览器授权未完成（${e.message}），可改用huicai login --paste手动粘贴令牌。`) + '\n');
       return;
     }
   } else {
     // 显式 --paste：无浏览器环境下手动粘贴令牌
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    key = (await new Promise((r) => rl.question(`API 令牌 (sk-huicai-…)${cur.apiKey ? ' [回车保留已保存]' : ''}: `, r))).trim()
+    key = (await new Promise((r) => rl.question(`API令牌 (sk-huicai-…)${cur.apiKey ? ' [回车保留已保存]' : ''}: `, r))).trim()
       || cur.apiKey;
     rl.close();
     if (!key) {
@@ -220,15 +230,15 @@ async function login(flags = {}) {
   saveConfig({ baseUrl: normBase, apiKey: key, model });
   if (tokenOk) {
     process.stdout.write(c.green('登录成功') + (model ? c.gray(` · 默认模型 ${model}`) : '') + '\n');
-    process.stdout.write(c.gray(`已保存到 ${CONFIG_PATH}，直接运行 huicai 开始。`) + '\n');
+    process.stdout.write(c.gray(`已保存到 ${CONFIG_PATH}，直接运行huicai开始。`) + '\n');
   } else {
-    process.stdout.write(c.yellow(`令牌已保存到 ${CONFIG_PATH}，但校验未通过——请重试 huicai login 或联系管理员。`) + '\n');
+    process.stdout.write(c.yellow(`令牌已保存到 ${CONFIG_PATH}，但校验未通过——请重试huicai login或联系管理员。`) + '\n');
   }
 }
 
 function validateAuth(config) {
-  if (!config.baseUrl) return c.red('未配置平台地址。运行 `huicai login` 或设置 HUICAI_BASE_URL。');
-  if (!config.apiKey) return c.red('未配置 API 令牌。运行 `huicai login` 或设置 HUICAI_API_KEY。');
+  if (!config.baseUrl) return c.red('未配置平台地址。运行 `huicai login` 或设置HUICAI_BASE_URL。');
+  if (!config.apiKey) return c.red('未配置API令牌。运行 `huicai login` 或设置HUICAI_API_KEY。');
   return null;
 }
 
@@ -280,7 +290,7 @@ async function cmdUsage(config) {
       process.stderr.write(c.red('拉取用量失败：平台未返回用量数据（请确认平台已支持 /v1/usage）') + '\n');
       process.exit(1);
     }
-    process.stdout.write(c.bold('Token 用量窗口（按会员等级）') + '\n');
+    process.stdout.write(c.bold('Token用量窗口（按会员等级）') + '\n');
     process.stdout.write('  近 5 小时：' + fmt(u.used5h, u.limit5h) + '\n');
     process.stdout.write('  近 7 天　：' + fmt(u.used7d, u.limit7d) + '\n');
     if (!u.allowed && u.message) {
@@ -308,7 +318,7 @@ async function cmdPython(config, rest) {
   if (action === 'status') {
     const s = py.runtimeStatus(config);
     const mark = (ok) => (ok ? c.green('✓') : c.yellow('•'));
-    process.stdout.write(c.bold('托管 Python 运行时') + c.gray('（' + s.dir + '）') + '\n');
+    process.stdout.write(c.bold('托管Python运行时') + c.gray('（' + s.dir + '）') + '\n');
     process.stdout.write(`  ${mark(s.uv)} uv ${s.uv ? '已就绪' + (s.uvVersion ? '（' + s.uvVersion + '）' : '') : '未安装'}\n`);
     process.stdout.write(`  ${mark(s.python)} CPython ${s.python ? s.pythonVersion + ' 已就绪' : '未安装'}\n`);
     process.stdout.write(`  ${mark(s.venv)} 虚拟环境 ${s.venv ? s.venvPython : '未创建'}\n`);
@@ -319,7 +329,7 @@ async function cmdPython(config, rest) {
     const mir = [s.mirrors.bundle && '整包=' + s.mirrors.bundle, s.mirrors.uv && 'uv=' + s.mirrors.uv,
       s.mirrors.python && 'python=' + s.mirrors.python, s.mirrors.pypi && 'PyPI=' + s.mirrors.pypi].filter(Boolean);
     if (mir.length) process.stdout.write(c.gray('  镜像：' + mir.join('  ')) + '\n');
-    if (!s.ready) process.stdout.write(c.gray('  （huicai python setup 立即安装；或首次数据分析任务时自动安装）') + '\n');
+    if (!s.ready) process.stdout.write(c.gray('  （huicai python setup立即安装；或首次数据分析任务时自动安装）') + '\n');
     return;
   }
 
@@ -349,7 +359,7 @@ async function cmdPython(config, rest) {
       const r = await py.packRuntime({ outDir, config, log: (line) => process.stdout.write(c.gray('  ' + line) + '\n') });
       process.stdout.write(c.green('✅ 整包完成：') + r.file + c.gray(`（${Math.round(r.size / 1024 / 1024)}MB）`) + '\n');
       process.stdout.write(c.gray('  清单已更新：' + r.manifest) + '\n');
-      process.stdout.write(c.gray('  托管到静态目录后配置 HUICAI_PYRT_BUNDLE=<基址> 即启用整包直下') + '\n');
+      process.stdout.write(c.gray('  托管到静态目录后配置HUICAI_PYRT_BUNDLE=<基址> 即启用整包直下') + '\n');
     } catch (e) {
       process.stderr.write(c.red('打包失败：' + e.message) + '\n');
       process.exit(1);
@@ -363,11 +373,11 @@ async function cmdPython(config, rest) {
       process.exit(1);
     }
     py.resetRuntime();
-    process.stdout.write(c.green('✅ 已清空托管 Python 运行时（下次使用时自动重装）') + '\n');
+    process.stdout.write(c.green('✅ 已清空托管Python运行时（下次使用时自动重装）') + '\n');
     return;
   }
 
-  process.stderr.write(c.red(`未知子命令：python ${action}（可用：status / setup / pack [--out 目录] / reset --yes）`) + '\n');
+  process.stderr.write(c.red(`未知子命令：python ${action}（可用：status / setup / pack [--out目录] / reset --yes）`) + '\n');
   process.exit(1);
 }
 
@@ -375,6 +385,7 @@ async function cmdPython(config, rest) {
  * skills 子命令：本地技能与平台云端技能库的查看/同步。
  *   huicai skills                    列出本地 + 平台技能
  *   huicai skills pull [name]       平台 → 本地（默认 ~/.huicai/skills；--project 放入项目 .huicai/skills）
+ *                                   落盘前过安全扫描；扫出严重风险即拦截，--force-unsafe 可强行拉取
  *   huicai skills push <name|目录>   本地 → 平台（默认同名跳过；--overwrite 覆盖）
  */
 async function cmdSkills(config, args, flags, cwd) {
@@ -382,9 +393,9 @@ async function cmdSkills(config, args, flags, cwd) {
   const locals = loadLocalSkills(cwd);
 
   if (action === 'list') {
-    process.stdout.write(c.bold('本地技能') + c.gray('（.huicai/skills 与 ~/.huicai/skills）') + '\n');
+    process.stdout.write(c.bold('本地技能') + c.gray('（.huicai/skills与 ~/.huicai/skills）') + '\n');
     if (!locals.length) {
-      process.stdout.write(c.gray('  （无。huicai skills pull 可从平台拉取）') + '\n');
+      process.stdout.write(c.gray('  （无。huicai skills pull可从平台拉取）') + '\n');
     } else {
       for (const s of locals) {
         process.stdout.write(`  ${s.name}${s.version ? c.gray(' v' + s.version) : ''}`
@@ -394,7 +405,7 @@ async function cmdSkills(config, args, flags, cwd) {
     }
     const problem = validateAuth(config);
     if (problem) {
-      process.stdout.write(c.gray('（未登录，跳过平台技能列表；huicai login 后可 pull/push）') + '\n');
+      process.stdout.write(c.gray('（未登录，跳过平台技能列表；huicai login后可pull/push）') + '\n');
       return;
     }
     try {
@@ -417,6 +428,30 @@ async function cmdSkills(config, args, flags, cwd) {
     return;
   }
 
+  // 校验（纯本地、离线，放在登录门禁之前）
+  if (action === 'lint') {
+    const roots = args.slice(1).filter((a) => !a.startsWith('--'));
+    const targets = roots.length ? roots : skillDirs(cwd).filter((d) => fs.existsSync(d));
+    if (!targets.length) {
+      process.stdout.write(c.gray('没有可校验的技能库（项目 .huicai/skills与 ~/.huicai/skills都不存在）') + '\n');
+      return;
+    }
+    const rep = lintSkillLibrary(targets, tokenize, { strict: !!flags.strict });
+    for (const r of rep.results) {
+      if (!r.errors.length && !r.warnings.length) continue;
+      process.stdout.write(`${r.errors.length ? c.red('✗') : c.yellow('·')} ${r.name}\n`);
+      for (const m of r.errors) process.stdout.write('    ' + c.red('错误 ') + m + '\n');
+      for (const m of r.warnings) process.stdout.write('    ' + c.yellow('警告 ') + m + '\n');
+    }
+    for (const m of rep.route.errors) process.stdout.write(c.red('✗ 触发路由 ') + m + '\n');
+    for (const m of rep.route.warnings) process.stdout.write(c.yellow('· 触发路由 ') + m + '\n');
+    const { skills, errors, warnings } = rep.counts;
+    const verdict = errors ? c.red('未通过') : c.green('通过');
+    process.stdout.write(`${verdict} — ${skills} 个技能，${errors} 个错误，${warnings} 个警告\n`);
+    if (errors) process.exit(1);
+    return;
+  }
+
   const problem = validateAuth(config);
   if (problem) {
     process.stderr.write(problem + '\n');
@@ -433,13 +468,41 @@ async function cmdSkills(config, args, flags, cwd) {
         process.stderr.write(c.red(wanted ? `平台上没有技能：${wanted}` : '平台上没有可拉取的文档技能') + '\n');
         process.exit(1);
       }
+      let blocked = 0;
+      // 拉到本地的新技能占会员「技能插件」额度（覆盖已有的同名技能不占）：先取最新上限，装满即停
+      await refreshPlan(config);
+      let limited = '';
+      let unpulled = 0;
       for (const s of targets) {
+        const isNew = !fs.existsSync(path.join(baseDir, String(s.name || '').replace(/[^a-zA-Z0-9_-]/g, '-'), 'SKILL.md'));
+        if (limited && isNew) { unpulled++; continue; }
         const detail = await getPlatformSkill(config.baseUrl, config.apiKey, s.id);
-        const dir = writeSkillToDir(baseDir, detail);
+        // 落盘前先过安全扫描（P0-A）。这条路径直接调 writeSkillToDir、不走 installSkillPackage，
+        // 所以闸门必须在这里再挡一道——否则 CLI 就是一扇没装门的侧门。
+        const scan = scanSkillPackage({ name: s.name, content: detail?.content, files: detail?.files || [] });
+        if (scan.verdict === 'blocked' && !flags.forceUnsafe) {
+          blocked++;
+          process.stderr.write(c.red(`已拦截 ${s.name}：安全扫描发现严重风险，未落盘`) + '\n');
+          process.stderr.write(formatScanReport(scan) + '\n');
+          process.stderr.write(c.gray('逐条审阅确无问题后，可加 --force-unsafe重试。') + '\n');
+          continue;
+        }
+        let dir;
+        try {
+          dir = writeSkillToDir(baseDir, detail);
+        } catch (e) {
+          if (!isPlanLimitError(e)) throw e;
+          limited = e.message;
+          unpulled++;
+          continue;
+        }
+        const warnNote = scan.counts.warn ? c.yellow(`（安全扫描 ${scan.counts.warn} 项警告）`) : '';
         process.stdout.write(c.green('已拉取 ') + s.name
-          + c.gray(`（${detail.files?.length || 0} 附件）→ ${dir}`) + '\n');
+          + c.gray(`（${detail.files?.length || 0} 附件）→ ${dir}`) + warnNote + '\n');
       }
-      process.stdout.write(c.gray('新会话中生效（系统提示词注入技能目录，load_skill 按需载入）。') + '\n');
+      if (blocked) process.stderr.write(c.red(`共 ${blocked} 个技能因安全扫描未被拉取。`) + '\n');
+      if (limited) process.stderr.write(c.red(`${limited}（${unpulled} 个技能未拉取）`) + '\n');
+      process.stdout.write(c.gray('新会话中生效（系统提示词注入技能目录，load_skill按需载入）。') + '\n');
     } catch (e) {
       process.stderr.write(c.red('拉取失败：' + e.message) + '\n');
       process.exit(1);
@@ -460,7 +523,7 @@ async function cmdSkills(config, args, flags, cwd) {
     try {
       payload = readSkillDirForPush(dir);
     } catch (e) {
-      process.stderr.write(c.red(`读取技能失败（目录须含 SKILL.md）：${e.message}`) + '\n');
+      process.stderr.write(c.red(`读取技能失败（目录须含SKILL.md）：${e.message}`) + '\n');
       process.exit(1);
     }
     try {
@@ -468,7 +531,7 @@ async function cmdSkills(config, args, flags, cwd) {
         ...payload, conflict: flags.overwrite ? 'overwrite' : 'skip',
       });
       const label = r.status === 'imported' ? '已推送（新建）'
-        : r.status === 'overwritten' ? '已推送（覆盖同名）' : '已跳过：平台已有同名技能（--overwrite 可覆盖）';
+        : r.status === 'overwritten' ? '已推送（覆盖同名）' : '已跳过：平台已有同名技能（--overwrite可覆盖）';
       process.stdout.write((r.status === 'skipped' ? c.yellow(label) : c.green(label))
         + c.gray(` · ${payload.filename} → ${config.baseUrl}`) + '\n');
       for (const w of r.warnings || []) {
@@ -527,15 +590,16 @@ async function main() {
       process.stdout.write(c.gray('卸载命令本体：npm uninstall -g @huicai/cli') + '\n');
       return;
     }
-    process.stdout.write('将永久删除以下 HuiCai CLI 本机数据（' + info.dir + '，共 ' + fmtSize(info.total) + '）：\n');
+    process.stdout.write('将永久删除以下HuiCai CLI本机数据（' + info.dir + '，共 ' + fmtSize(info.total) + '）：\n');
     for (const e of info.entries) {
-      process.stdout.write('  - ' + e.name + (e.kind === 'dir' ? '/' : '') + c.gray('  ' + fmtSize(e.size)) + '\n');
+      process.stdout.write('  - ' + e.name + (e.kind === 'dir' ? '/' : '')
+        + c.gray('  ' + fmtSize(e.size) + (e.label ? '  ' + e.label : '')) + '\n');
     }
     process.stdout.write(c.gray('  含登录令牌、会话历史、长期记忆、技能与自定义命令等，删除不可撤销。') + '\n');
     const yes = positional.includes('--yes') || positional.includes('-y') || flags.yolo;
     if (!yes) {
       if (!process.stdin.isTTY) {
-        process.stderr.write(c.red('非交互环境：请加 --yes 确认删除。') + '\n');
+        process.stderr.write(c.red('非交互环境：请加 --yes确认删除。') + '\n');
         process.exit(1);
       }
       const ans = await new Promise((resolve) => {
@@ -548,8 +612,8 @@ async function main() {
       }
     }
     const r = purgeData();
-    process.stdout.write(c.green('✅ 已清理所有 HuiCai CLI 本机数据：' + r.dir) + '\n');
-    process.stdout.write(c.gray('卸载命令本体：npm uninstall -g @huicai/cli（其 preuninstall 钩子也会自动清理本目录）') + '\n');
+    process.stdout.write(c.green('✅ 已清理所有HuiCai CLI本机数据：' + r.dir) + '\n');
+    process.stdout.write(c.gray('卸载命令本体：npm uninstall -g @huicai/cli（其preuninstall钩子也会自动清理本目录）') + '\n');
     return;
   }
 
@@ -588,6 +652,15 @@ async function main() {
     return;
   }
 
+  if (sub === 'acp') {
+    // ACP 服务端：编辑器/自动化客户端经 JSON-RPC over stdio 长驻驱动惠彩。
+    // 与 -p 的分工：那个跑完就退出，这个在同一段上下文里连续对话。
+    // 注意 stdout 从这一刻起被协议帧独占（acp.js 启动时会把杂音改道 stderr）。
+    const { runAcpServer } = await import('../src/acp.js');
+    await runAcpServer({ config, cwd, yolo: flags.yolo });
+    return;
+  }
+
   if (sub === 'daemon') {
     // 内置调度守护：按 cron 真正运行 /schedule 登记的任务（Ctrl-C 退出）
     const { runDaemon } = await import('../src/daemon.js');
@@ -641,7 +714,7 @@ async function main() {
     if (!kbId) {
       process.stderr.write(c.red('用法：huicai kb-sync <知识库ID> [ref] [--dry]') + '\n'
         + c.gray('  例：huicai kb-sync 12            # 同步本地未提交改动到知识库 12') + '\n'
-        + c.gray('      huicai kb-sync 12 origin/main # 同步相对 origin/main 的改动（CI 常用）') + '\n');
+        + c.gray('      huicai kb-sync 12 origin/main # 同步相对origin/main的改动（CI常用）') + '\n');
       process.exit(1);
     }
     const authProblem = validateAuth(config);
@@ -660,12 +733,12 @@ async function main() {
       }
       if (r.dry) {
         for (const f of r.preview) process.stdout.write((f.deleted ? c.red('  − ') : c.green('  + ')) + f.path + '\n');
-        process.stdout.write(c.gray(`试运行：${r.added} 新增/修改，${r.removed} 删除${r.skipped ? `，跳过 ${r.skipped}` : ''}（加 --dry 之外的调用即实际同步）`) + '\n');
+        process.stdout.write(c.gray(`试运行：${r.added} 新增/修改，${r.removed} 删除${r.skipped ? `，跳过 ${r.skipped}` : ''}（加 --dry之外的调用即实际同步）`) + '\n');
         return;
       }
       process.stdout.write(c.green('✅ 知识库已保鲜：') + r.message + '\n');
     } catch (e) {
-      process.stderr.write(c.red('✗ kb-sync 失败：' + e.message) + '\n');
+      process.stderr.write(c.red('✗ kb-sync失败：' + e.message) + '\n');
       process.exit(1);
     }
     return;
@@ -694,7 +767,7 @@ async function main() {
   // --consult：混合模式——把平台伪模型作为 consult_platform 工具（本机原始驱动 + 平台编排咨询）
   if (flags.consult) {
     if (!/^(agent|workflow|datahuman|squad)-/.test(flags.consult)) {
-      process.stderr.write(c.red('--consult 需平台伪模型 id：agent-xxx / workflow-xxx / datahuman-xxx（分享码见分享窗口）') + '\n');
+      process.stderr.write(c.red('--consult需平台伪模型id：agent-xxx / workflow-xxx / datahuman-xxx（分享码见分享窗口）') + '\n');
       process.exit(1);
     }
     config.consult = flags.consult;
@@ -774,24 +847,32 @@ async function main() {
   }
 
   // 交互式：默认富 TUI（ink，需已安装依赖 + TTY）；--plain 强制普通 REPL；TUI 不可用则自动回退
+  const updater = process.stdin.isTTY && process.stdout.isTTY ? createUpdater({ current: _pkg.version }) : null;
+  const finishUpdate = (result) => {
+    updater?.dispose();
+    if (result?.updated) process.stdout.write(c.green(`已更新到 v${displayVersion(result.updated)}，请重新运行 huicai。登录、历史与配置已保留。\n`));
+  };
   // 偏好顺序：命令行 --tui/--plain > 配置 tui(rich/plain) > auto（TTY 下用 TUI）
-  const wantTui = flags.tui || config.tui === 'rich'
-    || (!flags.plain && config.tui !== 'plain' && process.stdout.isTTY && process.stdin.isTTY);
+  const wantTui = !flags.plain && process.stdout.isTTY && process.stdin.isTTY && process.env.TERM !== 'dumb'
+    && (flags.tui || config.tui !== 'plain');
   if (wantTui) {
-    let ran = null;
+    let runInk;
     try {
-      const { runInk } = await import('../src/tui/app.js');
-      ran = (await runInk({ config, cwd, session, yolo: flags.yolo, initialPrompt: prompt || null, version: VERSION })) || {};
+      ({ runInk } = await import('../src/tui/app.js'));
     } catch (e) {
-      process.stderr.write(c.gray('（未启用 TUI：' + e.message + '，回退普通模式）') + '\n');
+      process.stderr.write(c.gray('（未启用TUI：' + e.message + '，回退普通模式）') + '\n');
     }
-    // 重新登录放在 try 外：登录流程自身失败不该被误读成「TUI 不可用」而回退去开普通 REPL
-    if (ran) {
+    // Only dependency loading may fall back. A runtime failure must never replay
+    // the initial prompt after it may already have edited files or run commands.
+    if (runInk) {
+      const ran = await runInk({ config, cwd, session, yolo: flags.yolo, initialPrompt: prompt || null, version: VERSION, updater });
+      finishUpdate(ran);
       await reloginIfNeeded(ran, flags);
       return;
     }
   }
-  const r = await startRepl({ config, cwd, yolo: flags.yolo, initialPrompt: prompt || null, session, version: VERSION });
+  const r = await startRepl({ config, cwd, yolo: flags.yolo, initialPrompt: prompt || null, session, version: VERSION, updater });
+  finishUpdate(r);
   await reloginIfNeeded(r, flags);
 }
 
@@ -834,7 +915,7 @@ async function pickSession(cwd) {
 function cmdSessions(cwd, all) {
   const list = sessions.listSessions(all ? null : cwd);
   if (!list.length) {
-    process.stdout.write(all ? '暂无历史会话。\n' : '当前目录暂无历史会话（-a/--all 查看全部）。\n');
+    process.stdout.write(all ? '暂无历史会话。\n' : '当前目录暂无历史会话（-a/--all查看全部）。\n');
     return;
   }
   for (const s of list) {
@@ -843,7 +924,7 @@ function cmdSessions(cwd, all) {
     );
     if (all) process.stdout.write(c.gray(`            ${s.cwd || ''}`) + '\n');
   }
-  process.stdout.write(c.gray('\n恢复：huicai resume <id>  或  huicai -c（最近一次）\n'));
+  process.stdout.write(c.gray('\n恢复：huicai resume <id>  或huicai -c（最近一次）\n'));
 }
 
 main().catch((e) => {

package/bin/update.js

@@ -0,0 +1,97 @@
+// CLI 更新只由入口启用；IDE 内嵌核心不会自行安装全局软件。
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+const PACKAGE = '@huicai/cli';
+const stable = (v) => typeof v === 'string' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(v);
+export function newer(a, b) {
+  if (!stable(a) || !stable(b)) return false;
+  const aa = a.split('.').map(BigInt), bb = b.split('.').map(BigInt);
+  for (let i = 0; i < 3; i++) if (aa[i] !== bb[i]) return aa[i] > bb[i];
+  return false;
+}
+export function displayVersion(v) {
+  const [year, md, patch] = v.split('.').map(Number);
+  const month = Math.floor(md / 100), day = md % 100;
+  return year >= 2020 && month >= 1 && month <= 12 && day >= 1 && day <= 31
+    ? `${year}.${String(month).padStart(2, '0')}.${String(day).padStart(2, '0')}${patch ? '.' + patch : ''}` : v;
+}
+
+// 直接执行 npm 的 JS 入口，兼容 Windows，避免 cmd/shell 插值及命令注入。
+export function npmExecutable(env = process.env) {
+  const dirs = [path.dirname(process.execPath), ...(env.PATH || '').split(path.delimiter)];
+  for (const dir of dirs) {
+    for (const file of ['npm', 'node_modules/npm/bin/npm-cli.js', '../lib/node_modules/npm/bin/npm-cli.js']) {
+      try {
+        const resolved = fs.realpathSync(path.resolve(dir, file));
+        if (resolved.endsWith('npm-cli.js')) return resolved;
+      } catch { /* 继续查找同一 Node 安装或 PATH 中的 npm */ }
+    }
+  }
+  throw new Error('未找到 npm，请安装 Node.js 附带的 npm 后重试。');
+}
+
+export function createUpdater({ current, packageRoot = fileURLToPath(new URL('..', import.meta.url)), env = process.env, run = exec } = {}) {
+  const controller = new AbortController();
+  let installing;
+  let installAbort;
+  const npm = async (args, timeout = 10000, signal = controller.signal) => {
+    const result = await run(process.execPath, [npmExecutable(env), ...args], {
+      env: { ...env, HUICAI_UPDATING: '1', npm_config_update_notifier: 'false' },
+      cwd: path.dirname(process.execPath), timeout, maxBuffer: 1024 * 1024,
+      signal, windowsHide: true,
+    });
+    return result.stdout.trim();
+  };
+  const check = npm(['view', PACKAGE + '@latest', 'version', '--json', '--fetch-retries=0', '--fetch-timeout=6000'])
+    .then((raw) => JSON.parse(raw)).then((version) => newer(version, current) ? version : null)
+    .catch(() => null); // 后台检测断网、未发布或损坏响应时静默，不影响启动。
+  return {
+    check,
+    dispose: () => { controller.abort(); installAbort?.abort(); },
+    menu: (version) => ({ title: `HuiCai AI 有新版本 v${displayVersion(version)}`, current: 'later', searchable: false,
+      options: [{ value: 'update', label: '更新到最新版本', description: '自动安装；保留登录、历史与配置，完成后重新运行 huicai' },
+        { value: 'later', label: '稍后', description: '继续当前会话，下次启动时再提醒' }] }),
+    install(version, { signal } = {}) {
+      if (installing) return installing;
+      installAbort = new AbortController();
+      const abort = () => installAbort?.abort();
+      signal?.addEventListener('abort', abort, { once: true });
+      if (signal?.aborted || controller.signal.aborted) installAbort.abort();
+      const installSignal = installAbort.signal;
+      installing = (async () => {
+        if (!newer(version, current)) throw new Error('无有效的新版本，已停止安装。');
+        // npm 7+ 不执行卸载钩子；旧 npm 可能在替换包时误删 ~/.huicai。
+        const npmVersion = await npm(['--version'], 10000, installSignal);
+        if (!/^\d+\./.test(npmVersion) || Number(npmVersion.split('.')[0]) < 7) throw new Error('自动更新需要 npm 7 或更新版本，请先升级 npm。');
+        let prefix;
+        const root = fs.realpathSync(packageRoot);
+        const suffix = path.join('lib', 'node_modules', '@huicai', 'cli');
+        const windowsSuffix = path.join('node_modules', '@huicai', 'cli');
+        // 已全局安装时固定原安装位置，避免 PATH 上另一个 npm 更新到错误目录。
+        if (root.endsWith(path.sep + suffix)) prefix = root.slice(0, -suffix.length);
+        else if (process.platform === 'win32' && root.endsWith(path.sep + windowsSuffix)) prefix = root.slice(0, -windowsSuffix.length);
+        else prefix = await npm(['prefix', '--global'], 10000, installSignal);
+        await npm(['install', '--global', '--prefix', prefix, PACKAGE + '@' + version,
+          '--no-audit', '--no-fund', '--fetch-retries=1', '--fetch-timeout=30000'], 300000, installSignal);
+        const installedRoot = path.join(prefix, ...(process.platform === 'win32' ? [] : ['lib']), 'node_modules', '@huicai', 'cli');
+        const installed = JSON.parse(fs.readFileSync(path.join(installedRoot, 'package.json'), 'utf8'));
+        if (installed.version !== version) throw new Error('安装后的版本校验未通过，请重试。');
+        // 用真实的新入口确认可启动，而非仅凭 npm 的退出码报告成功。
+        await run(process.execPath, [path.join(installedRoot, 'bin', 'huicai.js'), '--version'], {
+          env, timeout: 15000, maxBuffer: 65536, windowsHide: true, signal: installSignal,
+        });
+        return version;
+      })().catch((error) => {
+        installing = null;
+        if (installSignal.aborted) throw new Error('更新已中断，可输入 /update 重试。');
+        const denied = /EACCES|EPERM/.test(String(error.stderr || error.message));
+        throw new Error(denied ? '安装目录没有写入权限，请使用可写的 npm 全局目录后重试。' : '更新未完成，请检查网络或 npm 配置后重试。' + (error.message?.startsWith('Command failed') ? '' : ` ${error.message}`));
+      }).finally(() => { signal?.removeEventListener('abort', abort); installAbort = null; });
+      return installing;
+    },
+  };
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@huicai/cli",
-  "version": "2026.814.0",
-  "versionDisplay": "2026.08.14",
-  "description": "在终端运行的智能体 CLI：以 HuiCai_AI 平台的 OpenAI 兼容 /v1 为模型后端，在用户本机执行文件/命令工具。",
+  "version": "2026.1021.0",
+  "versionDisplay": "2026.10.21",
+  "description": "在终端运行的智能体CLI：以HuiCai_AI平台的OpenAI兼容 /v1 为模型后端，在用户本机执行文件/命令工具。",
   "type": "module",
   "bin": {
     "huicai": "bin/huicai.js"
@@ -11,21 +11,32 @@
     "node": ">=18"
   },
   "files": [
+    "LICENSE",
+    "README.md",
     "bin",
-    "src",
     "skills",
     "squads",
-    "README.md",
-    "LICENSE"
+    "src",
+    "ui"
   ],
   "scripts": {
     "start": "node bin/huicai.js",
     "check": "node --check bin/huicai.js",
+    "gates": "node scripts/gates/run-gates.cjs local",
+    "gates:prepush": "node scripts/gates/run-gates.cjs pre-push",
+    "gates:ci": "node scripts/gates/run-gates.cjs ci",
+    "gen:catalogs": "node scripts/gates/gen-tool-catalog.cjs --write && node scripts/gates/gen-command-catalog.cjs --write",
     "test": "node --test --test-concurrency=1 test/*.test.mjs",
     "version:next": "node scripts/next-version.cjs",
     "pack:release": "node scripts/pack-release.cjs",
     "preuninstall": "node bin/preuninstall.cjs",
-    "prepublishOnly": "node --check bin/huicai.js"
+    "prepublishOnly": "npm run gates:ci",
+    "battery:weekly": "node scripts/weekly-battery.mjs",
+    "battery:web": "node scripts/web-battery.mjs",
+    "battery:report": "node scripts/report-battery.mjs",
+    "mutest:weekly": "node scripts/weekly-mutest.mjs",
+    "lint:skills": "node scripts/skill-lint.cjs --strict --quiet",
+    "optimize:skill": "node scripts/skill-optimize.cjs"
   },
   "keywords": [
     "cli",
@@ -51,6 +62,14 @@
   },
   "dependencies": {
     "ink": "^7.1.0",
-    "react": "^19.2.7"
+    "react": "^19.2.7",
+    "string-width": "^7.2.0",
+    "strip-ansi": "^7.2.0",
+    "wrap-ansi": "^9.0.2"
+  },
+  "optionalDependencies": {
+    "@deepseek-ai/node-addon-landlock-run": "^0.1.0",
+    "koffi": "^2.9.0",
+    "node-pty": "^1.1.0"
   }
 }