@bolloon/bolloon-agent 0.5.3 → 0.5.5

package/dist/agents/pi-sdk.js

@@ -9,9 +9,26 @@
  *   - factory      → ./pi-sdk-session-factory.ts  (createAgentSession / getAgentSession / resetAgentSession / runSelfImproveLoop)
  *   - 本文件                                       (PiAgentSession 类: LLM 循环 / 系统提示 / 工具调用分发 / 压缩 / persistence)
  */
+import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { expandHomeArgs } from './tool-path-args.js';
+import { renderDelegateNotices, pushNotice, renderNoticeBlock } from './background-notices.js';
+import { runWithWriteOrigin } from './skill-ledger.js';
+import { createHash } from 'node:crypto';
+import { shouldReviewTask, runExperienceReview } from './experience-review.js';
+import { decideLessonSink, skillsFromDirs, logLessonSuggestions, routeLessonToSkill } from './lesson-to-skill.js';
+import { managedServices } from './managed-services.js';
+import { IterationBudget, isRefundableTool } from './iteration-budget.js';
+import { recordToolCall, argsFingerprint } from './tool-telemetry.js';
+import { capToolResult } from './tool-result-gate.js';
+import { renderToolListWithParams } from './tool-subset.js';
+import { codeWriteTarget, decideTypecheck, formatTypecheckResult } from './code-write-gate.js';
+// 2026-10-01: 身份解析必须**静态导入** —— 之前在函数体里用 require(), 而打包后是 ESM ⇒
+//   require 是 undefined ⇒ 抛错被 catch 静默吞掉 ⇒ "自愈"根本没跑, DID 一直是空的 ✗。
+import { loadOrCreateAgentIdentity } from './agent-identity.js';
+import { agentPersonaName } from './channel-identity.js';
 import { getContextManager } from '../bootstrap/context-manager.js';
 import { createRequire } from 'module';
 import { currentPackageRoot } from '../utils/version-info.js';
@@ -68,7 +85,7 @@ import { ReactHarness } from '../security/react-harness.js';
 import { HooksEngine } from '../hooks/hooks-engine.js';
 import { DenyPipeline } from './deny-pipeline.js';
 import { parseToolCall as parseToolCallImpl, parseAllToolCalls, isFinalResponse as isFinalResponseImpl, extractFinalAnswer as extractFinalAnswerImpl } from './parse-tool-call.js';
-import { buildObservation, buildReflection, formatObservationWithReflection } from './error-classifier.js';
+import { buildObservation, buildReflection, formatObservationWithReflection, classifyError } from './error-classifier.js';
 import { sessionStore as defaultSessionStore } from './session-store.js';
 import { ToolRegistry } from './tool-registry.js';
 import { decideMaxIterations, decideContextOverflow, shouldCompactBeforeIteration } from './react-loop.js';
@@ -130,6 +147,62 @@ export function writeBackCurrentTurnInto(history, wire) {
         return 0; // 写回失败绝不影响对话本身
     }
 }
+import { LoopStallState, observeToolCall, batchHint } from './tool-loop-guard.js';
+/**
+ * 写操作"读回自证" (2026-10-01 优化 #4): 写类工具成功后**自动**核一次, 把事实拼进结果。
+ * 为什么: 过程纪律写了"读回一次", 但**没人执行** ✗ ⇒ 现在由机制执行: "工具说成功 ≠ 任务成功"。
+ * 只做**便宜**的核对(存在性/大小); 失败静默(核对不该把工具搞失败)。
+ */
+export function verifyWriteOutcome(toolName, args, cwd) {
+    try {
+        const fsMod = require('node:fs');
+        const pathMod = require('node:path');
+        const WRITE = new Set(['write_file', 'edit_file', 'mkdir', 'move_file', 'copy_file']);
+        if (!WRITE.has(String(toolName)))
+            return null;
+        const rel = String(args?.path ?? args?.to ?? args?.dir ?? '').trim();
+        if (!rel)
+            return null;
+        const abs = pathMod.isAbsolute(rel) ? rel : pathMod.resolve(cwd, rel);
+        const st = fsMod.statSync(abs);
+        if (st.isDirectory())
+            return `[已核对] 目录存在: ${rel}`;
+        return `[已核对] 文件已落盘: ${rel} (${st.size} 字节, ${new Date(st.mtimeMs).toISOString()})`;
+    }
+    catch (e) {
+        return `[未核对] 读回失败: ${String(e?.message || e).slice(0, 80)} —— 别急着说"已完成", 先确认路径/权限`;
+    }
+}
+/**
+ * 过程纪律 (2026-10-01, 用户: 「智能体回复方式没有主动性 … 在过程里面更加主动考虑」)。
+ *
+ * 诊断: 系统提示里只有"理解→分析→调用→观察"这种**反应式**循环描述 ⇒ 模型容易"问一句答一句、
+ *   试一次就收尾、把方案当交付"。主动不是靠一句"请主动"能给的, 要落成**可判定的规矩**。
+ * 落地方式 (7 条, 都是"做/不做"能验收的): 先动手别先问 · 做到底别停在半成品 · 一个工具不够就换法继续 ·
+ *   工具说成功 ≠ 任务成功(读回验证) · 被阻塞如实说绝不编 · 每轮要么推进要么交付 · 顺手想影响面并给下一步建议。
+ */
+export const PROACTIVE_WORK_DISCIPLINE = `
+过程纪律 (比"答得漂亮"更重要, 逐条可判定):
+0. **先动手, 别先问**: 请求有显而易见的默认解释时, 按它做, 不要为了确认而停下 —— 只有"不同解释会让我做不同的事"时才问。
+0.5 **别把"主动"用在闲聊上**: 寒暄 / 感受 / 纯闲聊这类**没有任务**的消息 ⇒ 直接回答, **不要**为此调工具
+    (用户实测: 一句「你好」去跑了 git_status 花 4.1s ✗ —— 那是浪费)。"主动"= 接到任务后**想在你前面**,
+    不是"每句话都先把环境查一遍" ✗。
+1. **做到底**: 交付的是**能跑的东西 + 真实的工具输出**, 不是"我打算怎么做"。只写方案、只搭一半、只报告打算做什么, 都算没做完。
+2. **一个工具不够就换法继续**: 同一件事试到确实不通为止 —— 换参数/换命令/换路径/换工具接着试, 不要试一次就收尾。
+3. **工具说成功 ≠ 任务成功**: 写入/生成/发布这类动作, **读回一次**再声称完成(内容/存在/大小/哈希都可)。
+4. **被阻塞就如实说**: 讲清卡在哪一步、为什么、还缺什么; **绝不**用编造的结果顶替(编一个"看起来对"的输出比说"没做成"更糟)。
+5. **每一轮要么用工具推进, 要么给出结论**: 不要把"下一步我打算…"当成回答。
+6. **收尾时说三句**: 改了什么 · 验过什么(拿什么读到的) · 还剩什么。不重述过程。
+7.4 **技能是"要用时先读再照做"**: 库里有一批已装载技能(名字+说明), 用 list_skills <关键词> 找,
+    用 read_skill <名字> 读全文 —— **相关时先读它再动手**, 别凭印象做(技能里往往写着踩过的坑与判据 ✓)。
+7.5 **一轮里可以同时调多个独立工具** (并行执行已支持): 互不依赖的读取/查询**一次发出去**, 别一个一个来回 —
+    零碎调用既慢又费预算(批量工具还会退还额度 ✓)。
+7.6 **收尾标记的语义**(别猜, 就按这条): 写完那个结束标记 = "**我已收尾, 且自己验过**(改了什么/拿什么验证的), 请复核"。
+    只在这两种情况下写: ① 任务真的做完了(不是"我打算做") · ② 纯对话/问答也**不用**写(直接答即可)。
+    没做完就**别写** —— 写了会被当成"已完成"进入复核, 反而浪费一轮 ✓。
+7. **过程中主动考虑**: 动手前先想这个改动的**影响面**(同类调用点 · 相邻功能 · 已有数据/契约), 发现关联问题就说出来,
+   并给出你建议的下一步 —— 主动是指"想在你前面", 不是"多问几句"。
+`;
 export class PiAgentSession {
     cwd;
     peerId;
@@ -150,7 +223,51 @@ export class PiAgentSession {
     /** M2.4: 缓存 tool 列表, registerTools() 之后不变, runReActLoop 多次循环复用 */
     cachedToolDefinitions = '';
     /** M2.4: 缓存 persona section */
+    /**
+     * 当前活跃计划 (待办) 的**重注入段** (2026-10-01 落实④)。
+     * 每轮都带 —— 因为上下文压缩会把早先注入的计划文本丢掉, 一次性注入等于"压完就忘"。
+     * 有界 (条数/字符都封顶); 读不到就返回空串, 绝不影响主流程。
+     */
+    async renderActivePlansSection() {
+        // 2026-10-01: 后台委派的结果**自动回灌** —— 完成后的第一轮在这里给一行提示(只提一次)
+        let bg = '';
+        try {
+            bg = renderDelegateNotices();
+        }
+        catch { /* 提示失败不打断主流程 */ }
+        try {
+            const block = renderNoticeBlock(); // 通用回流(复盘产出/后台任务) —— 空闲排空 ⇒ 新一轮 ✓
+            if (block)
+                bg = bg ? `${bg}\n${block}` : block;
+        }
+        catch { /* 回流失败不打断 */ }
+        let plans = '';
+        try {
+            const { listActivePlans, formatPlansForPrompt } = await import('./plan-store.js');
+            const list = await listActivePlans();
+            plans = formatPlansForPrompt(list, { maxChars: 1200, maxItems: 3 });
+        }
+        catch {
+            return bg;
+        }
+        return bg ? `${bg}\n${plans}` : plans;
+    }
     cachedPersonaSection = '';
+    /** 本轮迭代预算 (每轮重置; 批处理工具会退还 —— 见 iteration-budget.ts) */
+    /** 上一个工具调用的参数指纹 (遥测判"是否重复调用") */
+    lastToolSig = null;
+    /** 最近一条用户消息 (按需子集档用来判 intent) */
+    lastUserIntent = '';
+    /** 本回合改过的 TS 文件 (回合收尾自动类型检查用) */
+    tsTouchedThisTurn = [];
+    /** 本回合是否已跑过类型检查 (一轮只跑一次) */
+    typecheckRanThisTurn = false;
+    iterBudget = null;
+    iterBudgetWarned = false;
+    /** 上一次已复盘的**任务签名** (签名变了 ⇒ 立刻复盘, 对应"每次任务都总结" ✓) */
+    lastReviewedTaskSig = undefined;
+    /** 上一次回合后自审的时间 (节流; 0 = 从未) */
+    lastExperienceReviewAt = 0;
     /** 2026-06-30: 持久化层 — 默认走 ~/.bolloon/sessions/cache/, 测试可注入临时目录. */
     _sessionStore;
     /** 构造期间 fire-and-forget 任务的 promise — whenReady() 等它 */
@@ -364,11 +481,41 @@ export class PiAgentSession {
         this.minimaxAvailable = this.checkMinimax();
         // 2026-07-04: 透传 agentId (server.ts 通过 createAgentSession 选项注入)
         this.currentAgentId = config.agentId || '';
+        // 2026-10-01 **身份自愈** (用户实测: get_identity 返回 "DID: " 空 + 各 channel 名字串台):
+        //   工具上下文里的身份来自 this.identity, 而它可能是 config.identityDoc 与 session 实例身份的
+        //   合并结果 —— **空 did 会盖掉真 did** ✗; 名字也可能缺失或被别处覆盖。
+        //   规矩: 缺 did / 名字时, 按 **currentAgentId** 从真身份生成器补齐 (did:key + 落盘密钥),
+        //   名字优先取该 agent 自己的 persona.json。绝不回落到全局/用户身份名。
+        try {
+            if (this.currentAgentId) {
+                const cur = this.identity || {};
+                const curDid = String(cur.did || '');
+                const badDid = !curDid || /^did:(local|pi):/i.test(curDid);
+                const missingName = !String(cur.name || '').trim();
+                // 2026-10-01 加固: **did 与本人密钥不符** 也算坏 —— 用户实测 get_identity 返回一个
+                //   数据里根本不存在的 did (按 peerId 当 scope 新造的), 而它非空、非假值 ⇒ 上一版判据漏过 ✗。
+                //   规矩: 只要 currentAgentId 有值, 身份的 did 就必须等于该 agent 自己的密钥 did。
+                const mine = loadOrCreateAgentIdentity(this.currentAgentId);
+                const mismatch = !!mine?.did && !!curDid && curDid !== mine.did;
+                if (badDid || missingName || mismatch) {
+                    if (badDid || mismatch) {
+                        console.warn(`[identity] 身份纠正: ${this.currentAgentId} 的 did ${curDid ? curDid.slice(0, 26) : '(空)'} ⇒ ${mine.did.slice(0, 26)} (以该 agent 自己的密钥为准)`);
+                    }
+                    // 2026-10-01: 同样必须**原地改** —— 这段在 registerTools() **之后**跑, 工具上下文已经按引用
+                    //   捕获了 this.identity; 换对象 ⇒ 工具看不到纠正结果 ✗ (同类 bug, 一并修)
+                    Object.assign(this.identity, {
+                        ...(mine?.did ? { did: mine.did, publicKey: mine.publicKey || cur.publicKey } : {}),
+                        ...(missingName ? { name: agentPersonaName(this.currentAgentId) || this.currentAgentId } : {}),
+                    });
+                }
+            }
+        }
+        catch { /* 自愈失败不致命 */ }
         // 2026-06-30: 持久化层可注入 — 测试传 tmpDir, 业务用默认 ~/.bolloon/sessions/cache/
         this._sessionStore = config.sessionStore ?? defaultSessionStore;
         this.constraintLayer = new ConstraintLayer();
         this.workflowEngine = new WorkflowEngine(this.constraintLayer);
-        this.sessionManager = new PiSessionManager(this.identity.did, this.cwd);
+        this.sessionManager = new PiSessionManager(this.identity.did, this.cwd, this.currentAgentId);
         this.agentsManager = new DiscoveredAgentsManager();
         this.usePivotLoop = config.usePivotLoop ?? false;
         this.pivotLoopConfig = config.pivotLoopConfig;
@@ -466,7 +613,13 @@ export class PiAgentSession {
             }
         }
         catch (err) {
-            console.warn(`[PiAgent] hydrateMessageHistory 失败 (non-fatal): ${err.message?.slice(0, 100)}`);
+            // 2026-09-30: "会话文件不存在" 不是失败 —— 新 channel / 还没落过盘的会话就是这种情况
+            //   (真机噪声: `hydrateMessageHistory 失败 (non-fatal): session not found: ch_bolloon:default`)。
+            //   只有**非** not-found 的错误才值得 warn。
+            const __msg = String(err?.message || err);
+            if (!/session not found|ENOENT/i.test(__msg)) {
+                console.warn(`[PiAgent] hydrateMessageHistory 失败 (non-fatal): ${__msg.slice(0, 100)}`);
+            }
         }
     }
     /**
@@ -600,6 +753,59 @@ export class PiAgentSession {
         this._inboxMessages = [];
         const toolCtx = {
             tools: this.tools,
+            // 2026-10-01 (用户: 「process 也要可以管理群聊和去中心化交流进程」):
+            //   把**常驻的交流类服务**也挂进 process —— 能启停的给启停(社交心跳 ✓), 只能看的如实标"仅状态" ✓(不假装能停 ✗)
+            managedServices: (() => {
+                const ms = managedServices;
+                ms.register({
+                    name: 'social-heartbeat',
+                    description: '社交心跳: 主动发现节点/发起对话/组织群聊的常驻循环(去中心化交流用)',
+                    status: () => (this.socialHeartbeat ? '运行中' : '已停止'),
+                    start: () => this.startSocialHeartbeat(),
+                    stop: () => this.stopSocialHeartbeat(),
+                });
+                ms.register({
+                    name: 'p2p-network',
+                    description: 'P2P 网络: 与其他 bolloon 节点的连接(群聊/消息都走它)',
+                    status: () => { try {
+                        const peers = this.getPeers?.() ?? [];
+                        return `已连接 ${peers.length} 个节点`;
+                    }
+                    catch {
+                        return '状态不可用';
+                    } },
+                });
+                ms.register({
+                    name: 'orbitdb-groups',
+                    description: 'OrbitDB 群聊存储: 本地群列表与消息持久化',
+                    status: () => { try {
+                        const g = this.listGroupsShallow?.();
+                        return g ? `本地群 ${g}` : '已就绪(用 /group 看列表)';
+                    }
+                    catch {
+                        return '状态不可用';
+                    } },
+                });
+                ms.register({
+                    name: 'document-receiver',
+                    description: '文档接收器: 监听并接收其他节点发来的文档分片',
+                    status: () => '监听中(随进程启动)',
+                });
+                return ms;
+            })(),
+            // 2026-10-01: 技能发现(list_skills / read_skill)的实现 —— 技能原先只注册不露面 ✗, 现在模型能自己找
+            listSkills: () => this.skillRegistry.list().map((sk) => ({ name: sk.name, description: String(sk.description || '') })),
+            getSkillBody: async (name) => {
+                const sk = this.skillRegistry.get(name);
+                if (!sk)
+                    return null;
+                try {
+                    return await sk.execute({});
+                }
+                catch {
+                    return null;
+                }
+            },
             cwd: this.cwd,
             identity: this.identity,
             persona: this.persona,
@@ -662,16 +868,18 @@ export class PiAgentSession {
         // 2026-07-29: 拒绝列表变化时清空缓存, 重新生成
         if (this.cachedToolDefinitions)
             return this.cachedToolDefinitions;
-        const defs = ['可用工具 (name(params) - 简介):'];
         // 2026-07-29: 使用 allowedTools() 过滤掉拒绝列表中的工具
-        for (const tool of this.allowedTools()) {
-            // 2026-06-19: 压缩 tool 定义 — 只显示参数名 (不显示描述, 减少 60% 长度)
-            //   完整 description 在 history 第一轮注入 (getToolDefinitionsFull 调用), 后续轮只看简短
-            //   避免 system prompt 太大导致 minimax 撞 max_tokens 输出空
-            const paramNames = Object.keys(tool.parameters).join(',');
-            defs.push(`- ${tool.name}(${paramNames})`);
-        }
-        this.cachedToolDefinitions = defs.join('\n');
+        const allowed = Array.from(this.allowedTools());
+        const header = '可用工具 (按类分组; name(params) - 简介):';
+        // 2026-06-19: 压缩 tool 定义 — 只显示参数名 (不显示描述, 减少 60% 长度)
+        //   完整 description 在 history 第一轮注入 (getToolDefinitionsFull 调用), 后续轮只看简短
+        //   避免 system prompt 太大导致 minimax 撞 max_tokens 输出空
+        // 2026-10-01 (优化 #2 v2): 按类**分组**列 + 说明"未列出的也能按名字调" ⇒ 治选择过载, 且不丢能力。
+        //   BOLLOON_TOOL_SUBSET=on 时改走"按 intent 只展开相关桶"(仍带 list_tools + 能力提示 ✓)。
+        const subsetOn = String(process.env.BOLLOON_TOOL_SUBSET || '').toLowerCase() === 'on';
+        const intentText = subsetOn ? this.lastUserIntent : '';
+        const rendered = renderToolListWithParams(allowed, intentText, { subset: subsetOn, perBucket: 14 });
+        this.cachedToolDefinitions = `${header}\n${rendered.text}`;
         return this.cachedToolDefinitions;
     }
     async initSession() {
@@ -683,12 +891,28 @@ export class PiAgentSession {
         }
     }
     createDefaultIdentity() {
-        return {
-            did: `did:pi:${this.peerId.substring(0, 16)}`,
-            name: `Agent-${this.peerId.substring(0, 8)}`,
-            publicKey: this.peerId,
-            createdAt: Date.now()
-        };
+        // 2026-10-01: 原先自造 `did:pi:<peerId>` —— **不是有效 DID** (仓里 server.ts 自己都把 did:pi:
+        //   当"待升级"占位; 用户实测 get_identity 报 did:pi:ch_1785668060213)。
+        //   改用仓里既有的真身份生成器 (agent-identity.loadOrCreateAgentIdentity, 同步, 产 did:key + 落盘密钥)。
+        const scope = this.currentAgentId || this.peerId || 'default';
+        try {
+            const real = loadOrCreateAgentIdentity(scope);
+            return {
+                did: real.did,
+                name: `Agent-${this.peerId.substring(0, 8)}`,
+                publicKey: real.publicKey || this.peerId,
+                createdAt: Date.now(),
+            };
+        }
+        catch {
+            // 真身份生成失败时**不编假 DID**: 如实留空, 由 /did 与 get_identity 报"未绑定"
+            return {
+                did: '',
+                name: `Agent-${this.peerId.substring(0, 8)}`,
+                publicKey: this.peerId,
+                createdAt: Date.now(),
+            };
+        }
     }
     checkMinimax() {
         try {
@@ -904,6 +1128,106 @@ export class PiAgentSession {
         try {
             // 2026-06-16: runReActLoop 现在返回 { reply, aiFailed, aiFailureReason } — 这里只需 reply 字符串
             const loopResult = await this.runReActLoop(this.currentOnStream ?? undefined, options?.signal);
+            // 2026-10-01: **本回合改过 TS ⇒ 收尾自动类型检查** (一轮一次) —— 复用已有的 tsc_check 工具
+            if (decideTypecheck(this.tsTouchedThisTurn, this.typecheckRanThisTurn)) {
+                this.typecheckRanThisTurn = true;
+                try {
+                    const tscTool = this.tools.get('tsc_check');
+                    if (tscTool?.execute) {
+                        const r = await tscTool.execute({});
+                        const line = formatTypecheckResult(r?.success !== false && !/error TS\d+/.test(String(r?.output || '')), String(r?.output || ''));
+                        this.currentOnStream?.({ type: 'status', content: `🔎 ${line}`, tool: 'system' });
+                    }
+                }
+                catch (e) {
+                    this.currentOnStream?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
+                }
+                this.tsTouchedThisTurn = [];
+            }
+            // 2026-10-01: **回合后自审 (纯旁路)** —— 沉淀可复用经验, 对应"结束后沉淀"那一段。
+            //   纪律: fire-and-forget (不阻塞主回合) · 只写 ~/.bolloon/experience/ (**不碰主对话/prompt 缓存**)
+            //        · 节流 (默认 10 分钟/agent) · 失败只记一行日志, 绝不影响本回合结果。
+            try {
+                const reviewNow = Date.now();
+                const turnSummary = `用户: ${String(this.currentUserInput || '').slice(0, 2000)}\n助手: ${String(loopResult?.reply || '').slice(0, 4000)}`;
+                // 任务签名: 用户这次要的东西 + 用了哪些工具 ⇒ 换任务立刻复盘(同一任务才节流) ✓
+                const taskSig = createHash('sha256')
+                    .update(`${String(this.currentUserInput || '').slice(0, 300)}|${this.totalToolCallsThisTurn || ''}`)
+                    .digest('hex').slice(0, 12);
+                if (shouldReviewTask(reviewNow, this.lastExperienceReviewAt, this.lastReviewedTaskSig, taskSig)) {
+                    this.lastExperienceReviewAt = reviewNow; // 先记账, 免得多路并发各起一次
+                    this.lastReviewedTaskSig = taskSig;
+                    // 2026-10-01 (用户: 「我没有看到执行完命令后 bolloon 知道选中更新 skills，是不是没有触发」):
+                    //   实测**确实没触发** ✓ —— 两个原因: ① 被调方又自己判了一次节流 ⇒ 换任务也被 throttled 掉 ✗;
+                    //   ② 反馈走 `console.warn`(TUI 里被吞 ✗) + `void … .catch(() => {})`(失败无声 ✗)
+                    //   ⇒ 你什么都看不到 ✓。现在: 传 force 尊重调用方的决定 ✓ · 复盘过程/结果/失败**都进对话流** ✓ ·
+                    //   同时落一份 `~/.bolloon/logs/experience-review.log` 供事后核 ✓。
+                    const reviewLog = (m) => {
+                        const line = `[${new Date().toISOString()}] ${m}`;
+                        try {
+                            const p = path.join(os.homedir(), '.bolloon', 'logs', 'experience-review.log');
+                            void fs.mkdir(path.dirname(p), { recursive: true })
+                                .then(() => fs.appendFile(p, line + '\n'))
+                                .catch(() => { });
+                        }
+                        catch { /* 落日志失败不影响主流程 */ }
+                        try {
+                            this.currentOnStream?.({ type: 'status', content: `📚 复盘: ${m}`, tool: 'system' });
+                        }
+                        catch { /* 上屏失败不打断 */ }
+                    };
+                    reviewLog('开始(换了任务 ⇒ 立刻复盘)');
+                    void runExperienceReview({
+                        turnSummary,
+                        force: true,
+                        chat: async (prompt) => {
+                            const r = await getMinimax().chat(prompt);
+                            return typeof r === 'string' ? r : String(r?.content ?? r?.text ?? '');
+                        },
+                        log: reviewLog,
+                        // 2026-10-01: 写了经验之后再找"能沉淀进哪个已有技能"的候选 —— **只记候选, 不自动改技能** ✓
+                        //   (实测: 拿真实教训撞真实 1300 个技能, 最高分只有 2 且 top 命中是瞎的 ✗ ⇒ 不替人决定 ✓)
+                        onLesson: (lesson) => {
+                            try {
+                                // ⓐ 管理: 找"能沉淀进哪个已有技能"的候选(只记, 不自动改 ✗)
+                                const dirs = defaultSkillPaths(os.homedir(), process.cwd());
+                                const decision = decideLessonSink(lesson, skillsFromDirs(dirs));
+                                logLessonSuggestions(lesson, decision);
+                                // ⓐ' 用户要求「**都进去**」⇒ 每条教训都落进技能库: 强命中写那个技能 ✓, 否则写沉淀技能 `lessons-learned` ✓
+                                // 2026-10-01 **写来源隔离**: 复盘/自审产生的写, 打上 review 标记 ✓ ⇒
+                                //   它只许治理**自己造出来**的技能 ✓(用户在 skills 里点名要的归用户 ✓)
+                                runWithWriteOrigin('review', () => routeLessonToSkill(lesson, skillsFromDirs(dirs)));
+                                // 2026-10-01 (用户: 「复盘任务能否触发 loop?」): 教训**回流成下一轮的任务源** ✓ ——
+                                //   只"记下来"等于闭环断在这 ✗; 投进共享队列 ⇒ 空闲时排空 ⇒ 以**新一轮**浮现 ✓(绝不中途插队 ✓)。
+                                try {
+                                    pushNotice('review', `${lesson.title} —— ${String(lesson.body || '').replace(/\s+/g, ' ').slice(0, 120)}`);
+                                }
+                                catch { /* 回流失败不打断 */ }
+                                // ⓑ 接入**判断力系统**: 同一条教训也进 HumanJudgment(带 source/confidence/revisable ⇒ 可被后续演化取代 ✓)
+                                //    这样经验库与判断力库**同一份来源**, 判断力注入(gate)时就能用上 ✓
+                                import('../pi-ecosystem-judgment/human-value-store.js').then((m) => m.storeHumanJudgment({
+                                    decision: lesson.title,
+                                    decision_type: 'modify',
+                                    reasons: [lesson.body],
+                                    values_derived: [],
+                                    context: { domain: lesson.klass || 'general', complexity: 'simple', stakes: 'medium', time_pressure: 'low' },
+                                    outcome: { approved: true },
+                                    metadata: { source: 'trajectory', confidence: 0.7, revisable: true },
+                                })).catch(() => { });
+                            }
+                            catch { /* 这一段整体是锦上添花, 绝不外泄错误 */ }
+                        },
+                    }).then((r) => {
+                        // 结果**如实上屏** ✓: 审没审 / 写没写 / 为什么没写 —— 不再无声 ✓
+                        reviewLog(r?.reviewed
+                            ? (r?.applied ? `已沉淀经验 ✓${r?.file ? ` → ${path.basename(String(r.file))}` : ''}` : `审了但没写: ${r?.reason || '无'}`)
+                            : `没审: ${r?.reason || '无'}`);
+                    }).catch((e) => {
+                        reviewLog(`失败(已如实记录, 不外泄错误): ${String(e?.message || e).slice(0, 160)}`);
+                    });
+                }
+            }
+            catch { /* 挂点自身失败也不影响主流程 */ }
             this.finishTrajectory(trajRec, loopResult.reply, loopResult.aiFailed ? 'error' : 'ok');
             return loopResult.reply;
         }
@@ -1262,6 +1586,10 @@ ${this.getToolDefinitions()}
 
 ${PiAgentSession.TOOL_SELECTION_GUIDE}
 
+${PROACTIVE_WORK_DISCIPLINE}
+
+${await this.renderActivePlansSection()}
+
 工作模式:
 1. 理解用户自然语言请求
 2. 分析需要哪些工具来完成
@@ -1546,6 +1874,9 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         const MAX_TOOL_CALLS_PER_LOOP = 25; // 单轮循环总工具调用上限 → 注入 hint
         let totalToolCallsThisLoop = 0;
         const lastNTools = []; // 最近 MAX_IDEMPOTENT_TOOL 次工具名, 检测重复
+        // 2026-10-01: 工具停滞观测状态 (分类 + 温和引导 + 重复结果引用) —— 见 agents/tool-loop-guard.ts
+        //   与上面的"同工具 5 次就提示"不同: 它按 (工具名 + 参数 + 结果) 签名判定, 并抓 A→B→A→B 的循环
+        const stallState = new LoopStallState();
         // 2026-08-10: unreported 循环逃生门 — LLM 反复不把工具结果写进回复时, 3 次后强制 final (不死板)
         const MAX_UNREPORTED_RETRIES = 3;
         let unreportedRetries = 0;
@@ -1710,7 +2041,18 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             }
             // 停止条件 1: max turns (fail-safe 10000, 正常任务永远跑不到)
             //   2026-07-01 (v0.2.4 子任务 1): 委托给 react-loop.decideMaxIterations 纯函数
-            const maxIterDecision = decideMaxIterations(iteration, this.MAX_REACT_ITERATIONS);
+            // 2026-10-01 (落实②: 可退还的迭代预算): 惩罚零碎调用, **奖励批处理** ——
+            //   程序化工具(execute_code, 一次能顶多次)调用后归还一次迭代 ⇒ 有效寿命被延长。
+            //   退出条件仍由 decideMaxIterations 决定(读**净**用量), 不做硬刹车。
+            if (iteration === 0 || !this.iterBudget)
+                this.iterBudget = new IterationBudget(this.MAX_REACT_ITERATIONS);
+            const iterBudget = this.iterBudget;
+            iterBudget.consume();
+            if (iterBudget.warn(0.8) && !this.iterBudgetWarned) {
+                this.iterBudgetWarned = true;
+                onStream?.({ type: 'status', internal: true, content: `⏳ 迭代预算已用 ${iterBudget.describe()} (批量工具会退还)` });
+            }
+            const maxIterDecision = decideMaxIterations(iterBudget.used, iterBudget.maxTotal);
             if (maxIterDecision.shouldExit) {
                 console.warn(`[PiAgent] 达到最大循环数 ${this.MAX_REACT_ITERATIONS}, 强制终止 (fail-safe)`);
                 onStream?.({ type: 'error', content: `⏹️ 达到最大循环数 (${this.MAX_REACT_ITERATIONS}, fail-safe)`, tool: 'loop' });
@@ -1839,6 +2181,10 @@ ${toolDefs}
 
 ${PiAgentSession.TOOL_SELECTION_GUIDE}
 
+${PROACTIVE_WORK_DISCIPLINE}
+
+${await this.renderActivePlansSection()}
+
 工作模式:
 1. 理解用户自然语言请求
 2. 分析需要哪些工具来完成
@@ -2149,7 +2495,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         }
                         let result = replaySkip
                             ? { success: true, output: `[恢复保护] ${toolCall.name} 在中断前已成功执行过, 本次不重复执行 (避免重复副作用)。当时结果: ${replaySkip}`, _replaySkipped: true }
-                            : await tool.execute(toolCall.args);
+                            : await (toolCall.__t0 = Date.now(), tool.execute(expandHomeArgs(toolCall.args)));
                         const toolDurationMs = Date.now() - toolStart;
                         if (replaySkip) {
                             console.log(`[PiAgent] 恢复重放守卫: 跳过已完成的非幂等工具 ${toolCall.name}`);
@@ -2208,7 +2554,39 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             console.warn(`[PiAgent] Harness output denied ${toolCall.name}: ${after.outputBlocked.reason}`);
                             result = { ...result, output: `[harness output gate: 输出含敏感内容, 已屏蔽. 原因: ${after.outputBlocked.reason}]`, _harnessDenied: true };
                         }
+                        // 2026-10-01: 落库前做一次停滞观测 —— 命中的是"引导/引用", 不是"拒绝执行":
+                        //   完全相同的返回从第 2 次起折叠成引用 (省上下文); 连续 3 次同参数同结果或检测到循环 ⇒
+                        //   在结果尾部追加一条系统提示 (保留模型的选择权, 不硬停 —— 硬停那条已被用户否决)。
+                        try {
+                            const obs = observeToolCall(stallState, {
+                                toolName: toolCall.name,
+                                sameSignatureBefore: this.lastToolSig === argsFingerprint(toolCall.args),
+                                args: toolCall.args,
+                                resultText: String(result.output || (result.success ? '' : String(result.error || ''))),
+                                ok: !!result.success,
+                                seenResultBefore: stallState.hasSeenResult(String(result.output || '')),
+                            });
+                            if (obs.stub) {
+                                result = { ...result, output: obs.stub, _stubbed: true };
+                            }
+                            else if (obs.notice) {
+                                result = { ...result, output: `${String(result.output || '')}\n\n${obs.notice}` };
+                            }
+                            if (obs.action === 'warn') {
+                                console.warn(`[PiAgent] 工具停滞引导 (${obs.code}, 第 ${obs.count} 次): ${toolCall.name}`);
+                                onStream?.({ type: 'status', internal: true, content: `🩺 检测到重复调用 ${toolCall.name} (${obs.code}), 已提示模型换法`, tool: 'loop' });
+                            }
+                        }
+                        catch { /* 观测失败绝不影响主路径 */ }
                         this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result, toolCallId: toolCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}` });
+                        // 2026-10-01 (用户: 「为什么这么慢」): 量到的事实 —— 每次 LLM 往返平均 3338ms,
+                        //   而"一轮发多个工具"(toolCalls>1) 只占 12/63 ✗ ⇒ 回合时长 ≈ 往返次数 × 3.3 秒 ✓。
+                        //   本回合**第一次**且**只发一个**工具时, 附一句带代价的提醒(不是口号 ✓), 只提一次免得刷屏。
+                        if (toolCalls.length === 1 && this.successfulToolResults.length <= 1) { // 本回合头一次(免得每轮刷屏)
+                            const __batchHint = batchHint(toolCall.name, 1);
+                            if (__batchHint)
+                                this.messageHistory.push({ role: 'system', content: __batchHint.trim() });
+                        }
                         this.logToHarness(toolCall.name, toolCall.args, result);
                         // 2026-08-09: 记录到本轮行动日志 (循环进度 + final 前目标核查用)
                         //   去重: 同一工具同 args 连续成功只记一次 (防 LLM 重复 react 刷屏)
@@ -2237,10 +2615,48 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                                 onStream({ type: 'step_error', content: `${toolCall.name} 执行失败`, tool: toolCall.name, error: result.error });
                             }
                         }
+                        // 2026-10-01 (优化 #1/#3/#4): 工具结果的**进上下文闸** + **遥测** + **写操作读回自证**
+                        {
+                            const __ms = Date.now() - Number(toolCall.__t0 || Date.now());
+                            try {
+                                // #1 结果闸: 超上限 ⇒ 头尾 + 完整结果落文件(给路径) ⇒ 上下文不再被一条大输出长期占住
+                                const capped = capToolResult(String(result.output ?? ''), { tool: toolCall.name });
+                                if (capped.capped) {
+                                    result.output = capped.text;
+                                    console.warn(`[PiAgent] ${toolCall.name} 结果过长(${capped.originalChars})已截断` + (capped.spilledTo ? `, 完整内容: ${capped.spilledTo}` : ''));
+                                }
+                                // #4 写操作"读回自证": 写类工具成功后自动核一次(存在? 大小?) ⇒ "工具说成功≠任务成功"从规矩变成机制
+                                // 2026-10-01: 改了 TS 源码就记账 ⇒ 回合收尾自动跑类型检查 (把"靠自觉"变成机制)
+                                {
+                                    const tsFile = codeWriteTarget(toolCall.name, toolCall.args);
+                                    if (tsFile && !this.tsTouchedThisTurn.includes(tsFile))
+                                        this.tsTouchedThisTurn.push(tsFile);
+                                }
+                                const verified = verifyWriteOutcome(toolCall.name, toolCall.args, this.cwd);
+                                if (verified)
+                                    result.output = `${String(result.output ?? '')}\n${verified}`;
+                                // #3 遥测: 记一行(工具/指纹/耗时/成败/结果大小/是否与上一次同签名) ⇒ 重复率可算
+                                recordToolCall({
+                                    tool: toolCall.name,
+                                    sig: argsFingerprint(toolCall.args),
+                                    ms: __ms,
+                                    ok: true,
+                                    resultChars: String(result.output ?? '').length,
+                                    prevSig: this.lastToolSig ?? null,
+                                });
+                                this.lastToolSig = argsFingerprint(toolCall.args);
+                            }
+                            catch { /* 任何优化项失败都不影响工具结果本身 */ }
+                        }
                         if (result.success) {
                             consecutiveErrors = 0;
                             // 2026-07-29: Hermes 风格硬限制计数
                             totalToolCallsThisLoop++;
+                            // 2026-10-01: 批处理工具(一次顶多次) ⇒ **退还**这次迭代 (奖励批处理, 压零碎调用)
+                            if (this.iterBudget && isRefundableTool(toolCall.name)) {
+                                this.iterBudget.refund();
+                                console.warn(`[PiAgent] ${toolCall.name} 是批量工具 ⇒ 退还 1 次迭代 (现 ${this.iterBudget.describe()})`);
+                            }
                             lastNTools.push(toolCall.name);
                             if (lastNTools.length > MAX_IDEMPOTENT_TOOL)
                                 lastNTools.shift();
@@ -2261,6 +2677,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         }
                         else {
                             consecutiveErrors++;
+                            // 2026-10-01 (优化 #3): 失败也记一行(带错误类别) ⇒ "错工具率"从这类错误里看得出来
+                            try {
+                                const __cls = classifyError(String(result.error || '')).label || '未分类';
+                                recordToolCall({ tool: toolCall.name, sig: argsFingerprint(toolCall.args), ms: 0,
+                                    ok: false, resultChars: 0, prevSig: this.lastToolSig ?? null, errorClass: __cls });
+                                this.lastToolSig = argsFingerprint(toolCall.args);
+                            }
+                            catch { /* 遥测失败不影响 */ }
                             totalErrors++;
                             if (toolCall.name === lastFailedTool) {
                                 lastFailedToolCount++;
@@ -2797,7 +3221,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 //   currentTurnContext 是调用方自己的当前轮易变段 (循环进度/改进提示), 走 CURRENT TURN 区.
                 // 2026-09-28: 回带最终 wire messages (含注入后的当前轮) → 上层据此写回 messageHistory.
                 const response = await llm.chat(contextOrMessages, systemPrompt, signal, tools, 'main-agent', 'react-loop', undefined, currentTurnContext);
-                // 2026-06-30: 透传 toolCalls (OpenAI 协议 native) 给上层, 让 assistant message 能 emit 真 id
+                // 2026-10-01 (用户: 「思考的记录可以也显示出来吗」): 思考模型的思维链原先只被"存起来回带",
+                //   **不显示** ✗。这里把它往流里送一份 —— 显示与否由 CLI 侧决定(BOLLOON_SHOW_THINKING, 默认显示) ✓。
+                try {
+                    const rc = String(response?.reasoningContent || '').trim();
+                    if (rc)
+                        this.currentOnStream?.({ type: 'reasoning', content: rc });
+                }
+                catch { /* 送不出去不影响主流程 */ } // 2026-06-30: 透传 toolCalls (OpenAI 协议 native) 给上层, 让 assistant message 能 emit 真 id
                 return { reply: response.reply || '', toolCalls: response.toolCalls, messages: response.messages };
             }
             catch (err) {
@@ -3343,7 +3774,13 @@ ${this.extractOperationsFromRef(operationsRef)}
         return { ...this.identity };
     }
     updateIdentity(updates) {
-        this.identity = { ...this.identity, ...updates };
+        // 2026-10-01 **修切换频道后身份不换的根因**: 上一版是 `this.identity = { ...this.identity, ...updates }`
+        //   —— **换成新对象** ✗。而工具上下文是在 registerTools() 时按**对象引用**捕获的 (`identity: this.identity`),
+        //   并且切频道时 session 是**复用**的(pi-sdk-session-factory 的模块级单例, 只调 updateIdentity) ⇒
+        //   工具里的 ctx.identity 一直指向**旧对象** ⇒ `get_identity` 永远返回上一个频道的身份 ✗✗
+        //   (实测: xiaomi/智能体频道都答「233 的 DID + 小龙」, 因为 233 是进程启动时的频道)。
+        //   ⇒ 改成**原地改**: 所有持有者(工具上下文/会话/状态栏)都看到同一个对象的新值 ✓。
+        Object.assign(this.identity, updates);
     }
     setCurrentChannelId(channelId) {
         this.currentChannelId = channelId;
@@ -3359,6 +3796,17 @@ ${this.extractOperationsFromRef(operationsRef)}
     }
     async setPersona(persona) {
         await this.sessionManager.savePersona(persona);
+        // 2026-10-01: **写透** —— 有身份文档的 agent 不套 persona.json, 只写 JSON 等于没改
+        //   (用户报"每次让智能体改都是同一个") ⇒ 同步落进它自己的身份文档 (标记区内)
+        if (this.currentAgentId) {
+            try {
+                const { applyPersonaToDocs } = await import('../bootstrap/persona-init.js');
+                const wrote = await applyPersonaToDocs(this.currentAgentId, persona);
+                if (wrote.length)
+                    console.warn(`[persona] 已把 ${this.currentAgentId} 的 persona 写进身份文档: ${wrote.join(' · ')}`);
+            }
+            catch { /* 非致命 */ }
+        }
         this.persona = persona;
         if (persona.name) {
             this.identity.name = persona.name;