@bolloon/bolloon-agent 0.6.4 → 0.6.6

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: {

package/dist/agents/world-watcher.js

@@ -15,7 +15,8 @@ export { readProfile, setProfile };
 let watcherTimer = null;
 let watching = false; // 防重叠: 上一轮没跑完就跳过这一轮
 let watcherCount = 0;
-/** 单轮观察: 扫描世界 → 观察日志/校准环自动积累 (分发主体本地版) */
+/** 单轮观察: 扫描世界 → 观察日志/校准环自动积累 (分发主体本地版)。
+ *  2026-10-05 (leo): 有 active intent / 画像时, 自动上网搜机会 (AI 主动搜索, 非被动响应)。 */
 export async function tickWorldWatcher() {
     if (watching)
         return { ok: true, observed: 0, count: watcherCount, error: '上一轮观察未完成, 跳过本轮 (防重叠)' };
@@ -23,12 +24,40 @@ export async function tickWorldWatcher() {
     try {
         const r = await scanOpportunities({ limit: 50 });
         watcherCount += 1;
+        // 2026-10-05: 主动搜索 — 有意图/画像才搜 (无 topic 不烧网络); 失败不影响扫描
+        await autoSearchForIntents();
         return { ok: r.ok, observed: r.results.length, count: watcherCount, error: r.error };
     }
     finally {
         watching = false;
     }
 }
+/** 按 active intent + 画像文本自动搜索机会 (AI 主动上网找, 结果进 world/search/) */
+async function autoSearchForIntents() {
+    try {
+        const { listIntents } = await import('./intent-store.js');
+        const intents = await listIntents();
+        const active = intents.ok ? intents.intents.filter((i) => i.status === 'active') : [];
+        const topics = active.map((i) => i.text);
+        if (!topics.length) {
+            const profile = await readProfile();
+            if (profile && (profile.about || profile.tags.length)) {
+                topics.push(profile.about || profile.tags.join(' '));
+            }
+        }
+        if (!topics.length)
+            return; // 无意图无画像 → 不主动搜
+        // 每轮至多搜 2 个主题 (网络调用有成本; 已有结果幂等不重复)
+        for (const t of topics.slice(0, 2)) {
+            const { searchOpportunitiesForTopic } = await import('./opportunity-web-search.js');
+            const r = await searchOpportunitiesForTopic(t, { limit: 4 });
+            if (r.added > 0) {
+                console.info(`[world-watcher] 主动搜索「${t.slice(0, 30)}」新增 ${r.added} 条机会`);
+            }
+        }
+    }
+    catch { /* 主动搜索失败静默, 下一轮再试 */ }
+}
 /**
  * 启动世界自动观察器 (服务端启动时调用一次即可; 幂等, 重复调用不叠定时器)。
  * 每 intervalMs (默认 10 分钟) 自动扫描一次 —— 机会进入 AI 视野是主动行为, 不是人触发。

package/dist/bootstrap/context-collector.js

@@ -214,10 +214,8 @@ function collectEnv() {
     let llmProvider = 'unknown';
     try {
         const home = process.env.HOME || os.homedir() || '/tmp';
-        // 2026-08-07: bolloon-config.json 优先, 旧 llm-config.json 兜底
-        let cfgPath = path.join(home, '.bolloon', 'bolloon-config.json');
-        if (!require('fs').existsSync(cfgPath))
-            cfgPath = path.join(home, '.bolloon', 'llm-config.json');
+        // 2026-10-06 技术债清理: 只读 canonical bolloon-config.json (旧 llm-config.json 已废弃)
+        const cfgPath = path.join(home, '.bolloon', 'bolloon-config.json');
         const cfg = require(cfgPath);
         if (cfg && typeof cfg === 'object' && 'provider' in cfg) {
             llmProvider = String(cfg.provider);

package/dist/bootstrap/context-hierarchy.js

@@ -71,7 +71,9 @@ async function readRuleFile(filePath) {
     }
 }
 /**
- * 读 project 层: 优先 Bolloon.md, fallback Bolloon.md, 最后尝试 .claude/rules/*.md
+ * 读 project 层: 优先 Bolloon.md, fallback Bolloon.md,
+ * 然后 AGENTS.md / CLAUDE.md (2026-10-12: Hermes/Claude Code 仓库约定文件, leo 要求对照 Hermes 主动加载),
+ * 最后尝试 .claude/rules/*.md
  */
 async function readProjectLayer(projectPath, projectRulesDir, maxChars) {
     // 1. Bolloon.md
@@ -83,6 +85,16 @@ async function readProjectLayer(projectPath, projectRulesDir, maxChars) {
     content = await readRuleFile(bolloonMdPath);
     if (content)
         return truncate(content, maxChars);
+    // 2b. 2026-10-12 (leo: 「开始的时候没有主动扫描加载这个仓库里面的技能, 看一下 hermes 怎么做的」):
+    //    Hermes 启动会把当前仓库的 AGENTS.md / CLAUDE.md 自动装进 project context (仓库约定即技能/规则)。
+    //    Bolloon 只认 Bolloon.md + .claude/rules, 漏了这两个最通用的约定文件 — 补上。
+    for (const f of ['AGENTS.md', 'CLAUDE.md']) {
+        const p = path.join(path.dirname(projectPath), f);
+        content = await readRuleFile(p);
+        if (content) {
+            return truncate(`### ${f}\n${content}`, maxChars);
+        }
+    }
     // 3. .claude/rules/*.md (合并所有)
     try {
         const entries = await fs.readdir(projectRulesDir, { withFileTypes: true });

package/dist/cli/ink-app.js

@@ -15,7 +15,6 @@ import { Static, render, Box, Text, useInput, useApp, useStdout } from 'ink';
 import { stripUiNoise, collapsePaste, stripBracketedPaste, looksLikePasteChunk, logPasteChunk, shouldSuppressMention, singleLine, logPopupEvent, PASTE_MENTION_SHIELD_MS } from './input-paste.js';
 import TextInput from 'ink-text-input';
 import { dispWidth, LOADING_FRAMES as KAOMOJI } from './loading-tui.js';
-import { reasoningMode } from './reasoning-view.js';
 import { THEME, fg } from './theme.js';
 import { COMPOSER_PLACEHOLDER, POPUP_TITLE_TAB, POPUP_TITLE_AGENT, POPUP_TITLE_FILE, POPUP_TITLE_COMMAND } from './content.js';
 import { DOUBLE_ESC_MS, STATUS_TICK_MS, THINK_FRAME_MS } from './timing.js';
@@ -389,30 +388,48 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
     // 2026-09-08 (Hermes TUI 学习落地): 实时终端尺寸 — 原来 terminalW/H 在 mount 时冻结,
     //   终端 resize 后分隔线/logo 宽度全错位 (Hermes 用 resizeCoalescer + 实时 layout)。
     //   订阅 stdout resize, 每次渲染用最新列数。
+    // 2026-10-15 (leo 拖动侧边栏): **变窄**时终端把旧帧满宽行自动折行,
+    //   Ink 的 eraseLines(lastOutputHeight) 按**未折行**行数擦 ⇒ 擦不干净 ⇒ 旧 footer/分隔线/
+    //   思考行残影被推进滚动区; 且 `<Static>` 历史区写进 scrollback 后不会重绘, 残影永远留在那里.
+    //   修法 (只对**变窄**): resize 停止 150ms 后整屏重建 —
+    //   ① 发 `ESC[2J ESC[3J ESC[H` (清可视区 + 清 scrollback + 光标归位) 把残影彻底清掉;
+    //   ② suspendInk + resumeInk 重挂全新 InkApp: `<Static>` 首次挂载对 store 全量重放
+    //      (历史一行不少, 按新宽度重新 wrap), footer 按新宽度重画。
+    //   变宽不会折行 (旧行宽 ≤ 旧终端宽 < 新终端宽), Ink 自己重画即可, 不重建。
     const { stdout } = useStdout();
     const [termSize, setTermSize] = useState({ w: terminalW, h: terminalH });
     useEffect(() => {
-        // resizeCoalescer (#9): 拖拽终端时会连发 resize — 聚合到 80ms 空闲后一次性应用, 避免中间态跳帧
-        let raf = null;
-        let pending = null;
-        const apply = () => {
-            if (pending) {
-                const p = pending;
-                pending = null;
-                setTermSize(p);
+        let lastWidth = stdout?.columns || terminalW;
+        let rebuildTimer = null;
+        const rebuild = () => {
+            rebuildTimer = null;
+            try {
+                // 残影在 scrollback 里 —— eraseLines 够不到, 必须整屏清掉再让 Ink 全量重放
+                process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+                suspendInk();
+                // 让 React 先完成 unmount 清理, 再重挂 (避免新旧实例抢 stdout)
+                setTimeout(() => { try {
+                    resumeInk();
+                }
+                catch { /* 重建失败不致命, 下次 resize 再试 */ } }, 0);
             }
-            raf = null;
+            catch { /* 清屏/重建失败不阻塞 resize 本身 */ }
         };
         const update = () => {
-            pending = { w: stdout?.columns || terminalW, h: stdout?.rows || terminalH };
-            if (raf)
-                clearTimeout(raf);
-            raf = setTimeout(apply, 80);
+            const w = stdout?.columns || terminalW;
+            setTermSize({ w, h: stdout?.rows || terminalH });
+            if (w < lastWidth) {
+                // 变窄: 折行残影无法增量修复, 停止拖动后整屏重建
+                if (rebuildTimer)
+                    clearTimeout(rebuildTimer);
+                rebuildTimer = setTimeout(rebuild, 150);
+            }
+            lastWidth = w;
         };
         update();
         stdout?.on?.('resize', update);
-        return () => { stdout?.removeListener?.('resize', update); if (raf)
-            clearTimeout(raf); };
+        return () => { if (rebuildTimer)
+            clearTimeout(rebuildTimer); stdout?.removeListener?.('resize', update); };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [stdout]);
     const W = termSize.w;
@@ -509,6 +526,16 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
             setTimeout(() => process.exit(0), 2000);
         };
         if (key.ctrl && _input === 'c') {
+            // 2026-10-13 (leo: 「按一次 Ctrl+C 是中断当前对话; 按两次才是完整退出; 空闲时按一次就退出」):
+            //   走 index.ts 注册的两级语义处理器 —— 有回合在跑且未 armed → 中断回合 (abort kernel actor);
+            //   第二次 / 空闲 → 完整退出。Ink raw mode 下 Ctrl+C 被 useInput 拦截, 不会产生 SIGINT,
+            //   所以**这里**才是 Ctrl+C 的主入口 (进程级 SIGINT 只是启动早期兜底)。
+            const sigintHandler = globalThis.__bolloonCliSigint;
+            if (typeof sigintHandler === 'function') {
+                sigintHandler();
+                return;
+            }
+            // 兜底: 处理器没注册 (极早期) → 直接退出, 不吞 Ctrl+C
             requestExit();
             return;
         }
@@ -839,7 +866,7 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
         }
         catch { /* 探针写不进去绝不影响界面 */ }
     });
-    return (_jsxs(_Fragment, { children: [_jsx(Static, { items: msgs, children: (m, i) => _jsx(Text, { children: m }, `m${i}`) }), _jsxs(Box, { flexDirection: "column", width: budget.cols, children: [hasRails && (_jsx(Box, { flexDirection: "column", children: railNames.map((n) => _jsx(Text, { color: THEME.muted, children: `${n}: ${String(widgets[n] ?? '').replace(/\n/g, ' ')}` }, n)) })), popupOpenNow && tabState && (_jsx(MentionPopup, { title: POPUP_TITLE_TAB, items: filtered, sel: safeSel, width: W, maxRows: budget.popupRows })), popupOpenNow && !tabState && mention && (_jsx(MentionPopup, { title: popupTitle, items: filtered, sel: safeSel, width: W, loading: loadingFiles, maxRows: budget.popupRows })), popupOpenNow && !tabState && !mention && picker && (_jsx(MentionPopup, { title: picker.title, items: picker.items, sel: Math.min(picker.sel, picker.items.length - 1), width: W, maxRows: budget.popupRows })), _jsx(Box, { height: 1, width: budget.cols, overflow: "hidden", children: transient ? (_jsx(Text, { children: transient })) : thinking ? (_jsx(Text, { color: "yellow", children: reasoningMode() === 'trace' ? '思考中...' : `${KAOMOJI[thinkingIdx.current]} 思考中...` })) : (_jsx(Text, { color: THEME.muted, children: '· 回车发送 · ↑↓ 历史 · PgUp 回看 · Esc 双击退出' })) }), _jsx(Box, { width: budget.cols, height: 1, overflow: "hidden", children: _jsx(Text, { bold: true, color: THEME.accent, children: ruleFor(Math.max(10, budget.cols - 1)) }) }), _jsx(Box, { height: 1, width: budget.cols, overflow: "hidden", children: _jsx(Text, { children: status }) }), _jsx(Box, { width: budget.cols, height: 1, overflow: "hidden", children: _jsx(Text, { bold: true, color: THEME.accent, children: ruleFor(Math.max(10, budget.cols - 1)) }) }), _jsxs(Box, { width: budget.cols, height: 1, overflow: "hidden", children: [_jsx(Text, { bold: true, color: THEME.accent, children: "\u276F " }), _jsx(Box, { width: Math.max(10, budget.cols - 2), height: 1, overflow: "hidden", flexShrink: 0, children: _jsx(TextInput, { value: singleLine(input), onChange: setInput, onSubmit: onSubmit, focus: !popupOpenNow, placeholder: COMPOSER_PLACEHOLDER }, tiKey) })] }), _jsx(Box, { width: budget.cols, height: 1, overflow: "hidden", children: _jsx(Text, { bold: true, color: THEME.accent, children: ruleFor(Math.max(10, budget.cols - 1)) }) })] })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Static, { items: msgs, children: (m, i) => _jsx(Text, { children: m }, `m${i}`) }), _jsxs(Box, { flexDirection: "column", width: budget.cols, children: [hasRails && (_jsx(Box, { flexDirection: "column", children: railNames.map((n) => _jsx(Text, { color: THEME.muted, children: `${n}: ${String(widgets[n] ?? '').replace(/\n/g, ' ')}` }, n)) })), popupOpenNow && tabState && (_jsx(MentionPopup, { title: POPUP_TITLE_TAB, items: filtered, sel: safeSel, width: W, maxRows: budget.popupRows })), popupOpenNow && !tabState && mention && (_jsx(MentionPopup, { title: popupTitle, items: filtered, sel: safeSel, width: W, loading: loadingFiles, maxRows: budget.popupRows })), popupOpenNow && !tabState && !mention && picker && (_jsx(MentionPopup, { title: picker.title, items: picker.items, sel: Math.min(picker.sel, picker.items.length - 1), width: W, maxRows: budget.popupRows })), _jsx(Box, { height: 1, width: budget.cols, overflow: "hidden", children: transient ? (_jsx(Text, { children: transient })) : thinking ? (_jsxs(Text, { color: "yellow", children: [KAOMOJI[thinkingIdx.current], " \u601D\u8003\u4E2D..."] })) : (_jsx(Text, { color: THEME.muted, children: '· 回车发送 · ↑↓ 历史 · PgUp 回看 · Esc 双击退出' })) }), _jsx(Box, { width: budget.cols, height: 1, overflow: "hidden", children: _jsx(Text, { bold: true, color: THEME.accent, children: ruleFor(Math.max(10, budget.cols - 1)) }) }), _jsx(Box, { height: 1, width: budget.cols, overflow: "hidden", children: _jsx(Text, { children: status }) }), _jsx(Box, { width: budget.cols, height: 1, overflow: "hidden", children: _jsx(Text, { bold: true, color: THEME.accent, children: ruleFor(Math.max(10, budget.cols - 1)) }) }), _jsxs(Box, { width: budget.cols, height: 1, overflow: "hidden", children: [_jsx(Text, { bold: true, color: THEME.accent, children: "\u276F " }), _jsx(Box, { width: Math.max(10, budget.cols - 2), height: 1, overflow: "hidden", flexShrink: 0, children: _jsx(TextInput, { value: singleLine(input), onChange: setInput, onSubmit: onSubmit, focus: !popupOpenNow, placeholder: COMPOSER_PLACEHOLDER }, tiKey) })] }), _jsx(Box, { width: budget.cols, height: 1, overflow: "hidden", children: _jsx(Text, { bold: true, color: THEME.accent, children: ruleFor(Math.max(10, budget.cols - 1)) }) })] })] }));
 };
 export { InkApp };
 // ─── 启动 ────────────────────────────────────────────────────────────────────

package/dist/cli/intent-command.js

@@ -172,14 +172,26 @@ export async function opportunityCommand(flags) {
         human: INTENT_USAGE,
     };
 }
-function cardRows(opts) {
-    const pct = Math.round(opts.score * 100);
-    const tag = opts.reason === 'match' ? '● 与你匹配' : '○ 世界变化';
-    return [
-        `  ${pct}% ${tag}  ${opts.title}`,
-        `      ${opts.summary}`,
-        `      预算: ${opts.budget ?? '未知'} · id=${opts.id}`,
-    ];
+/** 2026-10-06 (用户: 世界模式用表格呈现): ASCII 表格机会列表 — 列 = 分数/来源/标题/预算/id */
+export function opportunityTable(results) {
+    if (!results.length)
+        return ['  (没有机会)'];
+    const reasonShort = (r) => (r === 'match' ? '匹配' : r === 'inbox' ? '投递' : r === 'search' ? '搜索' : '世界');
+    const rows = results.map((o) => {
+        const pct = Math.round(o.score * 100);
+        const title = o.title.length > 32 ? o.title.slice(0, 31) + '…' : o.title;
+        return [String(pct) + '%', reasonShort(o.reason), title, (o.budget ?? '无').slice(0, 14), o.id];
+    });
+    const w = (idx, min) => Math.max(min, ...rows.map((r) => r[idx].length));
+    const wS = w(0, 5), wR = w(1, 4), wT = w(2, 32), wB = w(3, 6), wId = w(4, 8);
+    const sep = `  +${'-'.repeat(wS)}+${'-'.repeat(wR)}+${'-'.repeat(wT)}+${'-'.repeat(wB)}+${'-'.repeat(wId)}+`;
+    const head = `  | ${'分数'.padStart(wS - 2)} | ${'来源'.padEnd(wR)} | ${'标题'.padEnd(wT)} | ${'预算'.padEnd(wB)} | ${'ID'.padEnd(wId)} |`;
+    const line = (c) => `  | ${c[0].padStart(wS)} | ${c[1].padEnd(wR)} | ${c[2].padEnd(wT)} | ${c[3].padEnd(wB)} | ${c[4].padEnd(wId)} |`;
+    const out = [sep, head, sep];
+    for (const r of rows)
+        out.push(line(r));
+    out.push(sep);
+    return out;
 }
 async function opportunityScan(flags) {
     const head = 'bolloon opportunity scan';
@@ -201,8 +213,7 @@ async function opportunityScan(flags) {
     }
     const data = { count: r.results.length, minScore, opportunities: r.results };
     const human = [title(head), `  找到 ${r.results.length} 个机会 (score ≥ ${minScore}):`, ''];
-    for (const o of r.results)
-        human.push(...cardRows(o));
+    human.push(...opportunityTable(r.results));
     human.push('', hint('用 bolloon opportunity accept <id> 确认, ignore <id> 忽略'));
     return { envelope: okEnvelope('OK', `${r.results.length} 个机会`, data, r.results.map((x) => x.id), null), human: human.join('\n') };
 }
@@ -219,8 +230,7 @@ async function opportunityList(flags) {
         if (!hits.length)
             return { envelope: okEnvelope('OK', `意图「${i.text}」暂无匹配`, { count: 0, opportunities: [] }, [], null), human: `${title(head)}\n  「${i.text}」暂无匹配机会` };
         const human = [title(head), `  「${i.text}」的 ${hits.length} 个机会:`, ''];
-        for (const o of hits)
-            human.push(...cardRows(o));
+        human.push(...opportunityTable(hits));
         return { envelope: okEnvelope('OK', `${hits.length} 个机会`, { count: hits.length, opportunities: hits }, hits.map((x) => x.id), null), human: human.join('\n') };
     }
     return opportunityScan(flags);

package/dist/cli/loading-tui.js

@@ -12,6 +12,7 @@
  *   LoadingTUI             原地刷新的启动仪表盘类
  */
 import { truncateSafe } from './status-segments.js';
+import { toolArgsSummary } from './trace-line.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
@@ -433,12 +434,17 @@ function colorizeDiff(text) {
     });
     return out.join('\n');
 }
-/** 渲染单条工具调用为紧凑列表项 (增量显示, 一行, 无 args) */
+/** 渲染单条工具调用为紧凑列表项 (增量显示, 一行, 参数摘要) */
 export function renderToolCallListItem(item, index, total) {
     const dur = item.durationMs != null ? ` ${C_DIM}${item.durationMs}ms${RESET}` : '';
     const label = item.status === 'error' ? `${C_ERROR}${item.tool}${RESET}` : `${C_ACCENT}${item.tool}${RESET}`;
+    // 2026-10-14 (leo: 「调用工具的时候, 把执行的命令缩写也附带上 —— 现在看不到过程」):
+    //   工具行附上参数摘要 (terminal→命令 / read_file→路径 / grep→pattern·dir), 灰色、截断;
+    //   看不清过程的问题 = 之前只有工具名, 不知道它具体跑了什么。
+    const sum = toolArgsSummary(item.tool, item.args);
+    const sumPart = sum ? ` ${C_DIM}${sum}${RESET}` : '';
     // 2026-10-01: 工具行也按**保守宽度**截断 —— 超宽会让终端折行、打乱 Ink 光标 (底栏那块就是这么坏的)
-    return truncateSafe(`  🔧 ${label}${dur}`, Math.max(20, (process.stdout.columns || 100) - 1));
+    return truncateSafe(`  🔧 ${label}${sumPart}${dur}`, Math.max(20, (process.stdout.columns || 100) - 1));
 }
 /** 紧凑渲染工具输出 (检测到 diff 则着色, 否则普通截断) — 当前不显示 body */
 export function renderToolCallBody(item, width = 72) {