@huicai/cli 2026.710.97950 → 2026.711.24616

package/LICENSE

@@ -1,21 +1,43 @@
-MIT License
-
-Copyright (c) 2026 HuiCai AI
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+HuiCai AI — 专有软件许可协议 / Proprietary Software License
+
+版权所有 © 2026 HuiCai 保留所有权利。
+Copyright © 2026 HuiCai. All rights reserved.
+
+本软件（包括 HuiCai AI 命令行工具、VS Code 扩展、JetBrains 插件及其捆绑的
+核心代码、资源与文档，下称"本软件"）为汇材及其许可方的专有财产，受著作权法
+及国际条约保护。本软件按许可授权使用，而非出售。
+
+1. 授权。在您遵守本协议的前提下，汇材授予您一项有限的、非独占的、不可转让、
+   不可再许可的权利，以目标代码形式安装并使用本软件，用于您的内部业务用途。
+
+2. 限制。除适用法律明确允许或经汇材事先书面同意外，您不得：
+   (a) 复制、分发、出售、出租、出借、再许可或以其他方式向第三方提供本软件；
+   (b) 修改、翻译、改编本软件，或基于本软件创作衍生作品；
+   (c) 反向工程、反编译、反汇编本软件，或以其他方式尝试获取其源代码或内部结构
+       （适用法律明确不可排除者除外）；
+   (d) 去除或更改本软件中的任何专有声明、标识或标记。
+
+3. 所有权。本软件的一切权利、所有权及知识产权均归汇材及其许可方所有。本协议
+   未明确授予的权利均予保留。
+
+4. 无担保。本软件按"现状"提供，不附带任何明示或默示担保。
+
+5. 责任限制。在法律允许的最大范围内，汇材不对因使用或无法使用本软件而产生的
+   任何间接、附带、特殊或后果性损害承担责任。
+
+6. 终止。若您违反本协议，本授权自动终止；届时您须停止使用并销毁本软件的全部
+   副本。
+
+如需商业授权、再分发或源代码相关事宜，请联系 1253007701@qq.com。
+
+------------------------------------------------------------------------------
+
+This software (the "Software", including the HuiCai AI CLI, the VS Code
+extension, the JetBrains plugin, and their bundled core code, resources and
+documentation) is the proprietary property of HuiCai and its licensors. It is
+licensed, not sold. Except as expressly permitted above or by applicable law,
+you may not copy, distribute, sell, rent, sublicense, modify, translate, create
+derivative works of, reverse-engineer, decompile or disassemble the Software,
+nor remove any proprietary notices. All rights not expressly granted are
+reserved. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. The
+Chinese text above governs. Contact: 1253007701@qq.com

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.97950",
-  "versionDisplay": "2026.07.10.97950",
+  "version": "2026.711.24616",
+  "versionDisplay": "2026.07.11.24616",
   "description": "在终端运行的智能体 CLI：以 HuiCai_AI 平台的 OpenAI 兼容 /v1 为模型后端，在用户本机执行文件/命令工具。",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "check": "node --check bin/huicai.js",
     "test": "node --test --test-concurrency=1 test/*.test.mjs",
     "version:next": "node scripts/next-version.cjs",
+    "pack:release": "node scripts/pack-release.cjs",
     "prepublishOnly": "node --check bin/huicai.js"
   },
   "keywords": [
@@ -34,7 +35,7 @@
     "coding-agent"
   ],
   "author": "ChenBo",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/SJHT-SDK/huicai-cli/tree/master#readme",
   "repository": {
     "type": "git",

package/src/advisor.js

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

package/src/agent.js

@@ -1,385 +1 @@
-// 客户端 Agent 循环：以平台 /v1 为模型后端，模型决定调哪个工具，工具在本机执行，结果回灌，直至无工具调用。
-// 核心机制：循环与工具都在客户端，平台只做模型推理与计费。
-//
-// 两种运行形态（按 config.model 自动判定）：
-//  - 原始模型：本机工具循环（内置文件/命令工具 + todo_write + memory_write + extraTools[MCP/子智能体]）；
-//  - 伪模型 agent-/workflow-/datahuman-：平台编排直连（不传 tools，纯流式多轮）——即智能体/数字人/工作流
-//    分享页的对话能力，CLI/扩展/REPL/TUI 全部可用。
-//
-// 关键机制：
-//  - 连续的只读工具调用并行执行（结果仍按原顺序回灌）；
-//  - 工具输出截断保头尾注入上下文；工具参数 JSON 解析失败时把错误回灌模型（而非静默空参数）；
-//  - 中断时为未执行的 tool_calls 合成占位结果（协议配对完整）；
-//  - pullQueued：用户回合中排队的消息在工具轮间隙/回合末注入；
-//  - 思考过程（reasoning）流式上抛（events.onReasoning / REPL 灰字），config.showReasoning=false 关闭；
-//  - 上下文压缩为**非破坏式**：摘要存 compaction 状态（随会话持久化），原消息/页面显示不受影响，
-//    仅发给模型时经 buildModelMessages 组装视图；
-//  - 文本化工具调用防泄漏（与平台侧同款）：模型把工具调用写成纯文本标记时（DeepSeek 系退化）
-//    过滤不显示、不进会话，并注入纠正指令重试（一次要求改走 tool_calls 通道，二次禁工具强制作答）。
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { streamChat } from './api.js';
-import { MarkupFilter, stripMarkup } from './markup-filter.js';
-import { TOOL_SPECS, READONLY_TOOLS, runTool } from './tools.js';
-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 * as ide from './ide.js';
-import { c } from './colors.js';
-
-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;
-
-// 「文本化工具调用」被拦截后的纠正指令：与平台侧 ToolCallingOrchestrator 同款两级策略。
-// 第一次：要求改走规范 tool_calls 通道重试；第二次：禁用工具、强制直接作答（保证用户拿到干净答复）。
-const MARKUP_RETRY_PROMPT =
-  '你刚才的输出把工具调用写成了文本标记，工具并未被执行，该内容也不会展示给用户。'
-  + '请重新处理：若需调用工具，必须使用规范的函数调用（tool_calls）通道发起，'
-  + '绝不要以任何文本形式书写工具调用标记；若无需工具，请直接用中文输出面向用户的最终答复。';
-const MARKUP_FORCE_ANSWER_PROMPT =
-  '请停止调用任何工具。基于目前已获得的全部信息，直接用中文输出面向用户的完整最终答复，'
-  + '不要输出任何工具调用或协议标记。';
-// 预算收敛：临近工具轮数上限时注入，禁用工具并要求直接作答，保证中大型项目里到达上限也能给出干净的最终答复（而非被硬截断）。
-const BUDGET_FINAL_PROMPT =
-  '已接近本回合的工具调用轮数上限。请不要再调用任何工具，基于目前已获得的信息，直接用中文输出面向用户的完整最终答复。';
-
-/** 有序的有限并发 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) {
-  return /^(agent|workflow|datahuman)-/.test(String(model || ''));
-}
-
-function shortLine(s, max = 200) {
-  const first = String(s).split('\n')[0];
-  return first.length > max ? first.slice(0, max) + '…' : first;
-}
-
-/** 工具输出超长时截断（保头尾），防止单条结果撑爆上下文。 */
-export function capToolResult(text) {
-  const s = String(text);
-  if (s.length <= MAX_TOOL_RESULT_CHARS) return s;
-  const omitted = s.length - CAP_HEAD - CAP_TAIL;
-  return s.slice(0, CAP_HEAD) + `\n…【工具输出过长，中间已省略 ${omitted} 字符】…\n` + s.slice(-CAP_TAIL);
-}
-
-/**
- * 跑一个用户回合：mutate messages（追加 assistant/tool 消息），流式打印正文与工具进展。
- *
- * @param {object} p
- * @param {{spec:object,run:Function,readOnly:boolean}[]} [p.extraTools] 动态外部工具（MCP / 子智能体）
- * @param {number} [p.depth] 子智能体递归深度（0=顶层；todo/memory 仅顶层提供）
- * @param {{write:(s:string)=>void}} [p.io] 输出通道（子智能体传静默通道）
- * @param {object} [p.events] 结构化事件：onDelta/onReasoning/onAssistantText/onToolStart/onToolResult/onFileDiff/onSkip/onInfo/onTodo/onMemory/onTurnEnd
- * @param {{list:any[]}} [p.todoState] 任务清单状态（调用方持有可跨轮保留）
- * @param {{upTo?:number, summary?:string}} [p.compaction] 压缩状态（随会话持久化；原消息不被修改）
- * @param {() => (string|null)} [p.pullQueued] 取一条用户排队消息（无则 null）
- * @param {number} [p.maxIters] 本回合最大工具轮数（默认 config.maxTurns 或 60）
- * @returns {Promise<{aborted?:boolean, error?:string, usage:{prompt:number,completion:number}, lastPromptTokens:number}>}
- */
-export async function runTurn({
-  config, messages, permissions, cwd, ask, signal,
-  extraTools = [], depth = 0, io, events, todoState, compaction, pullQueued, maxIters,
-}) {
-  const out = (io && io.write) || ((s) => process.stdout.write(s));
-  const ev = events || null; // 结构化事件（ink TUI / 扩展用）；为空则走 out() 字符串输出（普通 REPL）
-  const info = (t) => {
-    if (ev) ev.onInfo?.(t);
-    else out(c.gray('  · ' + t) + '\n');
-  };
-  let prompt = 0;
-  let completion = 0;
-  let lastPromptTokens = 0;
-  const iterMax = Number(maxIters || config.maxTurns) || DEFAULT_MAX_ITERS;
-  const platformMode = isPlatformModel(config.model);
-  const compState = compaction || {}; // 未传则本回合内独立生效（不持久化）
-
-  // 顶层注入 todo_write / memory_write（平台编排模式无本机工具，均不注入）
-  const dynamicTools = [...extraTools];
-  if (depth === 0 && !platformMode && !dynamicTools.some((t) => t.spec?.function?.name === TODO_TOOL_NAME)) {
-    const state = todoState || { list: [] };
-    dynamicTools.push(
-      makeTodoTool({
-        state,
-        emit: (list) => {
-          if (ev) {
-            if (ev.onTodo) ev.onTodo(list.map((t) => ({ ...t })));
-            else ev.onInfo?.('任务清单：\n' + formatTodos(list));
-          } else {
-            out(c.gray(indent(formatTodos(list), '  ')) + '\n');
-          }
-        },
-      }),
-    );
-  }
-  if (depth === 0 && !platformMode && config.memoryEnabled !== false
-    && !dynamicTools.some((t) => t.spec?.function?.name === 'memory_write')) {
-    dynamicTools.push(
-      makeMemoryTool({
-        cwd,
-        emit: (t) => {
-          if (ev) {
-            if (ev.onMemory) ev.onMemory(t);
-            else ev.onInfo?.('已记入长期记忆：' + shortLine(t, 80));
-          } else {
-            out(c.gray('  ✎ 已记入长期记忆：' + shortLine(t, 80)) + '\n');
-          }
-        },
-      }),
-    );
-  }
-
-  const extraByName = new Map();
-  for (const t of dynamicTools) extraByName.set(t.spec.function.name, t);
-  const specs = platformMode ? undefined : [...TOOL_SPECS, ...dynamicTools.map((t) => t.spec)];
-
-  let markupRetries = 0; // 「文本化工具调用」纠正次数（首次要求改走 tool_calls 通道，二次禁工具收敛）
-  let toolsDisabled = false;
-  let correction = null; // 待注入的纠正指令：仅随本轮请求发给模型，不进会话记录（与平台侧临时 convo 等价）
-
-  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} 条较早消息已摘要，页面与会话记录不受影响）`);
-
-    let streamedAny = false;
-    let streamedReason = false;
-    const mf = new MarkupFilter(); // 文本化工具标记防泄漏：每轮模型输出独立实例
-    const emitDelta = (t) => {
-      if (!t) return;
-      if (!streamedAny && streamedReason && !ev) out('\n'); // 思考→正文换行
-      streamedAny = true;
-      if (ev) ev.onDelta?.(t);
-      else out(t);
-    };
-    const modelMessages = buildModelMessages(messages, compState);
-    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 || lastIter) ? undefined : specs,
-          // 对话落库审计：来源与会话号（由 config 透传；扩展侧为 vscode）
-          client: config.client,
-          sessionId: config.sessionId,
-        },
-        {
-          onContent: (t) => emitDelta(mf.feed(t)),
-          onReasoning: (t) => {
-            if (config.showReasoning === false) return;
-            if (ev) {
-              ev.onReasoning?.(t);
-            } else {
-              if (!streamedReason) out(c.gray('\n[思考] '));
-              out(c.gray(t));
-            }
-            streamedReason = true;
-          },
-          onRetry: (n, waitMs, reason) => info(`模型响应异常，${Math.round(waitMs / 1000)}s 后自动重试（第 ${n} 次）：${reason}`),
-        },
-        signal,
-      );
-    } catch (e) {
-      if (e.name === 'AbortError') {
-        if (ev) ev.onInfo?.('已中断');
-        else out(c.gray('\n[已中断]\n'));
-        return { aborted: true, usage: { prompt, completion }, lastPromptTokens };
-      }
-      if (ev) ev.onInfo?.('✗ 模型调用失败：' + e.message);
-      else out('\n' + c.red('✗ 模型调用失败：') + e.message + '\n');
-      return { error: e.message, usage: { prompt, completion }, lastPromptTokens };
-    }
-    emitDelta(mf.flush()); // 放行轮末仍持有的未确认内容（吞噬中则丢弃）
-
-    if (res.usage) {
-      prompt += res.usage.prompt_tokens || 0;
-      completion += res.usage.completion_tokens || 0;
-      lastPromptTokens = res.usage.prompt_tokens || lastPromptTokens;
-    }
-
-    // 全量内容按同一状态机二次清洗（与流式放行结果一致）：协议标记绝不进入会话记录与后续上下文
-    const { text: cleanText, sawMarkup: sawInFull } = stripMarkup(res.content);
-    const markupRound = sawInFull || mf.sawMarkup;
-    correction = null; // 上一轮注入的纠正指令已被消费
-
-    const toolCalls = platformMode ? [] : res.toolCalls;
-    if (!toolCalls.length) {
-      // 「文本化工具调用」拦截后的纠正：本轮"正文"实为协议标记（已被过滤，未显示，工具也未执行）。
-      // 平台编排模式（伪模型）由服务端过滤与纠正，客户端不再重试。
-      if (markupRound && !cleanText.trim() && !platformMode) {
-        if (markupRetries < 2) {
-          markupRetries++;
-          if (markupRetries === 2) toolsDisabled = true;
-          correction = markupRetries === 1 ? MARKUP_RETRY_PROMPT : MARKUP_FORCE_ANSWER_PROMPT;
-          info(`已拦截模型的文本化工具调用标记（工具未被执行），纠正重试中（第 ${markupRetries} 次）`);
-          continue;
-        }
-        info('模型持续输出无效的工具调用标记，已全部拦截；本轮无有效答复（可换个说法重试或更换模型）');
-      }
-      if (streamedAny && !ev) out('\n');
-      // 记录最终答复进上下文，使后续用户回合能看到助手上一次回复（多轮对话记忆）
-      if (cleanText) messages.push({ role: 'assistant', content: cleanText });
-      if (ev) ev.onTurnEnd?.(cleanText);
-      // 用户在回合中排队了新消息 → 直接续跑，无需重新发起回合
-      const queued = pullQueued?.();
-      if (queued) {
-        messages.push({ role: 'user', content: queued });
-        continue;
-      }
-      return { usage: { prompt, completion }, lastPromptTokens };
-    }
-
-    if (streamedAny && !ev) out('\n');
-    if (ev && cleanText) ev.onAssistantText?.(cleanText); // 工具轮前的正文先落定
-    messages.push({ role: 'assistant', content: cleanText, tool_calls: toolCalls });
-
-    // 预解析全部调用（名称/参数/只读性）；参数 JSON 解析失败记录错误（回灌模型重试，而非静默空参数）
-    const parsed = toolCalls.map((tc, idx) => {
-      const name = tc.function?.name || '';
-      let args = {};
-      let argsError = null;
-      const raw = tc.function?.arguments || '';
-      if (raw) {
-        try {
-          args = JSON.parse(raw);
-        } catch (e) {
-          argsError = `工具参数不是合法 JSON（${e.message}）：${String(raw).slice(0, 200)}…请修正参数后重新调用。`;
-        }
-      }
-      const extra = extraByName.get(name);
-      // IDE 集成下，write_file/edit_file 的批准发生在编辑器的内联 diff 审阅里，跳过 CLI 自身的 y/n（避免双重确认）
-      const deferToIde = ide.isActive() && (name === 'write_file' || name === 'edit_file');
-      const readOnly = extra ? !!extra.readOnly : READONLY_TOOLS.has(name);
-      return { tc, idx, name, args, argsError, extra, readOnly, deferToIde };
-    });
-
-    // 中断时为剩余未执行的 tool_calls 合成占位结果，保证 assistant.tool_calls 配对完整（协议要求）
-    const abortRest = (from) => {
-      for (let k = from; k < parsed.length; k++) {
-        messages.push({ role: 'tool', tool_call_id: parsed[k].tc.id || `call_${k}`, content: '（用户中断，该工具未执行）' });
-      }
-      if (ev) ev.onInfo?.('已中断');
-      else out(c.gray('\n[已中断]\n'));
-      return { aborted: true, usage: { prompt, completion }, lastPromptTokens };
-    };
-
-    const execOne = async (item) => {
-      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);
-      } catch (e) {
-        result = `工具执行失败：${e.message}`;
-      }
-      return capToolResult(String(result));
-    };
-    const emitStart = (item) => {
-      if (ev) ev.onToolStart?.(item.name, item.args);
-      else out(c.cyan('  ⏺ ') + toolLabel(item.name, item.args) + '\n');
-    };
-    const emitResult = (item, result) => {
-      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) });
-    };
-    const emitSkip = (item, reason) => {
-      if (ev) ev.onSkip?.(item.name, item.args);
-      else out(c.gray(`  ⊘ ${toolLabel(item.name, item.args)} — 已跳过\n`));
-      messages.push({ role: 'tool', tool_call_id: item.tc.id, content: reason || '未授权，未执行。' });
-    };
-    // 写文件类工具（edit_file/write_file）成功后向 UI 展示「更改的行」（display-only，不进模型上下文）。
-    // 以「执行前后文件内容对比」判定：未改动/失败/被拒 → before==after → 空 diff，天然不显示。
-    const isFileWrite = (name) => name === 'edit_file' || name === 'write_file';
-    const readSafe = (abs) => { try { return fs.readFileSync(abs, 'utf8'); } catch { return ''; } };
-    const emitFileDiff = (item, before) => {
-      const abs = path.resolve(cwd, String(item.args.path));
-      const diff = renderFileDiff(before, readSafe(abs), { path: String(item.args.path) });
-      if (!diff) return;
-      if (ev) ev.onFileDiff?.(diff);
-      else out(diff + '\n');
-    };
-
-    let i = 0;
-    while (i < parsed.length) {
-      if (signal?.aborted) return abortRest(i);
-      const cur = parsed[i];
-
-      // 参数损坏：不请求授权、不执行，直接把解析错误回灌（模型可修正后重试）
-      if (cur.argsError) {
-        emitStart(cur);
-        emitResult(cur, cur.argsError);
-        i++;
-        continue;
-      }
-
-      if (cur.readOnly) {
-        // 连续只读段：并行执行（权限对只读即时放行），结果按原顺序回灌
-        let j = i;
-        while (j < parsed.length && parsed[j].readOnly && !parsed[j].argsError) j++;
-        const batch = parsed.slice(i, j);
-        // 只读段并行执行，但并发受限（大仓库里模型可能一次触发很多 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);
-        }
-        i = j;
-        if (signal?.aborted) return abortRest(i);
-        continue;
-      }
-
-      // 写/执行类：顺序执行，逐个审批
-      const perm = await permissions.request(cur.name, cur.args, cwd, cur.readOnly || cur.deferToIde);
-      if (signal?.aborted) return abortRest(i);
-      if (!perm.allow) {
-        emitSkip(cur, perm.reason);
-        i++;
-        continue;
-      }
-      emitStart(cur);
-      const before = isFileWrite(cur.name) && cur.args?.path
-        ? readSafe(path.resolve(cwd, String(cur.args.path)))
-        : null;
-      const result = await execOne(cur);
-      emitResult(cur, result);
-      if (before != null) emitFileDiff(cur, before);
-      i++;
-    }
-
-    // 工具轮之间注入用户排队消息（协议合法：tool 配对已完整），模型下一轮即可看到
-    const queued = pullQueued?.();
-    if (queued) messages.push({ role: 'user', content: queued });
-  }
-
-  if (ev) ev.onInfo?.('已达最大工具轮数，停止');
-  else out(c.yellow('\n[已达最大工具轮数，停止]\n'));
-  return { usage: { prompt, completion }, lastPromptTokens };
-}
+import t from"node:fs";import o from"node:path";import{streamChat as e}from"./api.js";import{MarkupFilter as n,stripMarkup as r}from"./markup-filter.js";import{TOOL_SPECS as s,READONLY_TOOLS as a,runTool as l}from"./tools.js";import{toolLabel as i,indent as c,renderFileDiff as u}from"./render.js";import{compactIfNeeded as m,buildModelMessages as g}from"./compaction.js";import{makeTodoTool as p,formatTodos as f,TODO_TOOL_NAME as d}from"./todo.js";import{makeMemoryTool as h}from"./memory.js";import{loadHooks as y,runHooks as w}from"./hooks.js";import*as S from"./ide.js";import{c as _}from"./colors.js";function T(t){const o=String(t);return o.startsWith("工具执行失败")||o.startsWith("命令启动失败")||o.includes("不是合法 JSON")||o.includes("未找到要替换的内容")||o.includes("路径超出项目目录")||o.includes("是目录而非文件")}function b(t){return"\n\n# 当前目标（用户设定）\n"+String(t).trim()+"\n在本回合结束、停止作答前，检查该目标是否已达成：若未达成，应继续推进（补充调研/改动/验证），不要过早停止；达成后用一句话说明已达成。"}function k(t){return"string"==typeof t?t:Array.isArray(t)?t.filter(t=>"text"===t?.type).map(t=>t.text||"").join("\n"):""}async function x(t,o,e){const n=new Array(t.length);let r=0;return await Promise.all(Array.from({length:Math.max(1,Math.min(o,t.length))},async()=>{for(;r<t.length;){const o=r++;n[o]=await e(t[o],o)}})),n}export function isPlatformModel(t){return/^(agent|workflow|datahuman)-/.test(String(t||""))}function P(t,o=200){const e=String(t).split("\n")[0];return e.length>o?e.slice(0,o)+"…":e}export function capToolResult(t){const o=String(t);if(o.length<=2e4)return o;const e=o.length-16e3-3e3;return o.slice(0,16e3)+`\n…【工具输出过长，中间已省略 ${e} 字符】…\n`+o.slice(-3e3)}export async function runTurn({config:$,messages:j,permissions:M,cwd:I,ask:E,signal:U,extraTools:v=[],depth:A=0,io:O,events:C,todoState:R,compaction:N,pullQueued:D,maxIters:J,fileJournal:q}){const F=O&&O.write||(t=>process.stdout.write(t)),K=C||null,W=t=>{K?K.onInfo?.(t):F(_.gray("  · "+t)+"\n")};let L=0,Q=0,z=0;const B=Number(J||$.maxTurns)||120,G=isPlatformModel($.model);let H=$.model;if(0===A&&$.autoModelStrong&&!G){const t=[...j].reverse().find(t=>"user"===t.role),o=k(t?.content);($.planMode||o.length>400||/重构|架构|设计|复杂|排查|调试|debug|优化|性能|并发|死锁|重写|迁移|安全审查|根因/i.test(o))&&$.autoModelStrong!==$.model&&(H=$.autoModelStrong,$.debug&&W(`[automodel] 复杂回合升配 → ${H}`))}const V=N||{},X=[...v];if(0===A&&!G&&!X.some(t=>t.spec?.function?.name===d)){const t=R||{list:[]};X.push(p({state:t,emit:t=>{K?K.onTodo?K.onTodo(t.map(t=>({...t}))):K.onInfo?.("任务清单：\n"+f(t)):F(_.gray(c(f(t),"  "))+"\n")}}))}0!==A||G||!1===$.memoryEnabled||X.some(t=>"memory_write"===t.spec?.function?.name)||X.push(h({cwd:I,emit:t=>{K?K.onMemory?K.onMemory(t):K.onInfo?.("已记入长期记忆："+P(t,80)):F(_.gray("  ✎ 已记入长期记忆："+P(t,80))+"\n")}}));const Y=new Map;for(const t of X)Y.set(t.spec.function.name,t);const Z=G?void 0:[...s,...X.map(t=>t.spec)];let tt=0,ot=!1,et=0,nt=null;const rt=0!==A||G?null:y(I),st=!(!rt||!rt.all.length);if(st){const t=[];if(j.filter(t=>"user"===t.role).length<=1){const o=w("SessionStart",{cwd:I},rt);o.injectContext&&t.push(o.injectContext);for(const e of o.outputs)t.push(e.stdout)}const o=[...j].reverse().find(t=>"user"===t.role),e=w("UserPromptSubmit",{cwd:I,prompt:k(o?.content)},rt);if(e.block)return W("提交被 UserPromptSubmit 钩子阻断："+e.reason),{error:"提交被钩子阻断："+e.reason,usage:{prompt:L,completion:Q},lastPromptTokens:z};e.injectContext&&t.push(e.injectContext);for(const o of e.outputs)t.push(o.stdout);t.length&&(nt="【钩子提供的附加上下文】\n"+t.join("\n"))}for(let s=0;s<B;s++){const c=s===B-1;!c||G||ot||nt||(nt="已接近本回合的工具调用轮数上限。请不要再调用任何工具，基于目前已获得的信息，直接用中文输出面向用户的完整最终答复。");const p=await m(j,$,{state:V,lastPromptTokens:z});p>0&&W(`已压缩上下文（${p} 条较早消息已摘要，页面与会话记录不受影响）`);let f=!1,d=!1;const h=new n,y=t=>{t&&(f||!d||K||F("\n"),f=!0,K?K.onDelta?.(t):F(t))},k=g(j,V);let E=k;if(!G&&k.length&&"system"===k[0]?.role){let t="";$.planMode&&(t+="\n\n# 计划模式（当前开启）\n你现在处于计划模式：只能用只读工具（read_file/glob/grep/list_files/fetch_url）调研，不得做任何改动——write_file/edit_file/run_bash 等写或执行操作都会被拒绝，不要反复尝试。请先充分理解需求与现状，然后产出一份清晰、分步的实施方案：涉及哪些文件、每步改动要点、如何验证、风险点，用 todo_write 列出步骤，随后停下等待用户确认。用户关闭计划模式后你再执行。"),$.sandbox&&(t+="\n\n# 沙箱模式（当前开启）\n禁止执行 shell 命令（run_bash）与联网（fetch_url），调用会被拒绝，不要反复尝试。只做本地文件读写与分析。"),$.goal&&String($.goal).trim()&&(t+=b($.goal)),t&&(E=[{...k[0],content:String(k[0].content||"")+t},...k.slice(1)])}const v=Date.now();let A;try{A=await e({baseUrl:$.baseUrl,apiKey:$.apiKey,model:H,messages:nt?[...E,{role:"user",content:nt}]:E,tools:ot||c?void 0:Z,reasoningEffort:$.reasoningEffort,client:$.client,sessionId:$.sessionId},{onContent:t=>y(h.feed(t)),onReasoning:t=>{!1!==$.showReasoning&&(K?K.onReasoning?.(t):(d||F(_.gray("\n[思考] ")),F(_.gray(t))),d=!0)},onRetry:(t,o,e)=>W(`模型响应异常，${Math.round(o/1e3)}s 后自动重试（第 ${t} 次）：${e}`)},U)}catch(t){return"AbortError"===t.name?(K?K.onInfo?.("已中断"):F(_.gray("\n[已中断]\n")),{aborted:!0,usage:{prompt:L,completion:Q},lastPromptTokens:z}):(K?K.onInfo?.("✗ 模型调用失败："+t.message):F("\n"+_.red("✗ 模型调用失败：")+t.message+"\n"),{error:t.message,usage:{prompt:L,completion:Q},lastPromptTokens:z})}y(h.flush()),A.usage&&(L+=A.usage.prompt_tokens||0,Q+=A.usage.completion_tokens||0,z=A.usage.prompt_tokens||z),$.debug&&W(`[debug] 轮${s+1} · ${$.model} · in ${A.usage?.prompt_tokens||0} / out ${A.usage?.completion_tokens||0} tok · ${Date.now()-v}ms · ${(A.toolCalls||[]).length} 工具调用`);const{text:O,sawMarkup:C}=r(A.content),R=C||h.sawMarkup;nt=null;const N=G?[]:A.toolCalls;if(!N.length){if(R&&!O.trim()&&!G){if(tt<2){tt++,2===tt&&(ot=!0),nt=1===tt?"你刚才的输出把工具调用写成了文本标记，工具并未被执行，该内容也不会展示给用户。请重新处理：若需调用工具，必须使用规范的函数调用（tool_calls）通道发起，绝不要以任何文本形式书写工具调用标记；若无需工具，请直接用中文输出面向用户的最终答复。":"请停止调用任何工具。基于目前已获得的全部信息，直接用中文输出面向用户的完整最终答复，不要输出任何工具调用或协议标记。",W(`已拦截模型的文本化工具调用标记（工具未被执行），纠正重试中（第 ${tt} 次）`);continue}W("模型持续输出无效的工具调用标记，已全部拦截；本轮无有效答复（可换个说法重试或更换模型）")}f&&!K&&F("\n"),O&&j.push({role:"assistant",content:O}),K&&K.onTurnEnd?.(O);const t=D?.();if(t){j.push({role:"user",content:t});continue}if(st){const t=w("Stop",{cwd:I,result:O},rt);for(const o of t.outputs)W("钩子·Stop："+P(o.stdout,160))}return{usage:{prompt:L,completion:Q},lastPromptTokens:z}}f&&!K&&F("\n"),K&&O&&K.onAssistantText?.(O),j.push({role:"assistant",content:O,tool_calls:N});const J=N.map((t,o)=>{const e=t.function?.name||"";let n={},r=null;const s=t.function?.arguments||"";if(s)try{n=JSON.parse(s)}catch(t){r=`工具参数不是合法 JSON（${t.message}）：${String(s).slice(0,200)}…请修正参数后重新调用。`}const l=Y.get(e),i=S.isActive()&&("write_file"===e||"edit_file"===e);return{tc:t,idx:o,name:e,args:n,argsError:r,extra:l,readOnly:l?!!l.readOnly:a.has(e),deferToIde:i}}),X=t=>{for(let o=t;o<J.length;o++)j.push({role:"tool",tool_call_id:J[o].tc.id||`call_${o}`,content:"（用户中断，该工具未执行）"});return K?K.onInfo?.("已中断"):F(_.gray("\n[已中断]\n")),{aborted:!0,usage:{prompt:L,completion:Q},lastPromptTokens:z}},at=async t=>{if(t.argsError)return t.argsError;let o;try{o=t.extra?await t.extra.run(t.args):await l(t.name,t.args,I,$)}catch(t){o=`工具执行失败：${t.message}`}return capToolResult(String(o))},lt=t=>{K?K.onToolStart?.(t.name,t.args):F(_.cyan("  ⏺ ")+i(t.name,t.args)+"\n")},it=(t,o)=>{T(o)&&et++,K?K.onToolResult?.(t.name,String(o)):F(_.gray("     "+P(o))+"\n"),j.push({role:"tool",tool_call_id:t.tc.id,content:String(o)})},ct=(t,o)=>{K?K.onSkip?.(t.name,t.args):F(_.gray(`  ⊘ ${i(t.name,t.args)} — 已跳过\n`)),j.push({role:"tool",tool_call_id:t.tc.id,content:o||"未授权，未执行。"})},ut=t=>"edit_file"===t||"write_file"===t,mt=o=>{try{return t.readFileSync(o,"utf8")}catch{return""}},gt=(t,e)=>{const n=o.resolve(I,String(t.args.path)),r=u(e,mt(n),{path:String(t.args.path)});r&&(K?K.onFileDiff?.(r):F(r+"\n"))};let pt=0;for(;pt<J.length;){if(U?.aborted)return X(pt);const e=J[pt];if(e.argsError){lt(e),it(e,e.argsError),pt++;continue}if(e.readOnly){let t=pt;for(;t<J.length&&J[t].readOnly&&!J[t].argsError;)t++;const o=J.slice(pt,t),e=await x(o,8,async t=>{const o=await M.request(t.name,t.args,I,!0);return o.allow?(lt(t),{item:t,result:await at(t)}):{item:t,denied:o.reason||"未授权，未执行。"}});for(const t of e)null!=t.denied?ct(t.item,t.denied):it(t.item,t.result);if(pt=t,U?.aborted)return X(pt);continue}const n=await M.request(e.name,e.args,I,e.readOnly||e.deferToIde);if(U?.aborted)return X(pt);if(!n.allow){ct(e,n.reason),pt++;continue}if(st){const t=w("PreToolUse",{cwd:I,toolName:e.name,args:e.args},rt);for(const o of t.outputs)W("钩子·PreToolUse："+P(o.stdout,120));if(t.block){ct(e,"PreToolUse 钩子阻断："+t.reason),pt++;continue}t.modifiedArgs&&(e.args={...e.args,...t.modifiedArgs},W("钩子·PreToolUse 已修改工具参数"))}lt(e);const r=ut(e.name)&&e.args?.path?mt(o.resolve(I,String(e.args.path))):null;if(q&&null!=r&&e.args?.path){const n=t.existsSync(o.resolve(I,String(e.args.path)));q.push(r.length>2097152?{path:String(e.args.path),tooLarge:!0}:{path:String(e.args.path),before:r,existed:n})}let s=await at(e);if(st){const t=w("PostToolUse",{cwd:I,toolName:e.name,args:e.args,result:String(s)},rt);if(t.outputs.length){for(const o of t.outputs)W("钩子·PostToolUse："+P(o.stdout,120));s=String(s)+"\n\n[PostToolUse 钩子输出]\n"+t.outputs.map(t=>t.stdout).join("\n")}}it(e,s),null!=r&&gt(e,r),pt++}et>=3&&!ot&&!nt&&(nt="你刚才连续多次工具调用失败。请停下来重新审视：是不是文件路径/内容/前提假设错了？先用 read_file / grep / list_files 核实现状，再换一种更可靠的方法，绝不要重复同样会失败的调用。",et=0,W("检测到连续工具失败，已提示智能体换一种更可靠的方法"));const ft=D?.();ft&&j.push({role:"user",content:ft})}return K?K.onInfo?.("已达最大工具轮数，停止"):F(_.yellow("\n[已达最大工具轮数，停止]\n")),{usage:{prompt:L,completion:Q},lastPromptTokens:z}}