@huicai/cli 2026.710.97949 → 2026.711.0

package/bin/huicai.js

@@ -4,7 +4,7 @@
 import readline from 'node:readline';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { c } from '../src/colors.js';
+import { c, setColorMode, setAccent } from '../src/colors.js';
 import { loadConfig, saveConfig, CONFIG_PATH, DEFAULT_MODEL } from '../src/config.js';
 import { listModels, getAgentPersona, fetchUsage, listPlatformSkills, getPlatformSkill, pushPlatformSkill } from '../src/api.js';
 import { deviceLogin } from '../src/device.js';
@@ -129,6 +129,10 @@ ${c.bold('huicai')} — 终端智能体，以 HuiCai_AI 平台为模型后端，
   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 help                显示本帮助
@@ -441,6 +445,8 @@ async function main() {
   if (flags.key) config.apiKey = flags.key;
   if (flags.model) config.model = flags.model;
   if (Number.isFinite(flags.maxTurns) && flags.maxTurns > 0) config.maxTurns = flags.maxTurns;
+  setColorMode(config.theme); // /theme：无色/彩色
+  setAccent(config.accentColor); // /color：强调色
   const cwd = flags.cwd ? path.resolve(flags.cwd) : process.cwd();
 
   // 会话列表：纯本地，无需鉴权
@@ -464,6 +470,89 @@ async function main() {
     return;
   }
 
+  if (sub === 'daemon') {
+    // 内置调度守护：按 cron 真正运行 /schedule 登记的任务（Ctrl-C 退出）
+    const { runDaemon } = await import('../src/daemon.js');
+    try {
+      await runDaemon({});
+    } catch (e) {
+      process.stderr.write(c.red(e.message) + '\n');
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'watch') {
+    // 文件监听：变更即触发一个智能体任务。用法：huicai watch ["*.js"] [-p "跑测试"]
+    const { runWatch } = await import('../src/watch.js');
+    const pattern = positional[1] && !positional[1].startsWith('-') ? positional[1] : null;
+    const prompt = (flags.prompt || '').trim()
+      || '刚有文件变更。请审查这些改动是否有问题（bug/风格/遗漏），必要时跑相关测试，简要汇报；无需大改。';
+    try {
+      await runWatch({ cwd, prompt, pattern });
+    } catch (e) {
+      process.stderr.write(c.red(e.message) + '\n');
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'pr') {
+    // 自动提交并开 PR：生成规范 commit → 建分支 → push → gh 开 PR（`huicai pr commit` 仅提交不推送）
+    const authProblem = validateAuth(config);
+    if (authProblem) {
+      process.stderr.write(authProblem + '\n');
+      process.exit(1);
+    }
+    const { runPrFlow } = await import('../src/gitflow.js');
+    const commitOnly = positional[1] === 'commit';
+    const r = await runPrFlow({ cwd, config, emit: (t) => process.stdout.write(c.gray(t) + '\n'), push: !commitOnly, openPr: !commitOnly });
+    if (!r.ok) {
+      process.stderr.write(c.red('✗ ' + r.error) + '\n');
+      process.exit(1);
+    }
+    process.stdout.write(c.green('✅ ') + (r.pr ? 'PR: ' + r.pr : '分支 ' + r.branch + (r.note ? '（' + r.note + '）' : '')) + '\n');
+    return;
+  }
+
+  if (sub === 'kb-sync') {
+    // 配合 git diff 增量同步知识库：huicai kb-sync <知识库ID> [ref] [--dry]
+    //   无 ref  → 同步工作区相对 HEAD 的改动 + 未跟踪新文件
+    //   给 ref  → 同步相对该提交/分支的改动（如 origin/main、HEAD~3、abc123；适合 CI）
+    const kbId = positional[1] && !positional[1].startsWith('-') ? positional[1] : null;
+    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');
+      process.exit(1);
+    }
+    const authProblem = validateAuth(config);
+    if (authProblem) {
+      process.stderr.write(authProblem + '\n');
+      process.exit(1);
+    }
+    const base = positional[2] && !positional[2].startsWith('-') ? positional[2] : null;
+    const dry = positional.includes('--dry') || positional.includes('-n');
+    const { runKbSync } = await import('../src/kbsync.js');
+    try {
+      const r = await runKbSync({ cwd, config, kbId, base, dry, emit: (t) => process.stdout.write(c.gray(t) + '\n') });
+      if (r.empty) {
+        process.stdout.write(c.gray(r.message) + '\n');
+        return;
+      }
+      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');
+        return;
+      }
+      process.stdout.write(c.green('✅ 知识库已保鲜：') + r.message + '\n');
+    } catch (e) {
+      process.stderr.write(c.red('✗ kb-sync 失败：' + e.message) + '\n');
+      process.exit(1);
+    }
+    return;
+  }
+
   const problem = validateAuth(config);
   if (problem) {
     process.stderr.write(problem + '\n');
@@ -567,7 +656,9 @@ async function main() {
   }
 
   // 交互式：默认富 TUI（ink，需已安装依赖 + TTY）；--plain 强制普通 REPL；TUI 不可用则自动回退
-  const wantTui = flags.tui || (!flags.plain && process.stdout.isTTY && process.stdin.isTTY);
+  // 偏好顺序：命令行 --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);
   if (wantTui) {
     try {
       const { runInk } = await import('../src/tui/app.js');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@huicai/cli",
-  "version": "2026.710.97949",
-  "versionDisplay": "2026.07.10.97949",
+  "version": "2026.711.0",
+  "versionDisplay": "2026.07.11",
   "description": "在终端运行的智能体 CLI：以 HuiCai_AI 平台的 OpenAI 兼容 /v1 为模型后端，在用户本机执行文件/命令工具。",
   "type": "module",
   "bin": {

package/src/advisor.js

@@ -0,0 +1,46 @@
+// Advisor 升配（会决策）：设置了「顾问模型」（更强的模型）后，暴露 ask_advisor 工具——
+// 智能体遇到难题/复杂决策/反复卡住时，可主动向更强模型请教独立第二意见，再据此决策。
+// 仅当 config.advisorModel 非空时构造（否则返回 null，不暴露该工具）。
+
+import { streamChat } from './api.js';
+
+export function makeAdvisorTool({ config }) {
+  if (!config?.advisorModel) return null;
+  const spec = {
+    type: 'function',
+    function: {
+      name: 'ask_advisor',
+      description:
+        '遇到难题、复杂决策或反复卡住时，向一个更强的「技术顾问」模型请教独立的第二意见。'
+        + '把问题背景、已知信息、已尝试过什么、待决策点写清楚（自足），它会给出判断/方案与关键风险。'
+        + '用于真正的难点或高风险决策，不要滥用。',
+      parameters: {
+        type: 'object',
+        properties: {
+          question: { type: 'string', description: '自足的难题描述（含背景、已尝试、待决策点）' },
+        },
+        required: ['question'],
+      },
+    },
+  };
+  const run = async (args) => {
+    const q = String(args?.question || '').trim();
+    if (!q) return '缺少 question';
+    try {
+      const r = await streamChat({
+        baseUrl: config.baseUrl,
+        apiKey: config.apiKey,
+        model: config.advisorModel,
+        messages: [
+          { role: 'system', content: '你是资深技术顾问，正被一个编码智能体咨询一个难题。基于它提供的信息，给出清晰、具体、可执行的判断或方案：'
+            + '指出关键风险、推荐做法、以及为何。简洁直接，不要寒暄。' },
+          { role: 'user', content: q },
+        ],
+      });
+      return `【顾问（${config.advisorModel}）意见】\n` + ((r.content || '(顾问无回复)').trim());
+    } catch (e) {
+      return '咨询顾问失败：' + e.message;
+    }
+  };
+  return { readOnly: true, spec, run };
+}

package/src/agent.js

@@ -26,10 +26,12 @@ import { toolLabel, indent, renderFileDiff } from './render.js';
 import { compactIfNeeded, buildModelMessages } from './compaction.js';
 import { makeTodoTool, formatTodos, TODO_TOOL_NAME } from './todo.js';
 import { makeMemoryTool } from './memory.js';
+import { loadHooks, runHooks } from './hooks.js';
 import * as ide from './ide.js';
 import { c } from './colors.js';
 
-const DEFAULT_MAX_ITERS = 60;
+const DEFAULT_MAX_ITERS = 120; // 中大型项目需更多工具轮（读多文件/多次检索/多处编辑）；仍可 config.maxTurns 或 --max-turns 覆盖
+const TOOL_CONCURRENCY = 8;     // 并行只读工具的并发上限：大仓库里模型一次触发大量 grep/glob 时限并发，降争用、提稳定与总吞吐
 const MAX_TOOL_RESULT_CHARS = 20_000;
 const CAP_HEAD = 16_000;
 const CAP_TAIL = 3_000;
@@ -43,6 +45,57 @@ const MARKUP_RETRY_PROMPT =
 const MARKUP_FORCE_ANSWER_PROMPT =
   '请停止调用任何工具。基于目前已获得的全部信息，直接用中文输出面向用户的完整最终答复，'
   + '不要输出任何工具调用或协议标记。';
+// 预算收敛：临近工具轮数上限时注入，禁用工具并要求直接作答，保证中大型项目里到达上限也能给出干净的最终答复（而非被硬截断）。
+const BUDGET_FINAL_PROMPT =
+  '已接近本回合的工具调用轮数上限。请不要再调用任何工具，基于目前已获得的信息，直接用中文输出面向用户的完整最终答复。';
+// 自我纠错：短时间内多次工具失败时注入，打破「反复用同样会失败的调用」的死循环。
+const SELF_CORRECT_NOTE =
+  '你刚才连续多次工具调用失败。请停下来重新审视：是不是文件路径/内容/前提假设错了？'
+  + '先用 read_file / grep / list_files 核实现状，再换一种更可靠的方法，绝不要重复同样会失败的调用。';
+// 判断一条工具结果是否为「失败」（用于自我纠错计数）。
+function looksLikeToolFailure(result) {
+  const s = String(result);
+  return s.startsWith('工具执行失败') || s.startsWith('命令启动失败')
+    || s.includes('不是合法 JSON') || s.includes('未找到要替换的内容')
+    || s.includes('路径超出项目目录') || s.includes('是目录而非文件');
+}
+// 计划模式（/plan 开启）：每轮追加到系统提示词末尾，令模型只读调研并产出方案，写/执行由权限层拦截。
+const PLAN_MODE_NOTE =
+  '\n\n# 计划模式（当前开启）\n'
+  + '你现在处于计划模式：只能用只读工具（read_file/glob/grep/list_files/fetch_url）调研，'
+  + '不得做任何改动——write_file/edit_file/run_bash 等写或执行操作都会被拒绝，不要反复尝试。'
+  + '请先充分理解需求与现状，然后产出一份清晰、分步的实施方案：涉及哪些文件、每步改动要点、如何验证、风险点，'
+  + '用 todo_write 列出步骤，随后停下等待用户确认。用户关闭计划模式后你再执行。';
+// 沙箱模式（/sandbox 开启）：禁 shell 与联网。
+const SANDBOX_MODE_NOTE =
+  '\n\n# 沙箱模式（当前开启）\n禁止执行 shell 命令（run_bash）与联网（fetch_url），调用会被拒绝，不要反复尝试。只做本地文件读写与分析。';
+
+/** /goal 设定的目标：每轮追加到系统提示词末尾，令模型停止前自检是否达成。 */
+function goalNote(goal) {
+  return '\n\n# 当前目标（用户设定）\n' + String(goal).trim()
+    + '\n在本回合结束、停止作答前，检查该目标是否已达成：若未达成，应继续推进（补充调研/改动/验证），不要过早停止；达成后用一句话说明已达成。';
+}
+
+/** 从消息 content（字符串或多模态数组）提取纯文本，用于钩子上下文。 */
+function contentText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.filter((p) => p?.type === 'text').map((p) => p.text || '').join('\n');
+  return '';
+}
+
+/** 有序的有限并发 map：并发不超过 limit，结果按输入下标回填（与 Promise.all 相同的顺序语义，但并发受限）。 */
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+  return results;
+}
 
 /** 伪模型（平台编排）判定：agent-/workflow-/datahuman- 前缀。 */
 export function isPlatformModel(model) {
@@ -78,7 +131,7 @@ export function capToolResult(text) {
  */
 export async function runTurn({
   config, messages, permissions, cwd, ask, signal,
-  extraTools = [], depth = 0, io, events, todoState, compaction, pullQueued, maxIters,
+  extraTools = [], depth = 0, io, events, todoState, compaction, pullQueued, maxIters, fileJournal,
 }) {
   const out = (io && io.write) || ((s) => process.stdout.write(s));
   const ev = events || null; // 结构化事件（ink TUI / 扩展用）；为空则走 out() 字符串输出（普通 REPL）
@@ -91,6 +144,19 @@ export async function runTurn({
   let lastPromptTokens = 0;
   const iterMax = Number(maxIters || config.maxTurns) || DEFAULT_MAX_ITERS;
   const platformMode = isPlatformModel(config.model);
+
+  // 按任务自动选模型：非伪模型 + 配置了 strong 模型 + 本回合看起来复杂（长提示/难点关键词/计划模式）→ 升配
+  let effectiveModel = config.model;
+  if (depth === 0 && config.autoModelStrong && !platformMode) {
+    const lastUser = [...messages].reverse().find((m) => m.role === 'user');
+    const t = contentText(lastUser?.content);
+    const hard = config.planMode || t.length > 400
+      || /重构|架构|设计|复杂|排查|调试|debug|优化|性能|并发|死锁|重写|迁移|安全审查|根因/i.test(t);
+    if (hard && config.autoModelStrong !== config.model) {
+      effectiveModel = config.autoModelStrong;
+      if (config.debug) info(`[automodel] 复杂回合升配 → ${effectiveModel}`);
+    }
+  }
   const compState = compaction || {}; // 未传则本回合内独立生效（不持久化）
 
   // 顶层注入 todo_write / memory_write（平台编排模式无本机工具，均不注入）
@@ -134,9 +200,36 @@ export async function runTurn({
 
   let markupRetries = 0; // 「文本化工具调用」纠正次数（首次要求改走 tool_calls 通道，二次禁工具收敛）
   let toolsDisabled = false;
+  let toolFailures = 0; // 工具失败计数（自我纠错：累计≥3 注入一次「换策略」提示）
   let correction = null; // 待注入的纠正指令：仅随本轮请求发给模型，不进会话记录（与平台侧临时 convo 等价）
 
+  // 工具事件钩子：仅顶层原始模型加载（平台伪模型由服务端编排，无本机工具）
+  const hooks = (depth === 0 && !platformMode) ? loadHooks(cwd) : null;
+  const hooksActive = !!(hooks && hooks.all.length);
+
+  // SessionStart（会话首个用户回合触发一次）+ UserPromptSubmit 钩子：可阻断，或注入附加上下文
+  if (hooksActive) {
+    const parts = [];
+    if (messages.filter((m) => m.role === 'user').length <= 1) {
+      const ss = runHooks('SessionStart', { cwd }, hooks);
+      if (ss.injectContext) parts.push(ss.injectContext);
+      for (const o of ss.outputs) parts.push(o.stdout);
+    }
+    const lastUser = [...messages].reverse().find((m) => m.role === 'user');
+    const r = runHooks('UserPromptSubmit', { cwd, prompt: contentText(lastUser?.content) }, hooks);
+    if (r.block) {
+      info('提交被 UserPromptSubmit 钩子阻断：' + r.reason);
+      return { error: '提交被钩子阻断：' + r.reason, usage: { prompt, completion }, lastPromptTokens };
+    }
+    if (r.injectContext) parts.push(r.injectContext);
+    for (const o of r.outputs) parts.push(o.stdout);
+    if (parts.length) correction = '【钩子提供的附加上下文】\n' + parts.join('\n');
+  }
+
   for (let iter = 0; iter < iterMax; iter++) {
+    // 预算收敛：最后一轮禁用工具并提示直接作答，保证中大型项目里到达上限也能给出干净的最终答复（而非被硬截断）
+    const lastIter = iter === iterMax - 1;
+    if (lastIter && !platformMode && !toolsDisabled && !correction) correction = BUDGET_FINAL_PROMPT;
     // 非破坏式上下文压缩：仅更新 compState（摘要独立存储），messages/页面内容不动
     const compacted = await compactIfNeeded(messages, config, { state: compState, lastPromptTokens });
     if (compacted > 0) info(`已压缩上下文（${compacted} 条较早消息已摘要，页面与会话记录不受影响）`);
@@ -152,15 +245,31 @@ export async function runTurn({
       else out(t);
     };
     const modelMessages = buildModelMessages(messages, compState);
+    // 会话级临时指令（计划模式 / 目标）追加到系统提示词末尾（构造新数组，绝不改动原 messages/会话）
+    let requestMessages = modelMessages;
+    if (!platformMode && modelMessages.length && modelMessages[0]?.role === 'system') {
+      let extra = '';
+      if (config.planMode) extra += PLAN_MODE_NOTE;
+      if (config.sandbox) extra += SANDBOX_MODE_NOTE;
+      if (config.goal && String(config.goal).trim()) extra += goalNote(config.goal);
+      if (extra) {
+        requestMessages = [
+          { ...modelMessages[0], content: String(modelMessages[0].content || '') + extra },
+          ...modelMessages.slice(1),
+        ];
+      }
+    }
+    const reqStart = Date.now();
     let res;
     try {
       res = await streamChat(
         {
           baseUrl: config.baseUrl,
           apiKey: config.apiKey,
-          model: config.model,
-          messages: correction ? [...modelMessages, { role: 'user', content: correction }] : modelMessages,
-          tools: toolsDisabled ? undefined : specs,
+          model: effectiveModel,
+          messages: correction ? [...requestMessages, { role: 'user', content: correction }] : requestMessages,
+          tools: (toolsDisabled || lastIter) ? undefined : specs,
+          reasoningEffort: config.reasoningEffort, // 推理强度透传（/effort；模型不支持则忽略）
           // 对话落库审计：来源与会话号（由 config 透传；扩展侧为 vscode）
           client: config.client,
           sessionId: config.sessionId,
@@ -198,6 +307,10 @@ export async function runTurn({
       completion += res.usage.completion_tokens || 0;
       lastPromptTokens = res.usage.prompt_tokens || lastPromptTokens;
     }
+    if (config.debug) {
+      info(`[debug] 轮${iter + 1} · ${config.model} · in ${res.usage?.prompt_tokens || 0} / out ${res.usage?.completion_tokens || 0} tok`
+        + ` · ${Date.now() - reqStart}ms · ${(res.toolCalls || []).length} 工具调用`);
+    }
 
     // 全量内容按同一状态机二次清洗（与流式放行结果一致）：协议标记绝不进入会话记录与后续上下文
     const { text: cleanText, sawMarkup: sawInFull } = stripMarkup(res.content);
@@ -228,6 +341,11 @@ export async function runTurn({
         messages.push({ role: 'user', content: queued });
         continue;
       }
+      // Stop 钩子：回合结束触发（不阻断，仅采集输出，如收尾自检/通知）
+      if (hooksActive) {
+        const st = runHooks('Stop', { cwd, result: cleanText }, hooks);
+        for (const o of st.outputs) info('钩子·Stop：' + shortLine(o.stdout, 160));
+      }
       return { usage: { prompt, completion }, lastPromptTokens };
     }
 
@@ -269,7 +387,7 @@ export async function runTurn({
       if (item.argsError) return item.argsError;
       let result;
       try {
-        result = item.extra ? await item.extra.run(item.args) : await runTool(item.name, item.args, cwd);
+        result = item.extra ? await item.extra.run(item.args) : await runTool(item.name, item.args, cwd, config);
       } catch (e) {
         result = `工具执行失败：${e.message}`;
       }
@@ -280,6 +398,7 @@ export async function runTurn({
       else out(c.cyan('  ⏺ ') + toolLabel(item.name, item.args) + '\n');
     };
     const emitResult = (item, result) => {
+      if (looksLikeToolFailure(result)) toolFailures++;
       if (ev) ev.onToolResult?.(item.name, String(result));
       else out(c.gray('     ' + shortLine(result)) + '\n');
       messages.push({ role: 'tool', tool_call_id: item.tc.id, content: String(result) });
@@ -319,14 +438,13 @@ export async function runTurn({
         let j = i;
         while (j < parsed.length && parsed[j].readOnly && !parsed[j].argsError) j++;
         const batch = parsed.slice(i, j);
-        const settled = await Promise.all(
-          batch.map(async (item) => {
-            const perm = await permissions.request(item.name, item.args, cwd, true);
-            if (!perm.allow) return { item, denied: perm.reason || '未授权，未执行。' };
-            emitStart(item);
-            return { item, result: await execOne(item) };
-          }),
-        );
+        // 只读段并行执行，但并发受限（大仓库里模型可能一次触发很多 grep/glob，无限并发会抢占磁盘/CPU 反而更慢）；结果仍按原顺序回灌
+        const settled = await mapLimit(batch, TOOL_CONCURRENCY, async (item) => {
+          const perm = await permissions.request(item.name, item.args, cwd, true);
+          if (!perm.allow) return { item, denied: perm.reason || '未授权，未执行。' };
+          emitStart(item);
+          return { item, result: await execOne(item) };
+        });
         for (const s of settled) {
           if (s.denied != null) emitSkip(s.item, s.denied);
           else emitResult(s.item, s.result);
@@ -344,16 +462,51 @@ export async function runTurn({
         i++;
         continue;
       }
+      // PreToolUse 钩子：可阻断该工具（非零退出码），阻断原因回灌模型
+      if (hooksActive) {
+        const pre = runHooks('PreToolUse', { cwd, toolName: cur.name, args: cur.args }, hooks);
+        for (const o of pre.outputs) info('钩子·PreToolUse：' + shortLine(o.stdout, 120));
+        if (pre.block) {
+          emitSkip(cur, 'PreToolUse 钩子阻断：' + pre.reason);
+          i++;
+          continue;
+        }
+        if (pre.modifiedArgs) {
+          cur.args = { ...cur.args, ...pre.modifiedArgs }; // 结构化钩子改写工具参数
+          info('钩子·PreToolUse 已修改工具参数');
+        }
+      }
       emitStart(cur);
+      // 检查点文件日志：写入前记录原文与是否已存在（供 /rewind 回滚；过大文件仅标记不存原文）
       const before = isFileWrite(cur.name) && cur.args?.path
         ? readSafe(path.resolve(cwd, String(cur.args.path)))
         : null;
-      const result = await execOne(cur);
+      if (fileJournal && before != null && cur.args?.path) {
+        const existed = fs.existsSync(path.resolve(cwd, String(cur.args.path)));
+        fileJournal.push(before.length > 2 * 1024 * 1024
+          ? { path: String(cur.args.path), tooLarge: true }
+          : { path: String(cur.args.path), before, existed });
+      }
+      let result = await execOne(cur);
+      // PostToolUse 钩子：不阻断，输出附加到工具结果（模型可见，如格式化/测试结果）
+      if (hooksActive) {
+        const post = runHooks('PostToolUse', { cwd, toolName: cur.name, args: cur.args, result: String(result) }, hooks);
+        if (post.outputs.length) {
+          for (const o of post.outputs) info('钩子·PostToolUse：' + shortLine(o.stdout, 120));
+          result = String(result) + '\n\n[PostToolUse 钩子输出]\n' + post.outputs.map((o) => o.stdout).join('\n');
+        }
+      }
       emitResult(cur, result);
       if (before != null) emitFileDiff(cur, before);
       i++;
     }
 
+    // 自我纠错：本回合累计工具失败达阈值，注入一次「换策略」提示（打破反复失败的死循环）
+    if (toolFailures >= 3 && !toolsDisabled && !correction) {
+      correction = SELF_CORRECT_NOTE;
+      toolFailures = 0;
+      info('检测到连续工具失败，已提示智能体换一种更可靠的方法');
+    }
     // 工具轮之间注入用户排队消息（协议合法：tool 配对已完整），模型下一轮即可看到
     const queued = pullQueued?.();
     if (queued) messages.push({ role: 'user', content: queued });

package/src/api.js

@@ -101,6 +101,8 @@ export async function streamChat(opts, handlers = {}, signal) {
     payload.tool_choice = 'auto';
   }
   if (typeof opts.temperature === 'number') payload.temperature = opts.temperature;
+  // 推理强度：OpenAI 兼容字段 reasoning_effort（透传；模型不支持则平台/模型侧忽略）
+  if (opts.reasoningEffort && opts.reasoningEffort !== 'off') payload.reasoning_effort = opts.reasoningEffort;
   // 对话落库审计标识：来源(cli/vscode) + 会话号（平台按此归并同会话多轮，供后台审计）
   const chatHeaders = authHeaders(opts.apiKey);
   if (opts.client) chatHeaders['X-Huicai-Client'] = opts.client;
@@ -211,6 +213,37 @@ async function readStream(res, handlers, signal, stallMs) {
   return { content, toolCalls: toolCalls.filter(Boolean), finishReason, usage };
 }
 
+/** 文本向量化（POST /v1/embeddings，OpenAI 兼容）。返回向量数组（与 input 一一对应）；失败抛出。 */
+export async function embed(baseUrl, apiKey, model, input) {
+  const res = await fetch(`${baseUrl}/v1/embeddings`, {
+    method: 'POST',
+    headers: authHeaders(apiKey),
+    body: JSON.stringify({ model, input: Array.isArray(input) ? input : [input] }),
+    signal: AbortSignal.timeout(30_000),
+  });
+  if (!res.ok) throw new Error((await readError(res)).message);
+  const j = await res.json();
+  return Array.isArray(j?.data) ? j.data.map((d) => d.embedding) : null;
+}
+
+/**
+ * 知识库代码增量同步（POST /v1/knowledge/{kbId}/sync）。
+ * 把一批变更文件（新增/修改/删除）提交给平台按路径 upsert，保鲜 RAG。
+ * @param {string|number} kbId 知识库ID
+ * @param {Array<{path:string, content?:string, deleted?:boolean}>} files 变更文件
+ * @returns {Promise<{accepted:number, skipped:number, truncated:boolean, message:string}>}
+ */
+export async function syncKnowledge(baseUrl, apiKey, kbId, files) {
+  const res = await fetch(`${baseUrl}/v1/knowledge/${encodeURIComponent(kbId)}/sync`, {
+    method: 'POST',
+    headers: authHeaders(apiKey),
+    body: JSON.stringify({ files }),
+    signal: AbortSignal.timeout(120_000),
+  });
+  if (!res.ok) throw new Error((await readError(res)).message);
+  return res.json();
+}
+
 /** 列出可用模型（含平台已发布智能体伪模型 agent-/workflow-/datahuman-）。 */
 export async function listModels(baseUrl, apiKey) {
   const res = await fetch(`${baseUrl}/v1/models`, {

package/src/autofix.js

@@ -0,0 +1,90 @@
+// 自主「修到通过」闭环（/verify 深化）：跑验证命令 → 失败则让智能体定位修复 → 自动重跑，直到通过或达上限。
+// 这是自动化+智能化的核心：把「跑测试、看报错、改代码、再跑」这个人类循环交给智能体自主完成。
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const CAP = 16000;
+
+function clip(s) {
+  s = String(s);
+  return s.length > CAP ? s.slice(0, CAP) + '\n…（输出过长已截断）' : s;
+}
+
+/** 跑一条命令，返回 {code, output}（合并 stdout/stderr，截断）。超时整组击杀。 */
+export function captureCommand(cwd, command, timeout = 180000) {
+  const isWin = process.platform === 'win32';
+  return new Promise((resolve) => {
+    let out = '';
+    let killed = false;
+    const child = isWin
+      ? spawn(process.env.COMSPEC || 'cmd.exe', ['/d', '/s', '/c', command], { cwd, windowsVerbatimArguments: true })
+      : spawn(process.env.SHELL || '/bin/sh', ['-c', command], { cwd, detached: true });
+    const timer = setTimeout(() => {
+      killed = true;
+      try {
+        if (!isWin && child.pid) process.kill(-child.pid, 'SIGKILL');
+        else child.kill('SIGKILL');
+      } catch { /* ignore */ }
+    }, timeout);
+    const append = (d) => { if (out.length < CAP * 2) out += d.toString(); };
+    child.stdout.on('data', append);
+    child.stderr.on('data', append);
+    child.on('error', (e) => { clearTimeout(timer); resolve({ code: -1, output: '命令启动失败：' + e.message }); });
+    child.on('close', (code) => { clearTimeout(timer); resolve({ code: killed ? 124 : (code == null ? 1 : code), output: clip(out) || '（无输出）' }); });
+  });
+}
+
+/** 自动探测验证命令（测试/构建）。返回命令字符串或 null。 */
+export function detectVerifyCommand(cwd) {
+  const has = (f) => { try { return fs.existsSync(path.join(cwd, f)); } catch { return false; } };
+  try {
+    if (has('package.json')) {
+      const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+      if (pkg.scripts?.test && !/no test specified/i.test(pkg.scripts.test)) return 'npm test';
+      if (pkg.scripts?.build) return 'npm run build';
+    }
+  } catch { /* 坏 package.json 忽略 */ }
+  if (has('pyproject.toml') || has('pytest.ini') || has('tox.ini')) return 'pytest -q';
+  if (has('pom.xml')) return 'mvn -q test';
+  if (has('build.gradle') || has('build.gradle.kts')) return './gradlew test';
+  if (has('Cargo.toml')) return 'cargo test';
+  if (has('go.mod')) return 'go test ./...';
+  if (has('Makefile')) return 'make test';
+  return null;
+}
+
+/**
+ * 修到通过循环。
+ * @param {object} p
+ * @param {string} p.command 验证命令
+ * @param {number} [p.maxIters] 最多修复轮数（默认 5）
+ * @param {string} p.cwd
+ * @param {(prompt:string)=>Promise<{aborted?:boolean}|void>} p.runTurnOnce 跑一个智能体回合（前端提供）
+ * @param {(text:string)=>void} p.emit 进度输出
+ * @returns {Promise<{passed:boolean, iters?:number, output?:string, aborted?:boolean}>}
+ */
+export async function runVerifyLoop({ command, maxIters = 5, cwd, runTurnOnce, emit }) {
+  for (let i = 0; i < maxIters; i++) {
+    emit(`▶ 验证 ${i + 1}/${maxIters}：${command}`);
+    const { code, output } = await captureCommand(cwd, command);
+    if (code === 0) {
+      emit(`✅ 验证通过（第 ${i + 1} 轮）。`);
+      return { passed: true, iters: i + 1 };
+    }
+    emit(`✗ 未通过（退出码 ${code}）` + (i < maxIters - 1 ? '，让智能体定位修复后自动重跑…' : ''));
+    if (i === maxIters - 1) {
+      emit(`⚠ 已达上限 ${maxIters} 轮仍未通过。`);
+      return { passed: false, iters: i + 1, output };
+    }
+    const r = await runTurnOnce(
+      `自动验证：运行 \`${command}\` 失败（退出码 ${code}）。输出如下：\n\n${output}\n\n`
+      + '请定位根因并**修复代码/配置**。不要自己重跑该命令——我会自动重跑验证。本轮只做必要的修复。');
+    if (r && r.aborted) {
+      emit('已中断修复循环。');
+      return { passed: false, aborted: true, iters: i + 1 };
+    }
+  }
+  return { passed: false };
+}