@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/agents/process-runner.js

@@ -30,7 +30,15 @@ export function spawnBackground(raw, cwd = process.cwd()) {
     const shell = process.platform === 'win32' ? 'cmd' : '/bin/sh';
     const shellArgs = process.platform === 'win32' ? ['/c', raw] : ['-c', raw];
     try {
-        const proc = spawn(shell, shellArgs, { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }, windowsHide: true });
+        const proc = spawn(shell, shellArgs, {
+            cwd,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            windowsHide: true,
+            // 2026-10-13 (leo: 「有没有错误回收机制」): detached:true = 每条命令独立进程组,
+            //   killSession 才能按组杀 (负 pid) 回收整棵进程树, 不留 shell 的孤儿子进程。
+            //   副作用 (进程随父退出不自动回收) 由既有落盘恢复机制兜底 (persistSessions/restoreSessions)。
+            detached: process.platform !== 'win32',
+        });
         session.proc = proc;
         session.pid = proc.pid;
         persistSessions();
@@ -59,8 +67,11 @@ export function pollSession(id) {
         },
     };
 }
-/** 等待后台进程结束 (最多 timeoutMs). 返回最终状态. */
-export async function waitSession(id, timeoutMs = 30000) {
+/** 等待后台进程结束 (最多 timeoutMs). 返回最终状态.
+ *  2026-10-13 (leo: 「有没有错误回收机制, 超时回收机制?」): 超时后**回收** —— 默认 kill 挂起进程
+ *  (wait 语义 = "等它跑完取结果", 超时说明它不会在预算内跑完, 留着占资源没意义);
+ *  不想杀传 killOnTimeout=false (纯等待/轮询场景). */
+export async function waitSession(id, timeoutMs = 30000, killOnTimeout = true) {
     const s = sessions.get(id);
     if (!s)
         return { ok: false, error: `未知 session ${id}` };
@@ -71,9 +82,13 @@ export async function waitSession(id, timeoutMs = 30000) {
     while (Date.now() < deadline && s.status === 'running') {
         await new Promise((r) => setTimeout(r, 250));
     }
+    const timedOut = s.status === 'running';
+    if (timedOut && killOnTimeout) {
+        killSession(id); // 超时回收: 终止挂起进程, 不占资源
+    }
     return {
-        ok: s.status !== 'running',
-        session: { id: s.id, status: s.status, exitCode: s.exitCode, output: s.output.slice(-4000), timedOut: s.status === 'running' },
+        ok: !timedOut,
+        session: { id: s.id, status: s.status, exitCode: s.exitCode, output: s.output.slice(-4000), timedOut },
     };
 }
 /** 杀死后台进程. 返回是否已终止. */
@@ -85,10 +100,14 @@ export function killSession(id) {
         return { ok: true, reason: `进程已 ${s.status}` };
     }
     try {
-        if (process.platform === 'win32')
-            s.proc.kill('SIGTERM');
-        else
-            s.proc.kill('SIGTERM');
+        // 2026-10-13 (leo: 「有没有错误回收机制」): kill 只杀 shell 不杀子进程 = 进程树泄漏;
+        //   spawn 时 detached:true 让每条命令独立进程组 ⇒ 这里 kill 整个进程组 (负 pid = 组信号)。
+        //   spawnBackground 已带 detached:true (见该函数)。
+        try {
+            process.kill(-(s.proc.pid), 'SIGTERM');
+        }
+        catch { /* 组信号可能 EPERM (非组长) */ }
+        s.proc.kill('SIGTERM');
         s.status = 'killed';
         return { ok: true };
     }

package/dist/agents/react-loop.js

@@ -8,13 +8,12 @@
  * 决策表 (apply 到 LLM 回复 + 当前 state):
  *   1. reply 是 AI failure sentinel        → continue (push error 进 history, 让 LLM 反思)
  *   2. reply 可 parse 出 tool call         → execute-tool (调 tool, push result 进 history)
- *   3. reply 含 <final gen> 且无 tool_call → final (LLM 显式终止)
- *   4. reply 无 <final gen>, 无 tool_call  → continue (LLM 可能再想想, 让下一轮重新生成)
+ *   3. reply 有 tool_call → execute-tool (工具优先)
  *
  * 这个模块不调 LLM, 只接受 reply/state 返回下一步决策. LLM 调用 + 真正状态变更
  *   仍由 PiAgentSession 协调. 这样 claude code 可以独立 unit-test 决策边界.
  */
-import { parseToolCall, isFinalResponse } from './parse-tool-call.js';
+import { parseToolCall } from './parse-tool-call.js';
 /** 把 LLM 回复归到一种 next action — 纯函数. */
 export function decideNext(ctx) {
     if (ctx.signalAborted) {
@@ -42,12 +41,10 @@ export function decideNext(ctx) {
             reason: 'parse-tool-call',
         };
     }
-    // final gen 终止
-    if (isFinalResponse(ctx.reply)) {
-        return { kind: 'final', answer: ctx.reply, reason: 'final-gen-marker' };
-    }
-    // 默认 — 普通 text, 让 LLM 继续想
-    return { kind: 'continue', reason: 'no-tool-no-final' };
+    // 2026-10-12 (leo 拍板: 全项目去掉 <final gen> 截止符): 旧实现这里用
+    //   isFinalResponse (找 `<final gen>` 标记) 判结束 — 已移除。
+    //   无工具调用 = 正常 text, 让 LLM 继续想 (由外层质量/无进展门收尾)。
+    return { kind: 'continue', reason: 'no-tool' };
 }
 /**
  * isAiFailureSentinel — 检测 LLM 上游失败哨兵.
@@ -62,14 +59,9 @@ export function isAiFailureSentinel(reply) {
         trimmed.startsWith('[AI 调用失败]') ||
         trimmed.startsWith('[错误:');
 }
-/** extractFinalText — 抽 LLM 输出里能呈现给用户的最终文字 (已是 Message 状态). */
-export function extractFinalText(reply, marker = '<final gen>') {
-    const idx = reply.indexOf(marker);
-    if (idx !== -1) {
-        const after = reply.substring(idx + marker.length).trim();
-        return after || reply.substring(0, idx).trim();
-    }
-    return reply;
+/** extractFinalText — 抽 LLM 输出里能呈现给用户的最终文字. (2026-10-12: 不再按 <final gen> 切) */
+export function extractFinalText(reply) {
+    return reply.trim();
 }
 /**
  * 错误累计判定 — 当 totalErrors 达阈值时, 给 final 答案 + 汇总.

package/dist/agents/runner-resolver.js

@@ -44,20 +44,21 @@ function classify(err, stage) {
 /** 读本机 LLM 配置摘要 (只看结构与有无, 不打印任何密钥) */
 export async function probeLlmConfig(home = os.homedir()) {
     try {
-        const raw = JSON.parse(await fsp.readFile(path.join(home, '.bolloon', 'llm-config.json'), 'utf8'));
+        // 2026-10-06 技术债清理: 只读 canonical bolloon-config.json (旧 llm-config.json 已废弃, 迁移逻辑在 config-store)
+        const raw = JSON.parse(await fsp.readFile(path.join(home, '.bolloon', 'bolloon-config.json'), 'utf8'));
         const active = raw.activeProvider || raw.provider;
         const providers = raw.providers || {};
         const p = providers[active] || {};
         const needsKey = p.requiresApiKey !== false;
         const hasKey = !!(p.apiKey || p.api_key || process.env[`${String(active).toUpperCase()}_API_KEY`]);
         if (!active)
-            return { ok: false, reason: 'llm-config.json 没有 activeProvider' };
+            return { ok: false, reason: 'bolloon-config.json 没有 activeProvider' };
         if (needsKey && !hasKey)
             return { ok: false, provider: active, model: p.model, hasKey: false, reason: `provider ${active} 需要 apiKey 但没配` };
         return { ok: true, provider: active, model: p.model, hasKey };
     }
     catch (err) {
-        return { ok: false, reason: `llm-config.json 不可读: ${String(err?.message || err).slice(0, 100)}` };
+        return { ok: false, reason: `bolloon-config.json 不可读: ${String(err?.message || err).slice(0, 100)}` };
     }
 }
 async function stage(stages, name, required, timeoutMs, fn, log, noteOf) {

package/dist/agents/skill-loader.js

@@ -108,33 +108,44 @@ export async function parseSkillFile(filePath) {
     const dirName = path.basename(path.dirname(filePath));
     return normalize(dirName, filePath, raw);
 }
-/** 扫描一个目录, 找所有 {name}/SKILL.md (一层嵌套结构) */
+/** 扫描一个目录, 找所有 {name}/SKILL.md — 支持多级嵌套 (2026-10-12, Hermes 式分类技能库) */
 export async function loadSkillsDir(dir) {
     const out = [];
+    await walkSkillsDir(dir, out);
+    return out;
+}
+/** 递归扫: 一层 {name}/SKILL.md + 深层子目录 (Hermes skills/<category>/<skill>/SKILL.md 形态) */
+async function walkSkillsDir(dir, out, depth = 0) {
     let entries;
     try {
         entries = await fs.readdir(dir, { withFileTypes: true });
     }
     catch {
-        return out;
+        return;
     }
     for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
         if (entry.name.startsWith('.'))
             continue;
-        const skillFile = path.join(dir, entry.name, 'SKILL.md');
-        const meta = await parseSkillFile(skillFile);
-        if (meta)
-            out.push(meta);
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // ① 这层有 SKILL.md → 即一个技能目录
+            const meta = await parseSkillFile(path.join(full, 'SKILL.md'));
+            if (meta) {
+                out.push(meta);
+                continue;
+            }
+            // ② 没有 → 递归下钻 (分类层), 防深到失控
+            if (depth < 6)
+                await walkSkillsDir(full, out, depth + 1);
+        }
     }
-    return out;
 }
-/** 默认 skill 路径优先级 (后者覆盖前者同名 skill) */
+/** 默认 skill 路径优先级 (后者覆盖前者同名 skill); 2026-10-12 加 `<cwd>/skills` (Hermes 式仓库技能库) */
 export function defaultSkillPaths(home = os.homedir(), cwd = process.cwd()) {
     return [
         path.join(home, '.bolloon', 'skills'), // 全局用户级
-        path.join(cwd, '.bolloon', 'skills'), // 项目级
+        path.join(cwd, '.bolloon', 'skills'), // 项目级 (传统 Bolloon)
+        path.join(cwd, 'skills'), // 项目级 (Hermes 式: 仓库根 skills/ 分类技能库)
         path.join(home, '.boll', 'skills'), // 全局 (兼容 bollharness 旧用户)
     ];
 }
@@ -168,7 +179,3 @@ export async function loadSkillsFromPaths(paths) {
     }
     return Array.from(seen.values());
 }
-/** 列出已加载的 skills (调试/UI 用) */
-export function describeSkill(s) {
-    return `${s.name}: ${s.description}`;
-}

package/dist/agents/skills-manager.js

@@ -25,7 +25,7 @@ import { sanitizeSkillName as sanitizeNameLoose, getUserSkillsDir as userSkillsD
 import { parseSkillFile as parseSkillFileLoose } from './skill-loader.js';
 import { parseSkillFile, defaultSkillPaths } from './skill-loader.js';
 import { getUserSkillsDir } from './skill-writer.js';
-import { collectSkillBundle, parseSkillBundle, parseSkillRef, fetchSkillBundle, installSkillBundle, } from './skill-share.js';
+import { collectSkillBundle, parseSkillBundle, installSkillBundle, } from './skill-share.js';
 // ─────────────────────────────────────────────────────────────────────────────
 export function registryPath(home = os.homedir()) {
     return path.join(home, '.bolloon', 'skills-registry.json');
@@ -400,30 +400,6 @@ export class SkillsManager {
             await this.onRegistryChanged({ home: opts.home ?? this.home, action: 'import', name: tx.name }).catch(() => null);
         return { ok: tx.ok, name: tx.name, version: tx.version, error: tx.error, skill: tx.skill };
     }
-    /** @deprecated 保留旧签名以兼容; 内部已走事务版 */
-    async importLegacy(ref, opts = {}) {
-        const cid = parseSkillRef(ref);
-        if (!cid)
-            return { ok: false, error: `无法识别的技能引用 (要 bolloon://skill/<cid> / ipfs://<cid> / 裸 CID): ${ref.slice(0, 60)}` };
-        const fetched = await fetchSkillBundle(cid);
-        if (!fetched.ok || !fetched.bundle)
-            return { ok: false, error: fetched.error || '取包失败' };
-        const inst = await installSkillBundle(fetched.bundle, { home: opts.home ?? this.home, cwd: opts.cwd ?? this.cwd, force: opts.force, scope: opts.scope });
-        if (!inst.ok)
-            return { ok: false, error: inst.error };
-        const h = opts.home ?? this.home;
-        const name = fetched.bundle.name;
-        this.cache = null;
-        const after = await this.inspect(name, { home: h });
-        if (after) {
-            await this.patchRegistry(name, {
-                status: 'installed', source: opts.source || 'shared', sourceRef: cid, trust: 'unverified',
-                contentHash: after.contentHash, version: after.version,
-            }, h);
-        }
-        return { ok: true, name, version: fetched.bundle.version, skill: (await this.inspect(name, { home: h })) || undefined };
-    }
-    /** 从已解析的技能包装入 (本地文件/已取到的包) */
     async install(bundleJson, opts = {}) {
         // 2026-09-16 (2-G.3): 同样走事务 (install 的默认来源保持 'imported')
         const tx = await this.importTransactional({ bundleJson }, { ...opts, source: opts.source || 'imported' });

package/dist/agents/workflow-pivot-loop.js

@@ -56,6 +56,8 @@ export function canonicalizeToolCallArguments(argStr) {
 }
 /** 2026-08-11 (Hermes build_worker_context 全限幅): 工具输出进 LLM 上下文的上限 */
 export const TOOL_RESULT_MAX_CHARS = 12_000;
+/** 2026-10-12: 单工具执行超时 (慢工具不再拖死整轮; 超时 → 失败结果 + 续跑提示给 LLM 下轮决策) */
+export const TOOL_EXEC_TIMEOUT_MS = (typeof process !== 'undefined' && Number(process.env.BOLLOON_TOOL_TIMEOUT_MS)) || 120_000;
 /** 截断工具输出 (纯函数, 可单测): 超限 → 保留前 max + 可见省略标记 */
 export function truncateToolOutput(output, max = TOOL_RESULT_MAX_CHARS) {
     const s = output ?? '';
@@ -63,6 +65,34 @@ export function truncateToolOutput(output, max = TOOL_RESULT_MAX_CHARS) {
         return s;
     return s.slice(0, max) + `\n… [truncated, ${s.length - max} chars omitted]`;
 }
+/** 2026-10-12 (leo: 「每个命令后面放一个命令执行时间的读秒」): 毫秒 → 人读耗时串 (纯函数, 可单测) */
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return '(耗时未知)';
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = ms / 1000;
+    if (s < 60)
+        return `${s.toFixed(1)}s`;
+    const m = Math.floor(s / 60);
+    const rem = Math.round(s % 60);
+    return `${m}m${rem}s`;
+}
+/**
+ * 2026-10-12 (leo: 「对于 terminal 执行的命令, 你可以提供一个压缩的摘要」):
+ * 工具输出进 UI 前的摘要 (纯函数, 可单测) —— 只压 `terminal`/`shell` 类长输出:
+ * 折叠空白、截断到 ~300 字符、保留头部 (命令结果的开头最有信息量)。
+ * 其它工具原样返回 (read_file 等短输出没必要压)。
+ */
+export function summarizeToolOutput(toolName, output) {
+    const s = output ?? '';
+    if (!/terminal|shell|bash|exec/i.test(toolName))
+        return s;
+    const collapsed = s.replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+    if (collapsed.length <= 300)
+        return collapsed;
+    return collapsed.slice(0, 300) + `\n… [摘要, 原输出 ${s.length} 字符]`;
+}
 /**
  * Analyze input to determine task complexity
  */
@@ -386,24 +416,14 @@ export class WorkflowPivotLoop {
                 const nativeTools = this.nativeToolCallsToDefinitions(llmResponse.toolCalls || []);
                 const pendingTools = nativeTools.length > 0 ? nativeTools : this.extractPendingToolUses(reply);
                 if (pendingTools.length === 0) {
-                    // 2026-07-06: LLM 显式 <final gen> 标记 — pivot 立即退出, 不再走 quality/iter 流程
-                    //   这个 marker 之前和 思考/ 同义被忽略, 害得 "你好" 类问题跑 11 iter 还不见停
-                    //   加上之后 iter=1 收到 <final gen> 就 accept
-                    if (/<final\s+gen\s*\/?>|<\/final\s+gen>/i.test(reply)) {
-                        const cleaned = reply.replace(/<final\s+gen\s*\/?>|<\/final\s+gen>/gi, '').trim();
-                        response = cleaned || reply;
-                        this.emit({
-                            type: 'status', internal: true, // K4-B: 循环遥测 = 内部运行日志 (口径同老 loop)
-                            content: `✅ 检测到 <final gen> 结束标记, 立即退出 (iter=${this.state.iteration})`,
-                            tool: 'system',
-                        });
-                        return this.createResult(true, response, 'final_gen_marker');
-                    }
+                    // 2026-10-12 (leo 拍板: 全项目去掉 <final gen> 截止符):
+                    //   旧实现这里检测 `<final gen>` 标记 → 立即 break 退出 —— 模型在中间轮次
+                    //   echo 出 "> <final gen>" 类文本 (思考引用/复述契约) 就被正则命中, 循环提前截止,
+                    //   正是「中间生成了内容, 没办法衔接上就停止了」的根因之一。
+                    //   现在循环停止只剩: 质量达标 / 连续无进展 / 用户中止 (leo 确认的三条路)。
                     // Check if the reply contains tool call intent but couldn't be parsed
-                    // 2026-07-06: 排除合法的 思考/<final gen> 这些 tag (它们是 sentinel 不是 tool call)
                     const cleanedForIntentCheck = reply
-                        .replace(/<final\s+gen\s*\/?>|<\/final\s+gen>/gi, '')
-                        .replace(/<\/?think(?:ing)?>/gi, ''); // 移除
+                        .replace(/<\/?think(?:ing)?>/gi, ''); // 移除 think 块
                     const containsToolCallIntent = cleanedForIntentCheck.includes('调用工具') || cleanedForIntentCheck.includes('tool(') ||
                         cleanedForIntentCheck.includes('使用工具') || cleanedForIntentCheck.includes('需要获取') || cleanedForIntentCheck.includes('需要查看') ||
                         cleanedForIntentCheck.includes('tool =>') || cleanedForIntentCheck.includes('[TOOL_CALL]') ||
@@ -421,6 +441,12 @@ export class WorkflowPivotLoop {
                     }
                     // No pending tool uses - this is a normal completion
                     this.state.pendingToolUses = [];
+                    // 2026-10-12 (leo: 「任务进行到一半就卡住了」): **0 工具轮也要把回复写进历史**。
+                    //   旧代码只在工具执行分支 push assistant —— 纯回复轮 (模型给最终回答) 不进 history,
+                    //   于是: ① 质量不达标被打回重跑时, 模型下一轮**看不到自己上轮说过什么**;
+                    //   ② 循环因无进展退出时, 兜底取 `lastAssistant?.content` 是**最后一次工具轮**的
+                    //   空 content ⇒ 屏上 `│  │` 空框。现在: 每轮回复都进历史, 兜底能拿到真正的最终答复。
+                    this.messageHistory.push({ role: 'assistant', content: reply });
                     // Evaluate quality before accepting
                     const quality = this.evaluateQuality(reply);
                     this.state.qualityScores.push(quality);
@@ -429,32 +455,38 @@ export class WorkflowPivotLoop {
                         content: `✅ 检测到最终回复 (质量: ${(quality * 10).toFixed(1)}/10)`,
                         tool: 'system'
                     });
-                    // Check if quality threshold met
-                    if (quality >= effectiveConfig.qualityThreshold) {
-                        response = reply;
-                        return this.createResult(true, reply, 'quality_threshold_met');
-                    }
-                    // Quality not met but no more tools to call
-                    // Accept response if we've done minimum iterations
-                    if (this.state.iteration >= effectiveConfig.minIterations) {
-                        response = reply;
-                        return this.createResult(true, reply, 'no_pending_tools');
+                    // 2026-10-12 (leo: 「循环跑 1 次就截止, 要能多轮」): 质量未达标时旧代码在
+                    //   iter >= minIterations (默认 2) 就**直接收下** (no_pending_tools) —— 长任务
+                    //   经常第 2 轮就给出不完整回答被收了, 正是「中间生成内容但衔接不上就停止」。
+                    //   现在: 质量未达标一律**注入续跑提示 + 继续循环**, 由 maxConsecutiveNoProgress 兜底
+                    //   (真有进展的会持续往下, 空转的到阈值才停) —— 该停才停, 不是早停。
+                    if (quality < effectiveConfig.qualityThreshold) {
+                        this.pushContinuationHint(`上一轮回答质量评测 ${(quality * 10).toFixed(1)}/${(effectiveConfig.qualityThreshold * 10).toFixed(1)}, 未达完成标准 — 请对照用户需求检查是否还有未完成的子目标, 需要工具就继续调用, 全部完成再给出完整最终回答.`);
+                        this.state.consecutiveNoProgress++;
+                        this.emit({
+                            type: 'status', internal: true, // K4-B: 循环遥测 = 内部运行日志 (口径同老 loop)
+                            content: `📊 质量未达标 (${(quality * 10).toFixed(1)}/${(effectiveConfig.qualityThreshold * 10).toFixed(1)})，注入续跑提示，继续循环`,
+                            tool: 'system'
+                        });
+                        continue;
                     }
-                    // Too early, continue to see if we can improve
-                    this.state.consecutiveNoProgress++;
-                    this.emit({
-                        type: 'status', internal: true, // K4-B: 循环遥测 = 内部运行日志 (口径同老 loop)
-                        content: `📊 质量未达标 (${(quality * 10).toFixed(1)}/${(effectiveConfig.qualityThreshold * 10).toFixed(1)})，继续循环`,
-                        tool: 'system'
-                    });
-                    continue;
+                    // Quality met — accept
+                    response = reply;
+                    return this.createResult(true, reply, 'quality_threshold_met');
                 }
                 // We have pending tool uses - execute them
                 this.state.pendingToolUses = pendingTools;
                 this.state.lastMeaningfulWork = this.state.iteration;
                 this.state.consecutiveNoProgress = 0;
-                for (const toolCall of pendingTools) {
+                // 2026-10-12 (leo: 「运行工具的时候没有在后台运行, 花了太久, 把时间给 pass 了」):
+                //   旧实现 for...of 串行 await + **无超时** —— 一个慢工具 (网络/重 IO) 拖住整轮,
+                //   后面的工具全被阻塞, 轮次预算被耗在等待上。
+                //   现在: ① 同一轮的多个工具**并行**执行 (老 loop 早已 Promise.all, pivot 是行为退化);
+                //   ② 每个工具加超时包装 (默认 120s, BOLLOON_TOOL_TIMEOUT_MS 可调) —— 超时返回
+                //   失败结果 + 续跑提示, 让 LLM 下轮决定换法/重试, 而不是无限挂起。
+                const execTool = async (toolCall) => {
                     this.state.toolCallsCount++;
+                    const toolT0 = Date.now(); // 2026-10-12: 单工具耗时 (step_done 读秒用)
                     const tool = this.tools.get(toolCall.name);
                     if (!tool) {
                         this.emit({
@@ -478,7 +510,7 @@ export class WorkflowPivotLoop {
                             role: 'tool',
                             content: JSON.stringify({ success: false, error: `Unknown tool: ${toolCall.name}` })
                         });
-                        continue;
+                        return;
                     }
                     this.emit({
                         type: 'tool',
@@ -515,18 +547,38 @@ export class WorkflowPivotLoop {
                         //   **fail-closed**: 端口抛错 ⇒ 记拒执行文案且**绝不回落** `tool.execute` ——
                         //   门坏掉若静默变成"没门"(旧实现那两条 fail-open 路径), 比没有门更危险。
                         let result;
-                        if (this.config.guardedExecute) {
-                            try {
-                                result = await this.config.guardedExecute(tool, toolCall.args ?? {});
+                        const executeFn = this.config.guardedExecute
+                            ? () => this.config.guardedExecute(tool, toolCall.args ?? {})
+                            : () => tool.execute(toolCall.args ?? {});
+                        // 2026-10-12: 超时包装 — 慢工具不再拖死整轮 (失败结果给 LLM 下轮决策)
+                        const toolTimeoutMs = TOOL_EXEC_TIMEOUT_MS;
+                        // 2026-10-13 (leo: 「发送消息过程中的打断和衔接整个流程」): 工具执行阶段也要响应 abort —
+                        //   之前 Promise.race 只有 executeFn + 超时两路, Ctrl+C 打断要等工具跑完/超时 (最长 120s) 才生效。
+                        //   现在加第三路 abort: signal 触发立即返回"已中断"结果 → while 顶部 signal.aborted 检查 break。
+                        const abortWait = new Promise((resolve) => {
+                            const onAbort = () => resolve({ success: false, error: `已中断: ${toolCall.name} 被打断 (Ctrl+C)` });
+                            if (signal?.aborted) {
+                                onAbort();
+                                return;
                             }
-                            catch (guardErr) {
-                                const msg = String(guardErr?.message ?? guardErr);
-                                result = { success: false, error: `拒绝: [harness-error] ${msg}` };
-                            }
-                        }
-                        else {
-                            result = await tool.execute(toolCall.args ?? {});
-                        }
+                            signal?.addEventListener?.('abort', onAbort, { once: true });
+                        });
+                        result = await Promise.race([
+                            (async () => {
+                                try {
+                                    return await executeFn();
+                                }
+                                catch (guardErr) {
+                                    const msg = String(guardErr?.message ?? guardErr);
+                                    return { success: false, error: `拒绝: [harness-error] ${msg}` };
+                                }
+                            })(),
+                            new Promise((resolve) => setTimeout(() => {
+                                resolve({ success: false, error: `工具超时 (${toolTimeoutMs}ms): ${toolCall.name} 未在时限内返回` });
+                            }, toolTimeoutMs).unref?.()),
+                            abortWait,
+                        ]);
+                        const toolCostMs = Date.now() - toolT0; // 2026-10-12: 实际耗时 (含等待)
                         // 2026-08-11: 输出过大 → 续跑提示 (Hermes dropped-tools continuation 模式),
                         //   上下文后续可能被压缩, 提醒 LLM 需要精确数据时缩小范围重查
                         const outLen = (result.output || '').length;
@@ -537,19 +589,25 @@ export class WorkflowPivotLoop {
                         this.emit({
                             type: result.success ? 'step_done' : 'step_error',
                             content: result.success
-                                ? `${toolCall.name} 成功`
-                                : `${toolCall.name} 失败: ${result.error}`,
+                                ? `${toolCall.name} 成功 · ${formatDuration(toolCostMs)}`
+                                : `${toolCall.name} 失败: ${result.error}`, // 失败文案带原因即可, 耗时由 UI 从 durationMs 读
                             tool: toolCall.name,
                             success: result.success,
-                            output: result.output,
+                            output: summarizeToolOutput(toolCall.name, result.output),
                             error: result.error,
+                            durationMs: toolCostMs,
                         });
-                        this.emit({
-                            type: result.success ? 'status' : 'error',
-                            content: result.success
-                                ? `✅ ${toolCall.name} 成功`
-                                : `❌ ${toolCall.name} 失败: ${result.error}`
-                        });
+                        // 2026-10-12 (leo: 「✅ read_file 成功 不用发出来」):
+                        //   成功不再发 `✅ X 成功` 状态行 —— step_done 已带 工具名+耗时+摘要, 重复的
+                        //   成功汇报纯属噪音 (用户原话: 「这种执行工具成功的汇报不用发出来这个 log,
+                        //   只需要把工具执行的记录写清楚就行了」)。**失败保留** (`❌` error 事件,
+                        //   需人介入的信号不许吞)。
+                        if (!result.success) {
+                            this.emit({
+                                type: 'error',
+                                content: `❌ ${toolCall.name} 失败: ${result.error}`
+                            });
+                        }
                         this.messageHistory.push({
                             role: 'assistant',
                             content: reply,
@@ -574,9 +632,29 @@ export class WorkflowPivotLoop {
                             content: JSON.stringify({ success: false, error: String(execError) })
                         });
                     }
-                }
+                };
+                await Promise.all(pendingTools.map(execTool));
             }
             catch (error) {
+                // 2026-10-13 (leo: 「多步执行的任务会返回空, 直接回复的不会」): 根因是**模型调用超时杀死循环**。
+                //   多步任务工具多轮后上下文膨胀 (40KB+), kernel 模型调用 30s 硬超时抛 ModelTimeoutError,
+                //   旧代码一律当「循环崩溃」处理 (return createResult(false, response, 'error')) ⇒
+                //   工具全干完、response 还是空 → 屏上 `│  │` 空框。
+                //   修复: 超时 = 供应商慢, 不是循环崩。emit 状态 + continue 重试下一轮;
+                //   真卡死由 maxConsecutiveNoProgress 兜底 (每条路都有终点, 唯独不该有「白干+空框」)。
+                const isTimeout = error instanceof Error && (error.name === 'ModelTimeoutError' || /模型调用超时/.test(error.message));
+                if (isTimeout) {
+                    this.state.consecutiveNoProgress++;
+                    this.emit({
+                        type: 'status', internal: true, // K4-B: 循环遥测 = 内部运行日志 (口径同老 loop)
+                        content: `⏳ 模型调用超时 (${String(error.message).replace(/^模型调用超时\s*\(/, '').replace(/\)$/, '')}), 重试下一轮 (连续 ${this.state.consecutiveNoProgress}/${effectiveConfig.maxConsecutiveNoProgress} 次则停)`,
+                        tool: 'system',
+                    });
+                    // 2026-10-13 (leo: 「可以不用超时截止来确定时间周期, 有时候任务需要时间会比较久」):
+                    //   超时只是这一轮没来得及, 任务该做多久做多久 —— **不**注入「快点给个回答」的收敛提示
+                    //   (那会让模型在任务没做完时草草收尾)。继续推进, 由质量门/无进展兜底决定什么时候算完。
+                    continue;
+                }
                 this.emit({
                     type: 'error',
                     content: `❌ 循环异常: ${error}`
@@ -618,12 +696,18 @@ export class WorkflowPivotLoop {
     }
     /**
      * Adapt configuration based on task profile
+     *
+     * 2026-10-12 (leo: 「工具轮次到了 10 次就截止了」): 旧实现用
+     *   `Math.min(config.maxIterations, profile.suggestedMaxIterations)` 压迭代上限、
+     *   `Math.min(config.maxTokenBudget, profile.tokenBudget)` 压 token 预算 ——
+     *   simple 任务被压到 **10 iter + 800~2400 token**, 而 systemPrompt 本身就 40KB+,
+     *   第一次迭代 totalTokens 就超支 → 循环立刻 break, 长任务根本跑不完。
+     *   上限保留 createDefaultPivotConfig 的 200/1000/2000 (本来就注释「跑到 N 次也不报超时」),
+     *   由质量门 / maxConsecutiveNoProgress / user abort 兜底 —— 循环持久, 该停才停。
      */
     adaptConfigForTask(profile) {
         return {
             ...this.config,
-            maxIterations: Math.min(this.config.maxIterations, profile.suggestedMaxIterations),
-            maxTokenBudget: Math.min(this.config.maxTokenBudget, profile.tokenBudget),
             complexity: profile.complexity
         };
     }
@@ -847,6 +931,13 @@ export class WorkflowPivotLoop {
      * Evaluate response quality
      */
     evaluateQuality(response) {
+        // 2026-10-13 (leo: 「我发了一个命令, 返回空」): **空回复必须判不合格** —— 旧实现起点 0.7,
+        //   空串 '' 也有 0.7 分, 恰好等于默认阈值 ⇒ 空 reply 直接 quality_threshold_met 收尾 ⇒ CLI 空框
+        //   (「你好」正常因为模型给文本; 「能看到我的仓库吗？」模型某轮返回空 content/tool-only 回复 ⇒ 空串过关)。
+        //   现在: 空/纯空白一律 0.3 (低于任何阈值), 打回让模型重给; 非空保持旧评分。
+        const t = String(response || '').trim();
+        if (!t)
+            return 0.3;
         let score = 0.7; // 2026-07-06: 起点 0.7 — 短回复不应被当成低质量打回去重跑
         // Length bonus
         if (response.length > 100)
@@ -908,7 +999,7 @@ export class WorkflowPivotLoop {
         const identityLine = lines.find((l) => l.includes('你是') && !l.includes('(续)')) ?? '';
         return `[continuation] 你的 persona + tools + judgments 已在首轮 messageHistory 中.
 ${identityLine ? identityLine + '\n' : ''}当前 step 别再读 persona 全文, 继续推进任务即可.
-> <final gen> 只在真完成时输出.`;
+> 任务完成前持续调用工具推进; 全部完成后给出完整最终回答.`;
     }
     /**
      * Create result object
@@ -972,7 +1063,7 @@ ${identityLine ? identityLine + '\n' : ''}当前 step 别再读 persona 全文,
  */
 export function createDefaultPivotConfig(complexity) {
     // 2026-07-06: maxIterations 默认大幅上调 — LLM 自己约束结束时机, 持久循环.
-    //   真实停止由 LLM emit <final gen> / 质量达标 / 连续无进展 / user abort 触发.
+    // 2026-10-12: 真实停止由 质量达标 / 连续无进展 / user abort 触发 (leo 拍板去掉 <final gen>).
     //   旧 30/60 iter 在长任务 (eg. 大文档改写) 太短, 现在跑到 N 次也不报超时.
     const profiles = {
         simple: {