@bolloon/bolloon-agent 0.2.9 → 0.2.11

package/dist/agents/pi-sdk.js

@@ -19,7 +19,7 @@ import { getBranchPrefix, getCooldownMs, checkWritePath } from './shell-guard.js
 import { DiscoveredAgentsManager, createSocialHeartbeat } from '../social/heartbeat.js';
 import { getGlobalSharedContext } from '../social/global-shared-context.js';
 import { Session, SkillRegistry, saveSession, loadSession } from '@bolloon/constraint-runtime';
-import { loadSkillsFromPaths, defaultSkillPaths } from './skill-loader.js';
+import { loadSkillsFromPaths, defaultSkillPaths, describeSkill } from './skill-loader.js';
 // Judgment 注入门 (P0): 在主对话 LLM 调起前自动拼入 Top 3 判断力
 // 失败静默, 不阻塞主对话
 import { injectJudgmentGate, recordJudgmentUsage } from '../pi-ecosystem-judgment/injection-gate.js';
@@ -31,10 +31,6 @@ import { onPostToolUse } from '../bootstrap/lifecycle-hooks.js';
 import { budgetReduce, snip, microcompact } from '../context-compaction/index.js';
 // React Harness: 8-gate + 4-guard (防越权 / 防 prompt 注入)
 import { ReactHarness } from '../security/react-harness.js';
-import { parseToolCall as parseToolCallImpl, isFinalResponse as isFinalResponseImpl, extractFinalAnswer as extractFinalAnswerImpl } from './parse-tool-call.js';
-import { sessionStore as defaultSessionStore } from './session-store.js';
-import { ToolRegistry } from './tool-registry.js';
-import { decideMaxIterations, decideContextOverflow, shouldCompactBeforeIteration } from './react-loop.js';
 const SHARED_SESSION_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
 const PERSONA_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'persona.json');
 export class PiSessionManager {
@@ -321,18 +317,18 @@ export class PiSessionManager {
         await this.sharedContext.updateAgentStatus(this.agentId, status);
     }
 }
-const TOOL_DEFINITIONS = `
-可用工具:
-1. read_document(path) - 读取文档内容，支持 .txt, .md, .pdf, .docx
-2. summarize_document(path, context?) - 总结文档内容，可选提供上下文
-3. improve_document(path, requirements) - 改进文档，需提供文件路径和改进要求
-4. list_peers() - 列出已连接的对等节点
-5. send_message(peer_id, message) - 向指定对等节点发送消息
-6. broadcast_message(message) - 向所有对等节点广播消息
-7. get_identity() - 获取当前智能体身份信息
-8. set_persona(persona_json) - 更新智能体 persona，包含 name、description、personality、greeting 等
-9. run_workflow(steps) - 执行预定义工作流
-10. get_operation_logs() - 获取操作日志
+const TOOL_DEFINITIONS = `
+可用工具:
+1. read_document(path) - 读取文档内容，支持 .txt, .md, .pdf, .docx
+2. summarize_document(path, context?) - 总结文档内容，可选提供上下文
+3. improve_document(path, requirements) - 改进文档，需提供文件路径和改进要求
+4. list_peers() - 列出已连接的对等节点
+5. send_message(peer_id, message) - 向指定对等节点发送消息
+6. broadcast_message(message) - 向所有对等节点广播消息
+7. get_identity() - 获取当前智能体身份信息
+8. set_persona(persona_json) - 更新智能体 persona，包含 name、description、personality、greeting 等
+9. run_workflow(steps) - 执行预定义工作流
+10. get_operation_logs() - 获取操作日志
 `;
 class PiAgentSession {
     cwd;
@@ -348,17 +344,11 @@ class PiAgentSession {
     socialHeartbeat = null;
     messageHistory = [];
     tools = new Map();
-    /** 2026-06-30: tool registry 模块 — 独立 alias resolve, 测试可消融. */
-    _toolRegistry = new ToolRegistry();
     skillRegistry = new SkillRegistry();
     /** M2.4: 缓存 tool 列表, registerTools() 之后不变, runReActLoop 多次循环复用 */
     cachedToolDefinitions = '';
     /** M2.4: 缓存 persona section */
     cachedPersonaSection = '';
-    /** 2026-06-30: 持久化层 — 默认走 ~/.bolloon/sessions/cache/, 测试可注入临时目录. */
-    _sessionStore;
-    /** 构造期间 fire-and-forget 任务的 promise — whenReady() 等它 */
-    _readyPromise = null;
     // 2026-06-16 修: 父要求把 ReAct loop 上限放大到 "几乎无限", 靠自动压缩上下文 + fail-safe 兜底
     // 默认 10000 — 正常任务永远跑不到, 但作为防 LLM 死循环 / 防 OOM 的最后一道闸
     // 旧默认 100 写死导致中等复杂度任务 (10-50 个 tool call + 多步反思) 会被误杀
@@ -370,10 +360,6 @@ class PiAgentSession {
     /** 2026-06-16 新增: 累计错误总数兜底 (不管是否同工具, 累计 N 次就强制退出)
      *  防 LLM 轮换工具名绕开 MAX_SAME_TOOL_FAILURES 的死循环攻击 */
     MAX_TOTAL_ERRORS = 20;
-    /** 2026-06-19: 记录 loop 内成功执行的工具结果, 失败退出时汇总给用户 */
-    successfulToolResults = [];
-    /** 2026-06-19: Agent Mesh 通信 — 本地 + 远端 inbox 缓存, 给 check_inbox 工具读 */
-    _inboxMessages = [];
     /** 2026-06-16 新增: loop 内自动压缩触发阈值 (相对 60K 阈值的比例) */
     LOOP_COMPACT_RATIO = 0.8;
     /** P1: max output token 升级重试 (LLM 截断时重试, 最多 3 次) */
@@ -396,9 +382,6 @@ class PiAgentSession {
      */
     judgmentGateAddition = '';
     judgmentGateUsedIds = [];
-    // 2026-06-18: 来自 web server markedPrompt 外的 contextHint (channel/judgment/distill/remote channels),
-    //   拼到 systemPrompt 末尾, 别再混进 user message
-    contextHintAddition = '';
     /**
      * 当前 onStream 引用 + abort signal (computeJudgmentGate 需要 onStream 广播 phase)
      * 每次 prompt / promptStream / promptWithPivotLoop 入口设置, 用完即清
@@ -411,8 +394,6 @@ class PiAgentSession {
     promptStartTime = 0;
     /** 当前 channel id (由 getAgentForChannel / prompt 4 参注入, 供 hook / log 使用) */
     currentChannelId = '';
-    /** 2026-07-04: 当前 agentId (server.ts 通过 createAgentSession 选项注入), 供 onSessionStart 加载 persona docs */
-    currentAgentId = '';
     /** M2.2 (2026-06-17): 当前轮的用户请求 intent, runReActLoop 拼 systemPrompt 时会读这个 */
     currentIntent = 'chitchat';
     currentIntentHint = '';
@@ -456,10 +437,6 @@ class PiAgentSession {
         this.peerId = config.peerId || 'local';
         this.identity = config.identityDoc || this.createDefaultIdentity();
         this.minimaxAvailable = this.checkMinimax();
-        // 2026-07-04: 透传 agentId (server.ts 通过 createAgentSession 选项注入)
-        this.currentAgentId = config.agentId || '';
-        // 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);
@@ -475,37 +452,38 @@ class PiAgentSession {
         //   之前 messageHistory 是空的, 服务重启后 LLM 看到的是新对话
         //   现在 loadSessionKey 形如 "channel-xxx:default" 走 ~/.bolloon/sessions/cache/<key>.json
         if (config.loadSessionKey) {
-            this._readyPromise = this.hydrateMessageHistory(config.loadSessionKey, config.loadSessionMaxMessages ?? 30).catch((err) => {
-                // 失败静默, 但不让 whenReady 永久 hang
-                console.warn(`[PiAgent] hydrateMessageHistory failed: ${err.message?.slice(0, 100)}`);
-            });
+            this.hydrateMessageHistory(config.loadSessionKey, config.loadSessionMaxMessages ?? 30);
         }
     }
     /**
-     * 2026-06-30: 让外部 await 构造期间的 hydrate 完成.
-     * 解决 fire-and-forget 让 messageHistory 不可预测的问题.
-     * 不传 loadSessionKey 时立即返回.
-     */
-    whenReady() {
-        return this._readyPromise ?? Promise.resolve();
-    }
-    /**
-     * M2.3 (2026-06-30 重构): 从 SessionStore 加载历史, 转成 messageHistory 格式
+     * M2.3: 从 session JSON 加载历史, 转成 messageHistory 格式
      * - 失败静默 (历史加载失败不应该阻塞 agent 启动)
      * - 限制 max 条数, 防止 context 爆
-     * - 跳过错误消息 ([AI 服务调用失败] / [错误:...]) 不污染 LLM
-     * - 委托 SessionStore 完成 IO, 保证 save/load 路径对称
-     *
-     * 历史格式兼容旧 schema ({type, content}) 和新 schema (PersistedMessage[])
+     * - user 消息 role=user, ai 消息 role=assistant
+     * - 跳过 metadata 中含 error 的 (错误消息会污染 LLM)
      */
     async hydrateMessageHistory(sessionKey, maxMessages) {
         try {
-            const loaded = await this._sessionStore.loadMessages(sessionKey);
-            if (!loaded) {
-                console.log(`[PiAgent] hydrate: 没有 ${sessionKey} 的历史`);
-                return;
+            const sessionPath = path.join(os.homedir(), '.bolloon', 'sessions', 'cache', `${sessionKey}.json`);
+            const content = await fs.readFile(sessionPath, 'utf-8');
+            const session = JSON.parse(content);
+            const messages = Array.isArray(session?.messages) ? session.messages : [];
+            // 保留最后 N 条, 转换 role 字段
+            const tail = messages.slice(-maxMessages);
+            const hydrated = [];
+            for (const m of tail) {
+                // 跳过错误的 AI 消息 (M1.2 之后, AI 错误时 reply 是 [AI 服务调用失败] 字符串, 不该进 history)
+                if (m?.type === 'ai' && typeof m.content === 'string' && m.content.startsWith('[AI 服务调用失败]'))
+                    continue;
+                if (m?.type === 'ai' && typeof m.content === 'string' && m.content.startsWith('[错误:'))
+                    continue;
+                if (!m?.content)
+                    continue;
+                const role = m.type === 'user' ? 'user' : m.type === 'ai' ? 'assistant' : null;
+                if (!role)
+                    continue;
+                hydrated.push({ role, content: String(m.content) });
             }
-            const hydrated = this._filterToMessage(loaded).slice(-maxMessages);
             if (hydrated.length > 0) {
                 this.messageHistory = hydrated;
                 console.log(`[PiAgent] 从 ${sessionKey} 回灌 ${hydrated.length} 条历史`);
@@ -515,84 +493,6 @@ class PiAgentSession {
             console.warn(`[PiAgent] hydrateMessageHistory 失败 (non-fatal): ${err.message?.slice(0, 100)}`);
         }
     }
-    /**
-     * 2026-06-30: 把当前 messageHistory 持久化到 SessionStore.
-     * 公开方法 — claude code / 外部 harness 在每次 prompt 完成后调一下,
-     *   即可获得"重启 / 跨进程接续"的语义.
-     */
-    async saveCurrentSession(key) {
-        const persisted = this.messageHistory.map((m) => ({
-            role: m.role,
-            content: m.content,
-            toolCall: m.toolCall,
-            toolResult: m.toolResult,
-            toolCallId: m.toolCallId,
-            timestamp: Date.now(),
-            source: 'pi-session',
-        }));
-        await this._sessionStore.saveMessages(key, persisted);
-    }
-    /**
-     * 2026-06-30: 从 disk 拉历史覆盖当前 messageHistory.
-     * 返回加载条数 — 失败或空则返回 0.
-     * 与 loadSessionKey (构造时读) 不同: 这个是 session 已建好后再读.
-     */
-    async resumeSession(key, maxMessages = 30) {
-        const before = this.messageHistory.length;
-        await this.hydrateMessageHistory(key, maxMessages);
-        return this.messageHistory.length - before;
-    }
-    /**
-     * 2026-06-30: 读历史不修改 messageHistory.
-     * 给 claude code / 测试做"先看一下历史"用 — 不破坏当前会话.
-     * 返回 Message[] 数组 (空数组表示无历史).
-     */
-    async peekSessionHistory(key, maxMessages = 30) {
-        try {
-            const loaded = await this._sessionStore.loadMessages(key);
-            if (!loaded)
-                return [];
-            return this._filterToMessage(loaded).slice(-maxMessages);
-        }
-        catch {
-            return [];
-        }
-    }
-    /** hydrateMessageHistory 用的过滤逻辑 — 提到外面复用 */
-    _filterToMessage(loaded) {
-        const hydrated = [];
-        const VALID_ROLES = new Set(['user', 'assistant', 'tool', 'system']);
-        for (const m of loaded) {
-            // role 必须合法 (拒绝旧 schema {type:'user'} 没 role 字段的)
-            if (!VALID_ROLES.has(m.role))
-                continue;
-            // 跳过污染消息
-            if (typeof m.content === 'string' && m.content.startsWith('[AI 服务调用失败]'))
-                continue;
-            if (typeof m.content === 'string' && m.content.startsWith('[错误:'))
-                continue;
-            // 注意: '!m.content' 会跳过 content='' 的 tool call 消息 (assistant role + toolCall 字段),
-            //   这种是合法的 (LLM 输出只有 tool call, 没有正文) — 必须保留.
-            //   这里只跳过"无内容 + 也没 tool call/tool result"的废消息.
-            if (!m.content && !m.toolCall && !m.toolResult)
-                continue;
-            // 跳过空 tool role (tool result 占位但没有任何内容)
-            if (m.role === 'tool' && !m.toolResult)
-                continue;
-            hydrated.push({
-                role: m.role,
-                content: m.content ?? '',
-                toolCall: m.toolCall,
-                toolResult: m.toolResult,
-                toolCallId: m.toolCallId,
-            });
-        }
-        return hydrated;
-    }
-    /** 暴露 store 给测试 / 高级集成用. */
-    get sessionStoreInstance() {
-        return this._sessionStore;
-    }
     /**
      * 从 SKILL.md 目录加载 skills 进 skillRegistry.
      *
@@ -601,17 +501,23 @@ class PiAgentSession {
      *   2. ~/.bolloon/skills/         全局用户级
      *   3. <cwd>/.bolloon/skills/     项目级
      *   4. ~/.boll/skills/            全局 (兼容 bollharness 旧用户)
-     *
-     * 2026-07-04: 移除 18 个 bollharness builtin skill (findBolloonBuiltinSkillsPath).
-     *   历史遗留: 写 pi-sdk 时为方便演示, 把 bolloon 项目里的 19 个 skill 强制注入到 system prompt.
-     *   问题: system prompt 涨到 22K chars, LLM (minimax M3) 在 pivot loop 里反复 think 不输出
-     *          `<final gen>`, session 落盘拿不到最终回答.
-     *   现在: 只让用户放 .bolloon/skills/SKILL.md 才生效, 干净且 project-owned.
+     *   5. <bolloon-repo>/src/bollharness/.boll/skills/  bolloon 仓库内置 skill
+     *      (bolloon 项目本身用 pi-sdk 写核心, 这 19 个 skill 视为项目级 builtin)
      *
      * 静默忽略不存在的目录.
      */
     loadSkills(paths) {
-        const resolved = (paths && paths.length > 0) ? paths : defaultSkillPaths(os.homedir(), this.cwd);
+        let resolved;
+        if (paths && paths.length > 0) {
+            resolved = paths;
+        }
+        else {
+            resolved = [
+                ...defaultSkillPaths(os.homedir(), this.cwd),
+                // bolloon 仓库内置 skill (相对本 npm 包的位置)
+                this.findBolloonBuiltinSkillsPath(),
+            ].filter((p) => Boolean(p));
+        }
         loadSkillsFromPaths(resolved)
             .then((skills) => {
             for (const s of skills) {
@@ -620,17 +526,36 @@ class PiAgentSession {
                 }
                 this.skillRegistry.register(s);
             }
-            console.log(`[loadSkills] 已加载 ${skills.length} 个 skill from ${resolved.join(', ')}`);
-            if (skills.length > 0) {
-                for (const s of skills) {
-                    console.log(`  - ${s.name}: ${s.description.substring(0, 100)}${s.description.length > 100 ? '...' : ''}`);
-                }
-            }
+            console.log(`[loadSkills] 已加载 ${skills.length} 个 skill: ${skills.map(describeSkill).join(' | ')}`);
         })
             .catch((err) => {
             console.error('[loadSkills] 加载失败:', err);
         });
     }
+    /**
+     * 定位 bolloon 仓库内置的 bollharness skill 目录.
+     * 向上回溯 cwd, 找第一个包含 src/bollharness/.boll/skills 的祖先.
+     * 找不到时返回 null (例如把 bolloon-agent 作为外部依赖安装时).
+     */
+    findBolloonBuiltinSkillsPath() {
+        let dir = this.cwd;
+        for (let i = 0; i < 6; i++) {
+            const candidate = path.join(dir, 'src', 'bollharness', '.boll', 'skills');
+            try {
+                if (fsSync.existsSync(candidate) && fsSync.statSync(candidate).isDirectory()) {
+                    return candidate;
+                }
+            }
+            catch {
+                // 忽略 stat 异常, 继续向上
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return null;
+    }
     async initHarness() {
         try {
             const { createBollharnessIntegration } = await import('../bollharness-integration/index.js');
@@ -747,162 +672,6 @@ class PiAgentSession {
                 }
             }
         });
-        // 2026-06-19: 本地 + 远端智能体通信工具集 (Agent Mesh 通信层)
-        //   解决"另一个智能体发消息"的能力缺口:
-        //   - 本地 channel: 走 PiSessionManager.getAllChannels / addMessage / getChannelMessages
-        //   - 远端 P2P: 走 p2pNetwork.sendMessage
-        this._inboxMessages = [];
-        this._setupInboxListener();
-        // list_local_channels: 列出本 session 内所有 channel
-        this.tools.set('list_local_channels', {
-            name: 'list_local_channels',
-            description: '列出当前 PiAgentSession 注册的所有 channel. 每个 channel 是 bolloon 内的智能体会话, 可含 messages[] / peerDid(对端 DID) / peerName. 供 send_to_channel 选 channel_id.',
-            parameters: {},
-            execute: async () => {
-                const channels = this.sessionManager.getAllChannels();
-                if (channels.length === 0) {
-                    return { success: true, output: '📭 当前 session 没有注册任何 channel (用 send_to_channel 留空 channel_id 会自动创建一个)' };
-                }
-                const lines = channels.map((ch, i) => {
-                    const peer = ch.peerDid ? ` peer=${ch.peerDid.substring(0, 20)}` : (ch.peerName ? ` peer="${ch.peerName}"` : '');
-                    const msgCount = ch.messages?.length || 0;
-                    return `  ${i + 1}. ${ch.id} name="${ch.name}" msgs=${msgCount}${peer}`;
-                });
-                return { success: true, output: `📬 当前 session 有 ${channels.length} 个 channel:\n${lines.join('\n')}` };
-            }
-        });
-        // send_to_channel: 把消息发到指定 channel (本地 + 如果 channel 有关联 peerDid 也走 P2P 转发)
-        this.tools.set('send_to_channel', {
-            name: 'send_to_channel',
-            description: '发送消息到指定 channel. channel_id 留空会自动创建一个. 如果 channel 已关联 peerDid, 会同时通过 P2P 转发到对端 agent.',
-            parameters: { channel_id: '目标 channel id (留空自动创建)', message: '消息内容 (必填)', peer_did: '可选 创建新 channel 时绑定的对端 DID (e.g. did:key:...)' },
-            execute: async (args) => {
-                const message = String(args.message || '').trim();
-                if (!message)
-                    return { success: false, error: 'message 必填' };
-                let channelId = String(args.channel_id || '').trim();
-                const peerDid = args.peer_did ? String(args.peer_did) : undefined;
-                if (!channelId) {
-                    // 自动创建 channel
-                    const ch = await this.sessionManager.getOrCreatePeerChannel(peerDid || 'auto-created', 'auto-created');
-                    channelId = ch.id;
-                }
-                // 用 AgentSession 接口方法发消息 (它会自动设置 type/agentId/timestamp)
-                await this.sendSocialMessage(channelId, message);
-                // 如果 channel 关联了 peer, 走 P2P 转发
-                const ch = this.sessionManager.getAllChannels().find(c => c.id === channelId);
-                if (ch?.peerDid) {
-                    try {
-                        const peerId = ch.peerDid.replace(/^did:key:/, '').replace(/^did:pi:/, '');
-                        await p2pNetwork.sendMessage(peerId, 'channel-message', JSON.stringify({ channelId, content: message, from: this.identity.did, timestamp: new Date().toISOString() }));
-                        return { success: true, output: `📨 消息已存到 channel ${channelId} + P2P 转发到 ${ch.peerDid.substring(0, 30)}...` };
-                    }
-                    catch (e) {
-                        return { success: true, output: `📨 消息已存到 channel ${channelId} (P2P 转发失败: ${String(e).slice(0, 100)})` };
-                    }
-                }
-                return { success: true, output: `📨 消息已存到 channel ${channelId}` };
-            }
-        });
-        // check_channel_inbox: 读指定 channel 的所有 messages
-        this.tools.set('check_channel_inbox', {
-            name: 'check_channel_inbox',
-            description: '读取指定 channel 的所有 messages, 按时间排序. channel_id 必填, 来自 list_local_channels.',
-            parameters: { channel_id: '目标 channel id (必填)', max: '可选, 最多返回 N 条 (默认 50)' },
-            execute: async (args) => {
-                const channelId = String(args.channel_id || '').trim();
-                if (!channelId)
-                    return { success: false, error: 'channel_id 必填' };
-                const max = Number(args.max) || 50;
-                const messages = await this.sessionManager.getChannelMessages(channelId);
-                const channel = this.sessionManager.getAllChannels().find(c => c.id === channelId);
-                const channelName = channel?.name || channelId;
-                if (messages.length === 0) {
-                    return { success: true, output: `📭 channel "${channelName}" (${channelId}) 空, 0 条消息` };
-                }
-                const slice = messages.slice(-max);
-                const lines = slice.map((m, i) => {
-                    const from = m.sender || m.from || m.fromDid || m.agentId || '?';
-                    const ts = m.timestamp || m.createdAt || '?';
-                    const content = (m.content || m.text || '').substring(0, 200);
-                    return `  ${i + 1}. [${m.type || 'text'}] from=${from} time=${ts}\n     ${content}`;
-                });
-                return { success: true, output: `📬 channel "${channelName}" (${channelId}) 有 ${slice.length} 条消息 (共 ${messages.length}):\n${lines.join('\n')}` };
-            }
-        });
-        // check_inbox: 兼容旧名, 实际走 check_channel_inbox
-        this.tools.set('check_inbox', {
-            name: 'check_inbox',
-            description: "兼容旧名: 默认读第一个 channel 的 messages. 推荐用 list_local_channels + check_channel_inbox(channel_id)",
-            parameters: { max: '可选, 最多返回 N 条 (默认 50)' },
-            execute: async (args) => {
-                const channels = this.sessionManager.getAllChannels();
-                if (channels.length === 0) {
-                    return { success: true, output: '📭 当前 session 没有 channel, 0 条消息' };
-                }
-                const first = channels[0];
-                // 直接调 check_channel_inbox 复用逻辑
-                return await this.tools.get('check_channel_inbox').execute({ channel_id: first.id, max: String(args.max || 50) });
-            }
-        });
-        // send_to_peer: 发送结构化消息到指定 P2P 节点
-        this.tools.set('send_to_peer', {
-            name: 'send_to_peer',
-            description: '发送结构化消息到指定 P2P 节点 (远端 bolloon 实例). 对方会通过远端 channel 收到.',
-            parameters: { peer_id: '目标 P2P 节点 publicKey (用 list_peers 查)', message: '消息内容 (任意字符串)', type: '可选, 消息类型标签 (默认 agent-message)' },
-            execute: async (args) => {
-                const peerId = String(args.peer_id || '').trim();
-                const msg = String(args.message || '').trim();
-                const type = String(args.type || 'agent-message').trim();
-                if (!peerId)
-                    return { success: false, error: 'peer_id 必填' };
-                if (!msg)
-                    return { success: false, error: 'message 必填' };
-                try {
-                    await p2pNetwork.sendMessage(peerId, type, msg);
-                    return { success: true, output: `✅ 消息已发送到 ${peerId.substring(0, 16)}...` };
-                }
-                catch (e) {
-                    return { success: false, error: `发送失败: ${String(e)}` };
-                }
-            }
-        });
-        // p2p_broadcast: 广播给所有 P2P 节点
-        this.tools.set('p2p_broadcast', {
-            name: 'p2p_broadcast',
-            description: '广播消息到所有连接的 P2P 节点',
-            parameters: { message: '消息内容', type: '可选, 消息类型标签 (默认 agent-broadcast)' },
-            execute: async (args) => {
-                const msg = String(args.message || '').trim();
-                const type = String(args.type || 'agent-broadcast').trim();
-                if (!msg)
-                    return { success: false, error: 'message 必填' };
-                try {
-                    await p2pNetwork.broadcast(type, msg);
-                    return { success: true, output: `📡 已广播 type=${type}` };
-                }
-                catch (e) {
-                    return { success: false, error: `广播失败: ${String(e)}` };
-                }
-            }
-        });
-        // agent_call: RPC 风格远端 agent 任务调用
-        this.tools.set('agent_call', {
-            name: 'agent_call',
-            description: 'RPC: 让远端 P2P agent 跑一个任务, 等待结果返回. 远端 agent 会基于 task 描述自主完成, 完成后回复. (RPC 结果回收机制待实现)',
-            parameters: { peer_id: '目标 P2P 节点', task: '任务描述 (远端 agent 收到的 prompt)', timeoutMs: '可选 超时 (ms, 默认 30000)' },
-            execute: async (args) => {
-                const peerId = String(args.peer_id || '').trim();
-                const task = String(args.task || '').trim();
-                if (!peerId)
-                    return { success: false, error: 'peer_id 必填' };
-                if (!task)
-                    return { success: false, error: 'task 必填' };
-                const requestId = `rpc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-                await p2pNetwork.sendMessage(peerId, 'agent-call', JSON.stringify({ requestId, task, from: this.identity?.did }));
-                return { success: true, output: `📞 RPC 任务已发送给 ${peerId.substring(0, 16)}...\n   requestId=${requestId}` };
-            }
-        });
         this.tools.set('get_identity', {
             name: 'get_identity',
             description: '获取当前智能体身份信息',
@@ -1031,32 +800,7 @@ class PiAgentSession {
                 const cmd = String(args.command || '').trim();
                 if (!cmd)
                     return { success: false, error: 'command 必填' };
-                // 2026-06-19: 支持多种 args 格式
-                //   1. JSON 数组: ["checkout", "-b", "branch"] (LLM 偏好)
-                //   2. 逗号分隔: "checkout,-b,branch" (旧格式)
-                //   3. 字符串: "checkout -b branch" (单参数)
-                let argList = [];
-                const rawArgs = args.args;
-                if (Array.isArray(rawArgs)) {
-                    argList = rawArgs.map((s) => String(s).trim()).filter(Boolean);
-                }
-                else if (typeof rawArgs === 'string') {
-                    const trimmed = rawArgs.trim();
-                    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
-                        // JSON 数组字符串
-                        try {
-                            const parsed = JSON.parse(trimmed);
-                            if (Array.isArray(parsed)) {
-                                argList = parsed.map((s) => String(s).trim()).filter(Boolean);
-                            }
-                        }
-                        catch { /* fall through to comma split */ }
-                    }
-                    if (argList.length === 0) {
-                        // 逗号分隔 或 单字符串
-                        argList = trimmed.split(',').map(s => s.trim()).filter(Boolean);
-                    }
-                }
+                const argList = String(args.args || '').split(',').map(s => s.trim()).filter(Boolean);
                 const timeoutMs = Number(args.timeoutMs) || 30000;
                 const result = await shellExec(cmd, argList, { timeoutMs });
                 if (result.deniedByGuard) {
@@ -1082,10 +826,6 @@ class PiAgentSession {
                 return await runSelfImproveLoop(goal);
             }
         });
-        // 2026-06-24: Wallet + Polymarket + Safe 工具集 (基于 constraint-runtime/src/tools/)
-        //   真实可用实现: ethers v6 + JsonRpcProvider, 默认走 eth.llamarpc.com
-        //   agent 可以创建/导入/查询 EVM 钱包, 查余额, 签名, 转账, 部署 Safe 多签钱包
-        this._registerWalletTools();
         // list_skills 工具: 列出当前 session 已加载的 skills
         // 加载源: ~/.bolloon/skills/ → <cwd>/.bolloon/skills/ → ~/.boll/skills/
         this.tools.set('list_skills', {
@@ -1281,270 +1021,6 @@ class PiAgentSession {
                 return { success: true, output: `✅ ${create ? 'created + checked out' : 'checked out'} ${name}\n${result.output || ''}` };
             }
         });
-        // 2026-06-19: 实用代码修改工具集 (M4) — 补全 read/delete/mkdir/move + grep/git log/show
-        //   这些是 LLM 自主完成代码修改的最小工具集, 之前只能通过 shell_exec 间接调用
-        // 通用文件读取 (支持任意扩展名, 跟 read_document 区别是后者只支持 txt/md/pdf/docx)
-        this.tools.set('read_file', {
-            name: 'read_file',
-            description: '读取任意文件内容 (相对 cwd). 与 read_document 区别: 不限制文件类型. 受 shell-guard 路径白名单保护.',
-            parameters: { path: '相对路径 (必填, e.g. "src/agents/pi-sdk.ts")', startLine: '起始行号 (可选, 默认 0)', maxLines: '最大行数 (可选, 默认 500)' },
-            execute: async (args) => {
-                const relPath = String(args.path || '').trim();
-                if (!relPath)
-                    return { success: false, error: 'path 必填' };
-                const pathResult = checkWritePath(relPath);
-                if (!pathResult.allowed)
-                    return { success: false, error: `路径被护栏拒: ${pathResult.reason}` };
-                try {
-                    const absPath = path.resolve(this.cwd, relPath);
-                    const content = fsSync.readFileSync(absPath, 'utf-8');
-                    const start = Math.max(0, parseInt(String(args.startLine || '0')) || 0);
-                    const max = parseInt(String(args.maxLines || '500')) || 500;
-                    const lines = content.split('\n');
-                    const slice = lines.slice(start, start + max);
-                    return { success: true, output: `📄 ${relPath} (第 ${start + 1}-${start + slice.length} 行, 共 ${lines.length} 行):\n${slice.map((l, i) => `${String(start + i + 1).padStart(4)} | ${l}`).join('\n')}` };
-                }
-                catch (e) {
-                    return { success: false, error: `读取失败: ${e.message}` };
-                }
-            }
-        });
-        // 删除文件
-        this.tools.set('delete_file', {
-            name: 'delete_file',
-            description: '删除一个文件. 受 shell-guard 路径白名单保护. 不可恢复, 调用前请确认.',
-            parameters: { path: '相对路径 (必填)' },
-            execute: async (args) => {
-                const relPath = String(args.path || '').trim();
-                if (!relPath)
-                    return { success: false, error: 'path 必填' };
-                const pathResult = checkWritePath(relPath);
-                if (!pathResult.allowed)
-                    return { success: false, error: `路径被护栏拒: ${pathResult.reason}` };
-                try {
-                    const absPath = path.resolve(this.cwd, relPath);
-                    if (!fsSync.existsSync(absPath))
-                        return { success: false, error: `文件不存在: ${relPath}` };
-                    fsSync.unlinkSync(absPath);
-                    return { success: true, output: `✅ deleted ${relPath}` };
-                }
-                catch (e) {
-                    return { success: false, error: `删除失败: ${e.message}` };
-                }
-            }
-        });
-        // 创建目录
-        this.tools.set('mkdir', {
-            name: 'mkdir',
-            description: '创建一个或多个目录. 自动 mkdir -p (父目录不存在也创建).',
-            parameters: { path: '目录路径 (必填, 相对 cwd)' },
-            execute: async (args) => {
-                const relPath = String(args.path || '').trim();
-                if (!relPath)
-                    return { success: false, error: 'path 必填' };
-                const pathResult = checkWritePath(relPath);
-                if (!pathResult.allowed)
-                    return { success: false, error: `路径被护栏拒: ${pathResult.reason}` };
-                try {
-                    const absPath = path.resolve(this.cwd, relPath);
-                    fsSync.mkdirSync(absPath, { recursive: true });
-                    return { success: true, output: `✅ mkdir ${relPath}` };
-                }
-                catch (e) {
-                    return { success: false, error: `创建失败: ${e.message}` };
-                }
-            }
-        });
-        // 移动/重命名文件
-        this.tools.set('move_file', {
-            name: 'move_file',
-            description: '移动或重命名文件. 源和目标路径都在白名单内才允许.',
-            parameters: { from: '源路径 (必填)', to: '目标路径 (必填)' },
-            execute: async (args) => {
-                const from = String(args.from || '').trim();
-                const to = String(args.to || '').trim();
-                if (!from || !to)
-                    return { success: false, error: 'from 和 to 都必填' };
-                const fromCheck = checkWritePath(from);
-                if (!fromCheck.allowed)
-                    return { success: false, error: `from 路径被护栏拒: ${fromCheck.reason}` };
-                const toCheck = checkWritePath(to);
-                if (!toCheck.allowed)
-                    return { success: false, error: `to 路径被护栏拒: ${toCheck.reason}` };
-                try {
-                    const fromAbs = path.resolve(this.cwd, from);
-                    const toAbs = path.resolve(this.cwd, to);
-                    if (!fsSync.existsSync(fromAbs))
-                        return { success: false, error: `源文件不存在: ${from}` };
-                    fsSync.mkdirSync(path.dirname(toAbs), { recursive: true });
-                    fsSync.renameSync(fromAbs, toAbs);
-                    return { success: true, output: `✅ ${from} → ${to}` };
-                }
-                catch (e) {
-                    return { success: false, error: `移动失败: ${e.message}` };
-                }
-            }
-        });
-        // 文件内搜索 (类似 grep)
-        this.tools.set('grep_files', {
-            name: 'grep_files',
-            description: '在文件中搜索匹配 pattern 的行. 类似 grep -rn. 路径必须在白名单.',
-            parameters: { pattern: '搜索 pattern (必填, 字符串, 不是正则)', path: '搜索目录 (可选, 默认 .)', filePattern: '文件名 glob (可选, e.g. "*.ts")' },
-            execute: async (args) => {
-                const pattern = String(args.pattern || '').trim();
-                if (!pattern)
-                    return { success: false, error: 'pattern 必填' };
-                const searchPath = String(args.path || '.').trim();
-                const pathResult = checkWritePath(searchPath);
-                if (!pathResult.allowed)
-                    return { success: false, error: `路径被护栏拒: ${pathResult.reason}` };
-                try {
-                    const { execFile } = await import('child_process');
-                    const { promisify } = await import('util');
-                    const pExecFile = promisify(execFile);
-                    const argv = ['-rn', '--include=' + (args.filePattern || '*'), pattern, searchPath];
-                    const { stdout, stderr } = await pExecFile('grep', argv, { cwd: this.cwd, maxBuffer: 1024 * 1024 });
-                    const lines = stdout.split('\n').filter(Boolean).slice(0, 50);
-                    return { success: true, output: `🔍 grep "${pattern}" in ${searchPath} (${args.filePattern || '*'}, 最多 50 行):\n${lines.join('\n')}${lines.length === 50 ? '\n... (truncated)' : ''}` };
-                }
-                catch (e) {
-                    if (e.code === 1)
-                        return { success: true, output: `🔍 grep "${pattern}" in ${searchPath}: 0 matches` };
-                    return { success: false, error: `grep 失败: ${e.message}` };
-                }
-            }
-        });
-        // glob 找文件
-        this.tools.set('glob_files', {
-            name: 'glob_files',
-            description: '用 glob pattern 找文件. 例如 "**/*.test.ts".',
-            parameters: { pattern: 'glob pattern (必填, e.g. "src/**/*.ts")' },
-            execute: async (args) => {
-                const pattern = String(args.pattern || '').trim();
-                if (!pattern)
-                    return { success: false, error: 'pattern 必填' };
-                try {
-                    const pathResult = checkWritePath(pattern.replace(/\*\*.*$/, '').replace(/\/\*.*$/, '') || '.');
-                    if (!pathResult.allowed && pattern !== '**/*' && pattern !== '*')
-                        return { success: false, error: `路径被护栏拒: ${pathResult.reason}` };
-                    const { execFile } = await import('child_process');
-                    const { promisify } = await import('util');
-                    const pExecFile = promisify(execFile);
-                    // 用 shell 的 find + glob (避免引入额外依赖)
-                    const { stdout } = await pExecFile('find', [this.cwd, '-path', `*${pattern.replace(/\*\*\//, '*').replace(/\*\*$/, '*').replace(/\*$/, '*')}`, '-type', 'f'], { maxBuffer: 1024 * 1024 });
-                    const files = stdout.split('\n').filter(Boolean).slice(0, 100);
-                    const relFiles = files.map(f => path.relative(this.cwd, f));
-                    return { success: true, output: `🔍 glob "${pattern}" 找到 ${relFiles.length} 个文件${relFiles.length === 100 ? ' (truncated)' : ''}:\n${relFiles.join('\n')}` };
-                }
-                catch (e) {
-                    return { success: false, error: `glob 失败: ${e.message}` };
-                }
-            }
-        });
-        // git log
-        this.tools.set('git_log', {
-            name: 'git_log',
-            description: '查看 git log. 默认 --oneline -10. 支持过滤和范围.',
-            parameters: { range: '可选, e.g. "HEAD~5..HEAD" 或分支名', maxCount: '可选, 默认 10', oneline: '可选, "true" 用 --oneline (默认 true)' },
-            execute: async (args) => {
-                const range = String(args.range || '').trim();
-                const maxCount = parseInt(String(args.maxCount || '10')) || 10;
-                const oneline = String(args.oneline || 'true') === 'true';
-                const argv = ['log'];
-                if (oneline)
-                    argv.push('--oneline');
-                if (maxCount > 0)
-                    argv.push(`-n`, String(maxCount));
-                if (range)
-                    argv.push(range);
-                const result = await shellExec('git', argv, { timeoutMs: 10_000 });
-                if (result.deniedByGuard)
-                    return { success: false, error: result.error };
-                if (!result.success)
-                    return { success: false, error: result.error, output: result.output };
-                return { success: true, output: `📜 git log:\n${result.output || '(empty)'}` };
-            }
-        });
-        // git show
-        this.tools.set('git_show', {
-            name: 'git_show',
-            description: '查看 commit 内容. 默认 HEAD. 支持 --stat 看统计, --patch 看 diff.',
-            parameters: { ref: '可选, 默认 HEAD', stat: '可选, "true" 只看 stat (默认 false)' },
-            execute: async (args) => {
-                const ref = String(args.ref || 'HEAD').trim();
-                const argv = ['show', ref];
-                if (String(args.stat || 'false') === 'true')
-                    argv.push('--stat');
-                const result = await shellExec('git', argv, { timeoutMs: 15_000 });
-                if (result.deniedByGuard)
-                    return { success: false, error: result.error };
-                if (!result.success)
-                    return { success: false, error: result.error, output: result.output };
-                return { success: true, output: `📜 git show ${ref}:\n${result.output || '(empty)'}` };
-            }
-        });
-        // git stash
-        this.tools.set('git_stash', {
-            name: 'git_stash',
-            description: 'git stash 暂存当前未提交改动. action: save/pop/list/apply/drop. 支持 message.',
-            parameters: { action: '动作 (必填, "save" | "pop" | "list" | "apply" | "drop")', message: '可选, save 时的描述', index: '可选, apply/pop/drop 的 stash index (e.g. "0")' },
-            execute: async (args) => {
-                const action = String(args.action || '').trim();
-                if (!['save', 'pop', 'list', 'apply', 'drop'].includes(action)) {
-                    return { success: false, error: `action 必须是 save/pop/list/apply/drop 之一, 收到: ${action}` };
-                }
-                const argv = ['stash', action];
-                if (action === 'save' && args.message)
-                    argv.push('-m', String(args.message));
-                if ((action === 'apply' || action === 'drop' || action === 'pop') && args.index) {
-                    argv.push('stash@{' + String(args.index) + '}');
-                }
-                const result = await shellExec('git', argv, { timeoutMs: 10_000 });
-                if (result.deniedByGuard)
-                    return { success: false, error: result.error };
-                if (!result.success)
-                    return { success: false, error: result.error, output: result.output };
-                return { success: true, output: `✅ git stash ${action}\n${result.output || ''}` };
-            }
-        });
-        // vitest 跑测试
-        this.tools.set('vitest_run', {
-            name: 'vitest_run',
-            description: '跑 vitest 测试. 自动 bail (失败就停). 默认 60s timeout.',
-            parameters: { pattern: '可选, 文件 glob e.g. "src/agents/pi-sdk.test.ts"', timeoutMs: '可选, 默认 60000' },
-            execute: async (args) => {
-                const argv = ['vitest', 'run', '--reporter=default', '--no-color', '--bail=1'];
-                if (args.pattern)
-                    argv.push(String(args.pattern));
-                const timeoutMs = parseInt(String(args.timeoutMs || '60000')) || 60000;
-                const result = await shellExec('npx', argv, { timeoutMs });
-                if (result.deniedByGuard)
-                    return { success: false, error: result.error };
-                if (!result.success)
-                    return { success: false, error: result.error || 'vitest 失败', output: result.output };
-                return { success: true, output: `✅ vitest 通过:\n${(result.output || '').slice(0, 2000)}` };
-            }
-        });
-        // tsc 编译检查
-        this.tools.set('tsc_check', {
-            name: 'tsc_check',
-            description: '跑 tsc --noEmit 检查 TypeScript 编译. 默认 60s timeout.',
-            parameters: { project: '可选, tsconfig 路径 (默认 tsconfig.json)', timeoutMs: '可选, 默认 60000' },
-            execute: async (args) => {
-                const argv = ['tsc', '--noEmit'];
-                if (args.project)
-                    argv.push('-p', String(args.project));
-                else
-                    argv.push('-p', 'tsconfig.json');
-                const timeoutMs = parseInt(String(args.timeoutMs || '60000')) || 60000;
-                const result = await shellExec('npx', argv, { timeoutMs });
-                if (result.deniedByGuard)
-                    return { success: false, error: result.error };
-                if (!result.success)
-                    return { success: false, error: result.error || 'tsc 失败', output: result.output };
-                return { success: true, output: `✅ tsc 通过:\n${(result.output || 'no errors').slice(0, 1000)}` };
-            }
-        });
         // M3.2: 任务状态机工具 — 让 agent 自己维护 multi_step 任务的状态
         this.tools.set('create_task', {
             name: 'create_task',
@@ -1685,11 +1161,6 @@ class PiAgentSession {
         //   - 失败结果不缓存 (避免缓存 transient 错误)
         //   - 缓存容量 200 条, 超过就清空
         this.wrapToolsWithIdempotency();
-        // 2026-06-30: 镜像到 ToolRegistry — resolveToolName 走 registry 的 alias 表.
-        //   被 wrap 的 tool (idempotency cache) 也直接拿来用, registry 不重复 wrap.
-        for (const [name, tool] of this.tools.entries()) {
-            this._toolRegistry.register(tool);
-        }
     }
     /** M3.3: 工具结果缓存 — 防止 loop 重试时副作用 (写文件 / 改代码) 执行多次 */
     idempotencyCache = new Map();
@@ -1736,13 +1207,10 @@ class PiAgentSession {
         // M2.4 (2026-06-17): 缓存 tool 定义 — registerTools() 在构造时调一次, 此后不变
         if (this.cachedToolDefinitions)
             return this.cachedToolDefinitions;
-        const defs = ['可用工具 (name(params) - 简介):'];
+        const defs = ['可用工具:'];
         for (const tool of this.tools.values()) {
-            // 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})`);
+            const params = Object.entries(tool.parameters).map(([k, v]) => `${k}: ${v}`).join(', ');
+            defs.push(`- ${tool.name}(${params}) - ${tool.description}`);
         }
         this.cachedToolDefinitions = defs.join('\n');
         return this.cachedToolDefinitions;
@@ -1839,27 +1307,15 @@ class PiAgentSession {
         }
     }
     async promptStream(input, onStream, signal, channelId) {
-        console.log(`[PiAgent.promptStream] ENTRY, channelId=${channelId}, input chars=${input.length}`);
         this.minimaxAvailable = this.checkMinimax();
-        console.log(`[PiAgent.promptStream] minimaxAvailable=${this.minimaxAvailable}`);
         this.currentChannelId = channelId ?? this.currentChannelId;
-        // 2026-06-18 (supervisor): web server 把 46K markedPrompt 喂过来
-        //   (【本轮用户请求】\n<text>\n【请求结束】\n\n<contextHint>).
-        //   整个 input 走下游, pivot loop 之前拿 47K buildContext 当 user message 发出去,
-        //   模型撞 context window. 提取 userText 替代 input, contextHint 拼到 systemPrompt 末尾.
-        const markerMatch = input.match(/【本轮用户请求】\s*([\s\S]*?)\s*【请求结束】/);
-        const userText = markerMatch ? markerMatch[1].trim() : input;
-        const contextHint = markerMatch ? input.replace(markerMatch[0], '').trim() : '';
-        console.log(`[PiAgent.promptStream] marker matched=${!!markerMatch}, userText chars=${userText.length}, contextHint chars=${contextHint.length}`);
         this.messageHistory.push({
             role: 'user',
-            content: userText
+            content: input
         });
-        // 2026-06-18: web server 喂的 markedPrompt 外的 contextHint 拼到 system 末尾 (而不是当 user message)
-        this.contextHintAddition = contextHint;
         onStream({ type: 'thinking', content: '🤔 开始思考...' });
         if (!this.minimaxAvailable) {
-            const response = await this.handleFallback(userText);
+            const response = await this.handleFallback(input);
             this.messageHistory.push({ role: 'assistant', content: response });
             onStream({ type: 'done', content: '' });
             return response;
@@ -1867,11 +1323,11 @@ class PiAgentSession {
         // P0 注入门: 缓存 onStream + signal, computeJudgmentGate 用 currentOnStream 广播 phase
         this.currentOnStream = onStream;
         this.currentSignal = signal ?? null;
-        await this.computeJudgmentGate(userText);
+        await this.computeJudgmentGate(input);
         // M2.2 (2026-06-17): intent 分类 — 0 LLM 成本, 5 行 keyword 匹配
         try {
             const { classifyIntent, intentHint } = await import('./intent-classifier.js');
-            this.currentIntent = classifyIntent(userText);
+            this.currentIntent = classifyIntent(input);
             this.currentIntentHint = intentHint(this.currentIntent);
             if (this.currentIntent !== 'chitchat') {
                 onStream({ type: 'phase', phase: 'intent_classified', detail: this.currentIntent, content: '' });
@@ -1892,13 +1348,9 @@ class PiAgentSession {
         }
         // Bootstrap SessionStart: 收集项目 Context, 拼到 systemAddition 头部
         // (失败静默, 5s 限流防止循环)
-        // 2026-07-04: 透传 agentId 让 onSessionStart 加载 persona 文档
         let bootstrapAddition = '';
         try {
-            const ss = await onSessionStart({
-                channelId: this.currentChannelId || undefined,
-                agentId: this.currentAgentId || undefined,
-            });
+            const ss = await onSessionStart({ channelId: this.currentChannelId || undefined });
             bootstrapAddition = ss.systemAddition || '';
         }
         catch (err) {
@@ -1920,7 +1372,7 @@ class PiAgentSession {
         if (this.usePivotLoop) {
             let pivotResult = '';
             try {
-                const lr = await this.promptWithPivotLoop(userText, undefined, channelId);
+                const lr = await this.promptWithPivotLoop(input, undefined, channelId);
                 pivotResult = lr.response || '';
                 onStream({ type: 'done', content: '' });
             }
@@ -1944,7 +1396,7 @@ class PiAgentSession {
                     }
                     catch { }
                 }
-                monitorAfterReply(userText, pivotResult);
+                monitorAfterReply(input, pivotResult);
                 const stopStartTime = this.promptStartTime || Date.now();
                 onStop({
                     channelId: this.currentChannelId || 'unknown',
@@ -1955,7 +1407,6 @@ class PiAgentSession {
                 this.currentOnStream = null;
                 this.currentSignal = null;
                 this.bootstrapAddition = '';
-                this.contextHintAddition = '';
                 this.promptStartTime = 0;
             }
             return pivotResult;
@@ -2089,45 +1540,37 @@ class PiAgentSession {
         }
         // M2.4: persona 缓存
         if (!this.cachedPersonaSection && this.persona) {
-            this.cachedPersonaSection = `
-角色描述: ${this.persona.description || '无'}
-性格特点: ${this.persona.personality || '无'}
-问候语: ${this.persona.greeting || '无'}
+            this.cachedPersonaSection = `
+角色描述: ${this.persona.description || '无'}
+性格特点: ${this.persona.personality || '无'}
+问候语: ${this.persona.greeting || '无'}
 `;
         }
-        const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${this.cachedPersonaSection}
-当前工作目录: ${this.cwd}
-当前身份: ${this.identity.name} (${this.identity.did})
-${this.currentIntentHint}
-
-${this.getToolDefinitions()}
-
-工作模式:
-1. 理解用户自然语言请求
-2. 分析需要哪些工具来完成
-3. 按顺序调用工具并观察结果
-4. 根据观察结果决定下一步
-5. 最终给出完整回答
-
-重要 (一次命中要求):
-- 每次只调用一个工具
-- 仔细分析工具返回结果
-- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
-- 如果需要更多信息，继续调用工具
-
-【工具调用格式 (严格遵守, 否则系统无法解析)】
-- 你只能输出**一个**工具调用, 不要堆叠多个 invoke
-- 工具调用格式: {"name":"<tool_name>","input":{"arg1":"value1"}}
-- 用 markdown json code block 包裹: \`\`\`json\n{"name":"X","input":{...}}\n\`\`\`
-- 工具调用前可以简短思考 (1-2 句话), 但**不要写长篇 thinking** (会撞 max_tokens)
-- 工具调用后必须等结果, 不要在同一个回复里继续输出
-- <final gen> 只在**真完成所有任务**时输出, 不要在工具调用前/中输出${this.judgmentGateAddition}${this.contextHintAddition}`;
+        const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${this.cachedPersonaSection}
+当前工作目录: ${this.cwd}
+当前身份: ${this.identity.name} (${this.identity.did})
+${this.currentIntentHint}
+
+${this.getToolDefinitions()}
+
+工作模式:
+1. 理解用户自然语言请求
+2. 分析需要哪些工具来完成
+3. 按顺序调用工具并观察结果
+4. 根据观察结果决定下一步
+5. 最终给出完整回答
+
+重要:
+- 每次只调用一个工具
+- 仔细分析工具返回结果
+- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}`;
         // 2026-06-15: 把 currentOnStream 传给 loop, 让 step-timeline 在 pivot 循环里也能 emit step_start/done
         //   之前 loop.execute() 不接 streamCallback, 导致 step-timeline 只能看到老 runReActLoop 路径
         //   promptWithPivotLoop 路径 0 step events — UI 显示 timeline 但永远是空
         // 2026-06-17: 透传 signal 让 abort 工作 — loop.execute() 当前不接 signal 参数,
         //   所以 abort 行为通过 this.currentSignal 共享给 loop 内部读 (后续 M3.2 接 task plan 时一起加)
-        const result = await loop.execute(input, llm, systemPrompt, this.currentOnStream ?? undefined, this.currentSignal ?? undefined);
+        const result = await loop.execute(input, llm, systemPrompt, this.currentOnStream ?? undefined);
         this.messageHistory.push({ role: 'user', content: input });
         if (result.response) {
             this.messageHistory.push({ role: 'assistant', content: result.response });
@@ -2171,12 +1614,10 @@ ${this.getToolDefinitions()}
         while (iteration < this.MAX_REACT_ITERATIONS) {
             iteration++;
             // 停止条件 1: max turns (fail-safe 10000, 正常任务永远跑不到)
-            //   2026-07-01 (v0.2.4 子任务 1): 委托给 react-loop.decideMaxIterations 纯函数
-            const maxIterDecision = decideMaxIterations(iteration, this.MAX_REACT_ITERATIONS);
-            if (maxIterDecision.shouldExit) {
+            if (iteration >= this.MAX_REACT_ITERATIONS) {
                 console.warn(`[PiAgent] 达到最大循环数 ${this.MAX_REACT_ITERATIONS}, 强制终止 (fail-safe)`);
                 onStream?.({ type: 'error', content: `⏹️ 达到最大循环数 (${this.MAX_REACT_ITERATIONS}, fail-safe)`, tool: 'loop' });
-                finalResponse = finalResponse || maxIterDecision.finalAnswer;
+                finalResponse = finalResponse || '(本轮 ReAct 循环达到最大步数, 强制结束)';
                 break;
             }
             // 停止条件 2: signal.aborted (显式 abort / 用户中断)
@@ -2190,23 +1631,14 @@ ${this.getToolDefinitions()}
             if (totalErrors >= this.MAX_TOTAL_ERRORS) {
                 console.warn(`[PiAgent] 累计错误 ${totalErrors} >= ${this.MAX_TOTAL_ERRORS}, 强制终止 (防死循环)`);
                 onStream?.({ type: 'error', content: `⛔ 累计 ${totalErrors} 次错误, 强制终止 (防止 LLM 死循环)`, tool: 'loop' });
-                // 2026-06-19: 即使 LLM 一直失败, 也汇总之前成功执行的 tool result 给用户
-                if (this.successfulToolResults.length > 0) {
-                    finalResponse = `✅ 之前步骤成功执行了 ${this.successfulToolResults.length} 个工具 (但 LLM 后续 ${totalErrors} 次调用失败):\n` +
-                        this.successfulToolResults.map((r, i) => `  ${i + 1}. ${r.tool}: ${r.outputPreview}`).join('\n') +
-                        `\n\n⚠️ (LLM 连续失败, 可能是 minimax 上游限流/网络问题, 工具已成功执行但 LLM 没能继续总结)`;
-                }
-                else {
-                    finalResponse = finalResponse || `(本轮 ReAct 循环累计 ${totalErrors} 次错误, 强制结束。请换个思路或简化任务重试。)`;
-                }
+                finalResponse = finalResponse || `(本轮 ReAct 循环累计 ${totalErrors} 次错误, 强制结束。请换个思路或简化任务重试。)`;
                 break;
             }
             // 2026-06-16 新增: loop 内自动压缩 — token 超 80% 阈值时跑一次
             // compact 失败走 C 路径: 不强行 break, 让现有 60K 阈值兜底 (后面有检查)
-            //   2026-07-01 (v0.2.4 子任务 1): 触发判定走 shouldCompactBeforeIteration 纯函数
             const compactThreshold = this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD * this.LOOP_COMPACT_RATIO;
             const estimatedTokensBefore = this.estimateHistoryTokens();
-            if (shouldCompactBeforeIteration(estimatedTokensBefore, compactThreshold)) {
+            if (estimatedTokensBefore > compactThreshold) {
                 const tokensBeforeCompact = estimatedTokensBefore;
                 console.log(`[PiAgent] loop 入口 token ${tokensBeforeCompact} > ${compactThreshold}, 触发自动压缩`);
                 onStream?.({ type: 'status', content: `🗜️ loop 自动压缩 (token ${tokensBeforeCompact} > ${compactThreshold})`, tool: 'compactor' });
@@ -2219,13 +1651,11 @@ ${this.getToolDefinitions()}
                 }
             }
             // 停止条件 3: context overflow (compact 后还超, 强制终止)
-            //   2026-07-01 (v0.2.4 子任务 1): 委托给 react-loop.decideContextOverflow 纯函数
             const estimatedTokens = this.estimateHistoryTokens();
-            const overflowDecision = decideContextOverflow(estimatedTokens, this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD);
-            if (overflowDecision.shouldExit) {
+            if (estimatedTokens > this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD) {
                 console.warn(`[PiAgent] context overflow (${estimatedTokens} tokens > ${this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD})`);
                 onStream?.({ type: 'error', content: `⏹️ 上下文溢出 (${estimatedTokens} tokens, 阈值 ${this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD})`, tool: 'loop' });
-                finalResponse = finalResponse || overflowDecision.finalAnswer;
+                finalResponse = finalResponse || '(本轮 ReAct 循环因上下文溢出终止)';
                 break;
             }
             // 调试日志：显示每次循环开始
@@ -2250,33 +1680,33 @@ ${this.getToolDefinitions()}
             }
             // M2.4: persona section 缓存 — persona 在 loadPersona() 时一次设定, 此后不变
             if (!this.cachedPersonaSection && this.persona) {
-                this.cachedPersonaSection = `
-角色描述: ${this.persona.description || '无'}
-性格特点: ${this.persona.personality || '无'}
-问候语: ${this.persona.greeting || '无'}
+                this.cachedPersonaSection = `
+角色描述: ${this.persona.description || '无'}
+性格特点: ${this.persona.personality || '无'}
+问候语: ${this.persona.greeting || '无'}
 `;
             }
             const personaSection = this.cachedPersonaSection;
-            const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
-当前工作目录: ${this.cwd}
-当前身份: ${this.identity.name} (${this.identity.did})
-${refineContext}
-${this.currentIntentHint}
-
-${toolDefs}
-
-工作模式:
-1. 理解用户自然语言请求
-2. 分析需要哪些工具来完成
-3. 按顺序调用工具并观察结果
-4. 根据观察结果决定下一步
-5. 最终给出完整回答
-
-重要:
-- 每次只调用一个工具
-- 仔细分析工具返回结果
-- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
-- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}${this.contextHintAddition}`;
+            const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+当前工作目录: ${this.cwd}
+当前身份: ${this.identity.name} (${this.identity.did})
+${refineContext}
+${this.currentIntentHint}
+
+${toolDefs}
+
+工作模式:
+1. 理解用户自然语言请求
+2. 分析需要哪些工具来完成
+3. 按顺序调用工具并观察结果
+4. 根据观察结果决定下一步
+5. 最终给出完整回答
+
+重要:
+- 每次只调用一个工具
+- 仔细分析工具返回结果
+- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}`;
             // 3 个恢复机制 (Claude Code 论文 9-step pipeline 内部):
             //   1. max output token 升级 (最多 3 次, 每次 maxOutputTokens 翻倍)
             //   2. reactive compaction (prompt 估算超阈值, 跑压缩)
@@ -2284,31 +1714,18 @@ ${toolDefs}
             // 失败静默: 全部重试失败 → 空 reply (上层用 no tool_use 终止)
             const response = await this.callLlmWithRecovery(llm, messages, systemPrompt, signal, onStream);
             const reply = (response.reply || '').trim();
-            // 2026-06-30: OpenAI 协议 native tool_calls (LLM 真产了 tool_call 时, minimax/M3 会返回 id)
-            const nativeToolCalls = response.toolCalls;
-            // 2026-06-19 架构 fix: 不再因 [AI 服务调用失败] break
-            //   旧逻辑: sentinel → aiFailed=true → break → 外层 retry 整个 loop (重置 history)
-            //   新逻辑: 把错误当 tool_result push 进 history → 下一轮 LLM 看到错误能反思重试
-            //   这是 dive-into 文档的"fail-open error recovery" — 错误进入 context, 不让 LLM 重复犯同样错
+            // 2026-06-16: 看到 [AI 服务调用失败] sentinel → 不再立即 break,
+            // 而是设 aiFailed=true, 让外层 promptStream 自动重跑整个 loop 最多 N 次
+            // (LLM API 401 / 网络错 / 配额满时, pi-ai 返回这个 prefix;
+            //  自动 retry 兜底: 临时网络抖动可自愈, 真挂 N 次后才报失败)
             if (reply.startsWith('[AI 服务调用失败]')) {
-                console.log(`[PiAgent] 收到 AI 错误 sentinel, 推到 history 让 LLM 反思, 继续 loop`);
-                console.log(`[sentinel DEBUG] 完整 reply: ${reply}`);
-                console.log(`[sentinel DEBUG] 上一轮 messages 数量: ${Array.isArray(messages) ? messages.length : 'N/A'}, systemPrompt 长度: ${systemPrompt.length}`);
+                console.log(`[PiAgent] 收到 AI 错误 sentinel, 标记 aiFailed, 外层会自动重试整个 loop`);
+                aiFailed = true;
                 aiFailureReason = reply.length > 200 ? reply.substring(0, 200) : reply;
-                totalErrors++;
-                consecutiveErrors++;
-                // 把错误当成 tool 结果 push 进 history, 这样下一轮 LLM 看到错误能调整
-                this.messageHistory.push({
-                    role: 'system',
-                    content: `[Loop 错误恢复 ${totalErrors}/${this.MAX_TOTAL_ERRORS}] ${aiFailureReason}\n\n请基于上轮工具结果继续完成任务, 不要重复调用同一失败操作. 如果工具已成功执行, 请基于 result.output 给用户总结; 如果工具失败, 请换其他方式或重试.`
-                });
                 if (onStream) {
-                    onStream({ type: 'status', content: `⚠️ AI 调用失败 ${totalErrors}/${this.MAX_TOTAL_ERRORS}, 已 push 错误到 history 让 LLM 反思`, tool: 'system' });
+                    onStream({ type: 'status', content: `⚠️ AI 调用失败, 将自动重试整个 loop`, tool: 'system' });
                 }
-                // 退避 2s 后继续 — 临时 minimax 限流避开, 不让 loop 终止
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                // 关键: 不设 aiFailed=true, 让外层不重试整个 loop (重置 history), 继续内层循环
-                continue;
+                break;
             }
             console.log(`[PiAgent] LLM 回复长度: ${reply.length}, 内容预览: "${reply.substring(0, 80)}..."`);
             console.log(`[PiAgent] LLM 完整回复:\n${reply}`);
@@ -2316,14 +1733,20 @@ ${toolDefs}
             if (onStream) {
                 onStream({ type: 'token', content: reply.substring(0, 100) });
             }
-            // 2026-06-19 架构 fix: parseToolCall 优先于 isFinalResponse
-            //   之前: 思考块里的 "<final gen>" 触发 isFinalResponse 提前 break, 工具从未真正执行
-            //   现在: 先尝试解析 tool_call, 有就执行; 没有才检查是不是真正的 final gen
+            if (this.isFinalResponse(reply)) {
+                // 检查质量分数
+                lastQualityScore = this.estimateResponseQuality(reply);
+                // 如果质量太低且还有改进机会，进入改进循环
+                if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {
+                    refineAttempts++;
+                    console.log(`[PiAgent] 质量评分 ${(lastQualityScore * 10).toFixed(1)}/10 < ${(this.QUALITY_THRESHOLD * 10).toFixed(1)}/10，自动改进中 (${refineAttempts}/${this.MAX_REFINE_ATTEMPTS})`);
+                    continue;
+                }
+                finalResponse = this.extractFinalAnswer(reply);
+                break;
+            }
             const toolCall = this.parseToolCall(reply);
-            // 2026-06-30 修: 给 toolCall 分配稳定 id, 让后续 tool result 能引用同一个 id
-            //   OpenAI 协议要求 messages 里 tool result 必须有对应的 tool_call_id, 否则 400
             if (toolCall) {
-                toolCall.id = `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
                 this.messageHistory.push({
                     role: 'assistant',
                     content: reply,
@@ -2489,7 +1912,7 @@ ${toolDefs}
                     catch (err) {
                         console.warn('[PiAgent] reactHarness.postToolCall failed (non-fatal, allowing):', err);
                     }
-                    this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result, toolCallId: toolCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}` });
+                    this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result });
                     this.logToHarness(toolCall.name, toolCall.args, result);
                     // 通知前端工具执行结果
                     if (onStream) {
@@ -2521,16 +1944,6 @@ ${toolDefs}
                     }
                     if (result.success) {
                         consecutiveErrors = 0; // 重置连续错误计数
-                        // 2026-06-19: 记录成功结果, 用于 LLM 失败退出时汇总给用户
-                        if (result.output) {
-                            this.successfulToolResults.push({
-                                tool: toolCall.name,
-                                outputPreview: result.output.substring(0, 200) + (result.output.length > 200 ? '...' : '')
-                            });
-                        }
-                        else {
-                            this.successfulToolResults.push({ tool: toolCall.name, outputPreview: '(无输出)' });
-                        }
                         // 检查工具执行质量
                         lastQualityScore = this.estimateToolResultQuality(result);
                         if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {
@@ -2602,36 +2015,6 @@ ${toolDefs}
                 if (onStream) {
                     onStream({ type: 'token', content: reply.substring(0, 150) });
                 }
-                // 2026-06-19 架构 fix: 只有 strip <think> 后才检查 isFinalResponse
-                //   (parseToolCall 已先尝试, 既然没解析出 tool_call, 现在检查 final gen 是否真的在最终回答区)
-                if (this.isFinalResponse(reply)) {
-                    // 2026-06-19 dive-into 风格修复: 如果还有 successful tool results 没汇报,
-                    //   LLM 不能提前 final_gen — harness 自动注入"请汇报剩余工具结果" hint 再 continue
-                    //   这是 dive-into 文档"step 9 stop condition check" 的具体化:
-                    //   stop condition = (有工具结果未汇报) ? continue : break
-                    // 检查回复是否包含工具结果内容（避免无限循环）
-                    const hasToolResultContent = this.successfulToolResults.some(r => reply.includes(r.tool) || reply.includes(r.outputPreview.substring(0, 50)));
-                    // 如果回复包含工具结果内容，清除 successfulToolResults
-                    if (hasToolResultContent) {
-                        console.log(`[PiAgent] 回复包含工具结果内容, 清除 successfulToolResults (${this.successfulToolResults.length} 个)`);
-                        this.successfulToolResults = [];
-                    }
-                    if (this.successfulToolResults.length > 0 && iteration < this.MAX_REACT_ITERATIONS) {
-                        const unreported = this.successfulToolResults.length;
-                        console.log(`[PiAgent] LLM 想 final_gen 但还有 ${unreported} 个工具结果未汇报, push hint 让其继续`);
-                        this.messageHistory.push({
-                            role: 'system',
-                            content: `[dive-into stop condition] 你之前已成功执行了 ${unreported} 个工具, 但当前回复里没把它们的结果告诉用户. 请基于已有的工具结果 (在 history 里) 写一个完整总结回复给用户, 用 <final gen> 结尾. 不要再调工具.`
-                        });
-                        if (onStream) {
-                            onStream({ type: 'status', content: `🔄 还有 ${unreported} 个工具结果未汇报, 让 LLM 继续总结`, tool: 'system' });
-                        }
-                        continue;
-                    }
-                    lastQualityScore = this.estimateResponseQuality(reply);
-                    finalResponse = this.extractFinalAnswer(reply);
-                    break;
-                }
                 // 检查是否需要继续循环处理
                 // 更严格的判断：只有当回复明确表示需要更多信息时才继续
                 const containsToolCallIntent = reply.includes('调用工具') || reply.includes('tool(') ||
@@ -2677,12 +2060,12 @@ ${toolDefs}
             onStream({ type: 'status', content: `✅ 处理完成，共 ${iteration - 1} 次循环`, tool: 'system' });
         }
         const now = new Date().toISOString();
-        const identityPrefix = `${this.identity.name} ｜ bolloon 智能体
-<environment_details>
-Current time: ${now}
-Working directory: ${this.cwd}
-Workspace root folder: ${this.cwd}
-</environment_details>
+        const identityPrefix = `${this.identity.name} ｜ bolloon 智能体
+<environment_details>
+Current time: ${now}
+Working directory: ${this.cwd}
+Workspace root folder: ${this.cwd}
+</environment_details>
 `;
         finalResponse = identityPrefix + finalResponse;
         this.messageHistory.push({ role: 'assistant', content: finalResponse });
@@ -2774,45 +2157,18 @@ Workspace root folder: ${this.cwd}
             for (const m of recentMessages) {
                 const role = m.role;
                 let content = m.content;
-                // 2026-06-30 修: OpenAI 协议 tool role 必须带 tool_call_id, 否则 minimax (OpenAI-compatible) 报 400
-                //   bolloon 之前把所有 tool result 包成 "[工具结果] ..." 当 user/assistant role 发, minimax 严格校验失败
-                //   现在: 保留 role='tool' + 加 tool_call_id 字段 (用 messageHistory 里自己生成的 id)
+                // tool role: 用 toolResult 序列化 (跟 buildContext 一样)
                 if (role === 'tool') {
                     const result = m.toolResult ? JSON.stringify(m.toolResult) : content;
                     content = `[工具结果] ${result}`;
-                    // MiniMax 等 API 不支持 tool role, 转为 user role
-                    out.push({ role: 'user', content });
-                    continue;
                 }
                 // system role (router hint 等) 直接保留
                 if (role === 'system') {
                     out.push({ role: 'system', content });
                     continue;
                 }
-                // 2026-06-30 修: assistant 消息如果带 toolCall (bolloon 内部对象), emit OpenAI 协议的 tool_calls 数组
-                //   minimax 严格要求 assistant 消息含 tool_calls 字段, 后续 tool result 才能引用 tool_call_id
-                if (role === 'assistant') {
-                    const tc = m.toolCall;
-                    if (tc && tc.id) {
-                        out.push({
-                            role: 'assistant',
-                            content: content || '',
-                            tool_calls: [{
-                                    id: tc.id,
-                                    type: 'function',
-                                    function: {
-                                        name: tc.name,
-                                        arguments: JSON.stringify(tc.args || {}),
-                                    },
-                                }],
-                        });
-                    }
-                    else {
-                        out.push({ role, content });
-                    }
-                    continue;
-                }
-                if (role === 'user') {
+                // assistant / user / tool 直接转
+                if (role === 'user' || role === 'assistant' || role === 'tool') {
                     out.push({ role, content });
                 }
             }
@@ -2899,8 +2255,7 @@ Workspace root folder: ${this.cwd}
                 // M3.5 (2026-06-17): 传 messages 数组 (如果 contextOrMessages 是数组) 或字符串
                 //   数组版让 LLM 看到结构化的 user/assistant/tool role, 而不是把 history 拼成单字符串
                 const response = await llm.chat(contextOrMessages, systemPrompt, signal);
-                // 2026-06-30: 透传 toolCalls (OpenAI 协议 native) 给上层, 让 assistant message 能 emit 真 id
-                return { reply: response.reply || '', toolCalls: response.toolCalls };
+                return { reply: response.reply || '' };
             }
             catch (err) {
                 // 用户主动 abort: 不重试, 立即抛
@@ -3026,375 +2381,100 @@ Workspace root folder: ${this.cwd}
         }
     }
     isFinalResponse(content) {
-        // 2026-06-30: 抽到 ./parse-tool-call.ts 作为纯函数 — 这里只构建 ctx 并调用
-        return isFinalResponseImpl(content, this._parseCtx());
+        // 只有明确输出 <final gen> 才认为是最终回答
+        return content.includes('<final gen>');
     }
     extractFinalAnswer(content) {
-        // 抽取实现已挪到 ./parse-tool-call.ts (纯函数, 易测)
-        return extractFinalAnswerImpl(content);
-    }
-    _parseCtx() {
-        return {
-            tools: new Set(Array.from(this.tools.keys())),
-            resolveAlias: (name) => this.resolveToolName(name),
-        };
-    }
-    parseToolCall(content) {
-        // 2026-06-30: 抽到 ./parse-tool-call.ts 作为纯函数 — 这里只构建 ctx 并调用
-        return parseToolCallImpl(content, this._parseCtx());
-    }
-    // [debug-2026-06-19] 临时: 打印 parseToolCall 输入和返回
-    _dbgParseToolCall(content) {
-        const r = this.parseToolCall(content);
-        console.log('[DBG parseToolCall] result:', JSON.stringify(r), 'content head:', JSON.stringify(content.substring(0, 200)));
-        return r;
-    }
-    /**
-     * 2026-06-24: 注册 Wallet + Polymarket + Safe 工具
-     *   真实实现 (ethers v6 + JsonRpcProvider) — agent 可以创建 EVM 钱包, 查余额, 转账, 签名, Polymarket 下单
-     *   工具来源: src/constraint-runtime/src/tools/{WalletTools,PolymarketSDK,SafeSDK}/
-     */
-    _registerWalletTools() {
-        // === WalletTools (EVM 钱包) ===
-        this.tools.set('wallet_create', {
-            name: 'wallet_create',
-            description: '创建新 EVM 钱包 (BIP-39 12 词助记词 + 私钥 + 地址). 私钥会在响应中返回, agent 应当保存到 ~/.bolloon/wallets/<address>.json',
-            parameters: {},
-            execute: async () => {
-                try {
-                    const { createWallet } = await import('../constraint-runtime/dist/tools/WalletTools/createWallet.js').catch(() => import('../constraint-runtime/src/tools/WalletTools/createWallet.js'));
-                    const r = await createWallet();
-                    return { success: true, output: `✅ 钱包创建成功:\n  address: ${r.address}\n  privateKey: ${r.privateKey}\n  mnemonic: ${r.mnemonic}\n  createdAt: ${r.createdAt}\n\n⚠️ 请 agent 立即把私钥保存到 ~/.bolloon/wallets/${r.address}.json` };
-                }
-                catch (e) {
-                    return { success: false, error: `创建失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('wallet_import', {
-            name: 'wallet_import',
-            description: '导入已有 EVM 钱包 (用助记词或私钥)',
-            parameters: { mnemonic: '可选, 12/15/18/21/24 词助记词', privateKey: '可选, 0x 开头的私钥' },
-            execute: async (args) => {
-                try {
-                    const { importWallet } = await import('../constraint-runtime/dist/tools/WalletTools/importWallet.js').catch(() => import('../constraint-runtime/src/tools/WalletTools/importWallet.js'));
-                    const r = await importWallet({ mnemonic: args.mnemonic, privateKey: args.privateKey });
-                    return { success: true, output: `✅ 钱包导入成功:\n  address: ${r.address}\n  privateKey: ${r.privateKey}\n  source: ${r.source}` };
-                }
-                catch (e) {
-                    return { success: false, error: `导入失败: ${String(e.message || e)}` };
-                }
+        // 提取 <final gen> 后的内容作为最终回答
+        const marker = '<final gen>';
+        const markerIndex = content.indexOf(marker);
+        if (markerIndex !== -1) {
+            const after = content.substring(markerIndex + marker.length).trim();
+            // v3 修复: 如果 <final gen> 之后是空, fallback 用 marker 之前的内容 (去掉 marker)
+            // 否则 LLM 写了 <final gen> 在末尾时, 用户看到空回复 + error
+            if (after) {
+                content = after;
             }
-        });
-        this.tools.set('wallet_get_balance', {
-            name: 'wallet_get_balance',
-            description: '查 EVM 钱包 ETH 余额. 默认 RPC = https://eth.llamarpc.com, 可指定其他 RPC URL',
-            parameters: { address: '0x 开头的 EVM 地址 (必填)', rpcUrl: '可选 RPC URL (默认 eth.llamarpc.com)' },
-            execute: async (args) => {
-                try {
-                    const { getBalance } = await import('../constraint-runtime/dist/tools/WalletTools/getBalance.js').catch(() => import('../constraint-runtime/src/tools/WalletTools/getBalance.js'));
-                    const r = await getBalance({ address: String(args.address), rpcUrl: args.rpcUrl });
-                    return { success: true, output: `💰 ${r.address}\n  ${r.balanceEth} ${r.symbol} (${r.balance} wei)` };
-                }
-                catch (e) {
-                    return { success: false, error: `查余额失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('wallet_sign_message', {
-            name: 'wallet_sign_message',
-            description: '用私钥对消息做 EIP-191 personal_sign 签名',
-            parameters: { message: '要签名的消息 (必填)', privateKey: '0x 开头的私钥 (必填)' },
-            execute: async (args) => {
-                try {
-                    const { signMessage } = await import('../constraint-runtime/dist/tools/WalletTools/signMessage.js').catch(() => import('../constraint-runtime/src/tools/WalletTools/signMessage.js'));
-                    const r = await signMessage({ message: String(args.message), privateKey: String(args.privateKey) });
-                    return { success: true, output: `✅ 签名完成:\n  address: ${r.address}\n  message: ${r.message}\n  signature: ${r.signature}` };
-                }
-                catch (e) {
-                    return { success: false, error: `签名失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('wallet_send_tx', {
-            name: 'wallet_send_tx',
-            description: '用 EVM 钱包发送交易 (转账 ETH 或调用合约). 走 EIP-1559, 默认 RPC = eth.llamarpc.com',
-            parameters: { privateKey: '私钥 (必填)', to: '接收地址 (必填)', value: '发送 wei 数量 (必填)', data: '可选 0x 开头的 calldata', rpcUrl: '可选 RPC URL' },
-            execute: async (args) => {
-                try {
-                    const { sendTransaction } = await import('../constraint-runtime/dist/tools/WalletTools/sendTransaction.js').catch(() => import('../constraint-runtime/src/tools/WalletTools/sendTransaction.js'));
-                    const r = await sendTransaction({
-                        privateKey: String(args.privateKey),
-                        to: String(args.to),
-                        value: String(args.value),
-                        data: args.data ? String(args.data) : undefined,
-                        rpcUrl: args.rpcUrl,
-                    });
-                    return { success: true, output: `✅ 交易已发送:\n  hash: ${r.hash}\n  from: ${r.from} → to: ${r.to}\n  value: ${r.value} wei\n  status: ${r.status}\n  blockNumber: ${r.blockNumber || '(pending)'}\n  gasUsed: ${r.gasUsed || '?'}` };
-                }
-                catch (e) {
-                    return { success: false, error: `交易失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('wallet_transfer_token', {
-            name: 'wallet_transfer_token',
-            description: '用 EVM 钱包转 ERC20 token (需要 token 合约地址)',
-            parameters: { privateKey: '私钥 (必填)', tokenAddress: 'ERC20 合约地址 (必填)', to: '接收地址 (必填)', amount: 'token 数量 (人类可读, 自动按 decimals 转换)', decimals: '可选 token decimals (默认查合约)', rpcUrl: '可选 RPC URL' },
-            execute: async (args) => {
-                try {
-                    const { transferToken } = await import('../constraint-runtime/dist/tools/WalletTools/transferToken.js').catch(() => import('../constraint-runtime/src/tools/WalletTools/transferToken.js'));
-                    const r = await transferToken({
-                        privateKey: String(args.privateKey),
-                        tokenAddress: String(args.tokenAddress),
-                        to: String(args.to),
-                        amount: String(args.amount),
-                        decimals: args.decimals ? Number(args.decimals) : undefined,
-                        rpcUrl: args.rpcUrl,
-                    });
-                    return { success: true, output: `✅ Token 转账完成:\n  hash: ${r.hash}\n  ${r.amount} ${r.tokenAddress.substring(0, 10)}...\n  from: ${r.from} → to: ${r.to}\n  status: ${r.status}` };
-                }
-                catch (e) {
-                    return { success: false, error: `转账失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('wallet_autopay', {
-            name: 'wallet_autopay',
-            description: '设置自动付款 (订阅/定期扣款, 用 SafeSDK 自动执行). 实际能力取决于 SafeSDK autopay 实现',
-            parameters: { from: '付款方地址 (必填)', to: '收款方地址 (必填)', amount: '金额 (必填)', interval: '周期 (e.g. daily/weekly/monthly)', token: '可选, 默认 ETH' },
-            execute: async (args) => {
-                try {
-                    const mod = await import('../constraint-runtime/dist/tools/WalletTools/autoPay.js').catch(() => import('../constraint-runtime/src/tools/WalletTools/autoPay.js'));
-                    const fn = mod.autoPay || mod.setAutoPay || mod.default;
-                    if (!fn)
-                        return { success: false, error: 'autoPay 接口未找到' };
-                    const r = await fn({
-                        from: String(args.from), to: String(args.to), amount: String(args.amount),
-                        interval: String(args.interval || 'monthly'), token: args.token,
-                    });
-                    return { success: true, output: `✅ 自动付款已设置: ${JSON.stringify(r)}` };
-                }
-                catch (e) {
-                    return { success: false, error: `设置失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        // === PolymarketSDK (预测市场) ===
-        this.tools.set('polymarket_list_markets', {
-            name: 'polymarket_list_markets',
-            description: '列出 Polymarket 预测市场 (用 Polymarket CLOB API). limit 默认 50',
-            parameters: { limit: '可选 数量 (默认 50)', offset: '可选 偏移', closed: '可选 是否只显示已关闭 (默认 false = 只显示活跃)' },
-            execute: async (args) => {
-                try {
-                    const { listMarkets } = await import('../constraint-runtime/dist/tools/PolymarketSDK/listMarkets.js').catch(() => import('../constraint-runtime/src/tools/PolymarketSDK/listMarkets.js'));
-                    const markets = await listMarkets({
-                        limit: args.limit ? Number(args.limit) : 50,
-                        offset: args.offset ? Number(args.offset) : 0,
-                        closed: args.closed ? String(args.closed) === 'true' : false,
-                    });
-                    if (!markets || markets.length === 0) {
-                        return { success: true, output: '📊 Polymarket 当前没有活跃市场 (或 API 不可达, 因为 constraint-runtime 是占位实现, 需要装 polymarket-sdk 包)' };
-                    }
-                    const lines = markets.slice(0, 10).map((m, i) => `  ${i + 1}. [${m.id}] ${m.question}\n     vol=${m.volume} active=${m.active}`);
-                    return { success: true, output: `📊 Polymarket 找到 ${markets.length} 个市场 (前 10):\n${lines.join('\n')}` };
-                }
-                catch (e) {
-                    return { success: false, error: `查询失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('polymarket_get_market', {
-            name: 'polymarket_get_market',
-            description: '获取单个 Polymarket 市场的详情 (id/conditionId 都可)',
-            parameters: { marketId: '市场 ID (必填)' },
-            execute: async (args) => {
-                try {
-                    const mod = await import('../constraint-runtime/dist/tools/PolymarketSDK/getMarket.js').catch(() => import('../constraint-runtime/src/tools/PolymarketSDK/getMarket.js'));
-                    const fn = mod.getMarket || mod.default;
-                    const m = await fn(String(args.marketId));
-                    if (!m)
-                        return { success: false, error: '市场不存在' };
-                    return { success: true, output: `📊 市场详情:\n  ${JSON.stringify(m, null, 2).substring(0, 1500)}` };
-                }
-                catch (e) {
-                    return { success: false, error: `查询失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('polymarket_get_orders', {
-            name: 'polymarket_get_orders',
-            description: '查询 Polymarket 订单 (需要 CLOB client + auth, 当前 constraint-runtime 是占位实现)',
-            parameters: { marketId: '可选 按市场 ID 过滤' },
-            execute: async (args) => {
-                try {
-                    const { getOrders } = await import('../constraint-runtime/dist/tools/PolymarketSDK/getOrders.js').catch(() => import('../constraint-runtime/src/tools/PolymarketSDK/getOrders.js'));
-                    const orders = await getOrders(args.marketId ? { marketId: String(args.marketId) } : {});
-                    return { success: true, output: `📋 订单列表: ${JSON.stringify(orders, null, 2).substring(0, 1500)}` };
-                }
-                catch (e) {
-                    return { success: false, error: `查询失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('polymarket_create_order', {
-            name: 'polymarket_create_order',
-            description: '在 Polymarket 下单 (BUY/SELL, price 0-1, size USDC). 当前 constraint-runtime 是占位实现, 实际下单需要 CLOB client + 私钥签名',
-            parameters: { marketId: '市场 ID (必填)', side: 'BUY 或 SELL (必填)', price: '价格 0-1 (必填)', size: '数量 USDC (必填)' },
-            execute: async (args) => {
-                try {
-                    const { createOrder } = await import('../constraint-runtime/dist/tools/PolymarketSDK/createOrder.js').catch(() => import('../constraint-runtime/src/tools/PolymarketSDK/createOrder.js'));
-                    const r = await createOrder({
-                        marketId: String(args.marketId),
-                        side: String(args.side).toUpperCase() === 'SELL' ? 'SELL' : 'BUY',
-                        price: Number(args.price),
-                        size: Number(args.size),
-                    });
-                    if (r.success)
-                        return { success: true, output: `✅ 订单: ${r.message}` };
-                    return { success: false, error: r.message, output: r.message };
-                }
-                catch (e) {
-                    return { success: false, error: `下单失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        this.tools.set('polymarket_cancel_order', {
-            name: 'polymarket_cancel_order',
-            description: '取消 Polymarket 订单 (order ID)',
-            parameters: { orderId: '订单 ID (必填)' },
-            execute: async (args) => {
-                try {
-                    const { cancelOrder } = await import('../constraint-runtime/dist/tools/PolymarketSDK/cancelOrder.js').catch(() => import('../constraint-runtime/src/tools/PolymarketSDK/cancelOrder.js'));
-                    const r = await cancelOrder({ orderId: String(args.orderId) });
-                    if (r.success)
-                        return { success: true, output: `✅ 取消订单: ${r.message}` };
-                    return { success: false, error: r.message, output: r.message };
-                }
-                catch (e) {
-                    return { success: false, error: `取消失败: ${String(e.message || e)}` };
-                }
-            }
-        });
-        // === SafeSDK (多签钱包) ===
-        this.tools.set('safe_deploy', {
-            name: 'safe_deploy',
-            description: '部署 Safe 多签钱包 (需要 owners/threshold 参数)',
-            parameters: { owners: 'JSON 数组 owner 地址 (必填)', threshold: '需要几个签名 (必填, e.g. 2)' },
-            execute: async (args) => {
-                try {
-                    const { deploySafe } = await import('../constraint-runtime/dist/tools/SafeSDK/deploySafe.js').catch(() => import('../constraint-runtime/src/tools/SafeSDK/deploySafe.js'));
-                    const owners = Array.isArray(args.owners) ? args.owners : JSON.parse(String(args.owners));
-                    const r = await deploySafe({ owners, threshold: Number(args.threshold) });
-                    return { success: true, output: `✅ Safe 部署: ${JSON.stringify(r)}` };
-                }
-                catch (e) {
-                    return { success: false, error: `部署失败: ${String(e.message || e)}` };
-                }
+            else {
+                content = content.substring(0, markerIndex).trim();
             }
-        });
-    }
-    /**
-     * 2026-06-19: 工具名大小写不敏感 + Claude Code 风格别名映射
-  
-    /**
-     * 2026-06-19: 工具名大小写不敏感 + Claude Code 风格别名映射
-     *   LLM 实际产出 Read/Edit/Write/Bash/Grep/Glob 等大写名 (Claude Code 工具命名)
-     *   bolloon 注册的是 read_document / edit_file / write_file / shell_exec / list_files
-     *   返回 this.tools 里的标准名, 或 null 表示未识别
-     */
-    /**
-     * 把 LLM 给的工具名 (可能大小写不一, 或者 Claude Code 风格的别名) 解析为
-     * bolloon 注册的标准工具名.
-     *
-     * 2026-06-30: 委托给 ToolRegistry 模块 — alias 表在 tool-registry.ts 统一维护,
-     *   这里只做 thin wrapper 保留 backward compat (private API 但其它地方可能用).
-     */
-    resolveToolName(name) {
-        return this._toolRegistry.resolve(name);
+        }
+        // 移除任何 tool call 标记
+        let cleaned = content
+            .replace(/调用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
+            .replace(/使用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
+            .replace(/tool[_\w]*[：:]\s*\w+\s*\([^)]*\)/gi, '')
+            .trim();
+        return cleaned;
     }
-    /**
-     * 2026-06-19: 注册 P2P 消息 listener, 把收到的消息存到 _inboxMessages 供 check_inbox 读.
-     *   监听 type='message' (send_to_peer) 和 type='agent-message' (P2P 远端 agent).
-     *   失败静默, 不阻塞 PiAgentSession 构造.
-     */
-    _setupInboxListener() {
-        if (!p2pNetwork || typeof p2pNetwork.onMessage !== 'function')
-            return;
-        try {
-            // 监听所有 type 的消息, 存储到 inbox
-            p2pNetwork.onMessage('*', (msg, from, did) => {
-                try {
-                    const text = new TextDecoder().decode(msg);
-                    // 解析 DID:|type:payload 格式
-                    let type = 'message';
-                    let payload = text;
-                    if (text.startsWith('DID:')) {
-                        const pipeIdx = text.indexOf('|');
-                        if (pipeIdx > 0) {
-                            const rest = text.substring(pipeIdx + 1);
-                            const colonIdx = rest.indexOf(':');
-                            if (colonIdx > 0) {
-                                type = rest.substring(0, colonIdx);
-                                payload = rest.substring(colonIdx + 1);
-                            }
-                            else {
-                                type = rest;
-                                payload = '';
-                            }
+    parseToolCall(content) {
+        const patterns = [
+            /调用工具[：:]\s*(\w+)\s*\(([^)]*)\)/,
+            /使用工具[：:]\s*(\w+)\s*\(([^)]*)\)/,
+            /tool[_\w]*[：:]\s*(\w+)\s*\(([^)]*)\)/i,
+            /(\w+)\s*\(\s*([^)]*)\s*\)/,
+            // 兼容 LLM 输出的对象字面量格式: {tool => "get_identity", args => {...}}
+            /\{\s*tool\s*=>\s*["'](\w+)["']\s*(?:,\s*args\s*=>\s*(\{[\s\S]*?\}))?\s*\}/,
+            // 兼容: tool => "get_identity"  (无 args 包裹)
+            /\btool\s*=>\s*["'](\w+)["']/,
+            // 兼容: [TOOL_CALL] 块内 JSON 形式 {"name": "x", "args": {...}}
+            /\[TOOL_CALL\][\s\S]*?\{\s*"name"\s*:\s*"(\w+)"\s*,\s*"args"\s*:\s*(\{[\s\S]*?\})/i,
+            // 2026-06-15 修: 兼容 LLM 输出的 XML 格式 <tool_name>...<arg>value</arg>...</tool_name>
+            //   实际 LLM 习惯: <shell_exec>\n<command>ls</command>\n<args>["-la", "..."]</args>\n</shell_exec>
+            /<(\w+)>([\s\S]*?)<\/\1>/,
+        ];
+        for (const pattern of patterns) {
+            const match = content.match(pattern);
+            if (match) {
+                const name = match[1];
+                let args = {};
+                const rawArgs = match[2] || '';
+                if (rawArgs && rawArgs.trim().startsWith('{')) {
+                    // JSON 形式, 尝试解析
+                    try {
+                        const parsed = JSON.parse(rawArgs);
+                        if (parsed && typeof parsed === 'object') {
+                            args = Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v)]));
                         }
                     }
-                    else {
-                        const colonIdx = text.indexOf(':');
-                        if (colonIdx > 0) {
-                            type = text.substring(0, colonIdx);
-                            payload = text.substring(colonIdx + 1);
+                    catch {
+                        // 解析失败就当字符串处理
+                        const argPairs = rawArgs.split(',').map(s => s.trim()).filter(Boolean);
+                        for (const pair of argPairs) {
+                            const [key, ...valueParts] = pair.split(':').map(s => s.trim().replace(/['"]/g, ''));
+                            if (key)
+                                args[key] = valueParts.join(':') || '';
                         }
                     }
-                    this._inboxMessages.push({
-                        id: `p2p-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-                        from: from.substring(0, 32),
-                        fromDid: did,
-                        type,
-                        payload,
-                        timestamp: Date.now(),
-                        source: 'p2p',
-                    });
-                    // 限制 inbox 大小, 防止内存泄漏
-                    if (this._inboxMessages.length > 1000) {
-                        this._inboxMessages = this._inboxMessages.slice(-1000);
+                }
+                else if (rawArgs && /<\w+>[\s\S]*<\/\w+>/.test(rawArgs)) {
+                    // 2026-06-15 修: XML 格式, 解析内嵌子标签 <argname>value</argname>
+                    //   例: <command>ls</command>\n<args>["-la","~/.bolloon/skills"]</args>
+                    const xmlArgPattern = /<(\w+)>([\s\S]*?)<\/\1>/g;
+                    let xmlMatch;
+                    while ((xmlMatch = xmlArgPattern.exec(rawArgs)) !== null) {
+                        const argName = xmlMatch[1];
+                        const argValue = xmlMatch[2].trim();
+                        if (argName && argValue) {
+                            args[argName] = argValue;
+                        }
                     }
                 }
-                catch (err) {
-                    console.warn('[PiAgent] inbox listener decode error:', err);
+                else if (rawArgs) {
+                    // 形参串, 形如 key: value, key2: value2
+                    const argPairs = rawArgs.split(',').map(s => s.trim()).filter(Boolean);
+                    for (const pair of argPairs) {
+                        const [key, ...valueParts] = pair.split(':').map(s => s.trim().replace(/['"]/g, ''));
+                        if (key)
+                            args[key] = valueParts.join(':') || '';
+                    }
                 }
-            });
-        }
-        catch (err) {
-            console.warn('[PiAgent] _setupInboxListener failed (non-fatal):', err);
-        }
-        // 监听本地 inbox bus 投递 (send_to_local_agent)
-        try {
-            const { LocalInboxBus } = require('../network/local-inbox-bus.js');
-            const myRole = process.env.BOLLOON_ROLE || 'default';
-            LocalInboxBus.getInstance().subscribe(myRole, (msg) => {
-                this._inboxMessages.push({
-                    id: `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-                    from: msg.from || 'unknown',
-                    fromDid: msg.fromDid,
-                    type: msg.type || 'agent-local-message',
-                    payload: msg.payload || '',
-                    timestamp: msg.timestamp || Date.now(),
-                    source: 'local',
-                });
-                if (this._inboxMessages.length > 1000) {
-                    this._inboxMessages = this._inboxMessages.slice(-1000);
+                if (this.tools.has(name) || this.tools.has(name.replace(/_/g, '_'))) {
+                    return { name, args };
                 }
-            });
-        }
-        catch (err) {
-            // LocalInboxBus 可能还没创建, 不阻塞
+            }
         }
+        return null;
     }
     estimateResponseQuality(response) {
         let score = 0.5;
@@ -3485,37 +2565,37 @@ Workspace root folder: ${this.cwd}
     getDefaultResponse(input) {
         const operationsRef = PiAgentSession.getOperationsReference();
         if (operationsRef) {
-            return `收到了: "${input}"
-
-我是一个判断力处理智能体，支持自然语言交互。
-
-可用操作（直接说出即可）:
-${this.extractOperationsFromRef(operationsRef)}
-
-示例请求:
-  - "读取 src/index.ts 文件"
-  - "总结一下 README.md"
-  - "查看当前连接了哪些节点"
+            return `收到了: "${input}"
+
+我是一个判断力处理智能体，支持自然语言交互。
+
+可用操作（直接说出即可）:
+${this.extractOperationsFromRef(operationsRef)}
+
+示例请求:
+  - "读取 src/index.ts 文件"
+  - "总结一下 README.md"
+  - "查看当前连接了哪些节点"
   - "向 QmABC... 发送测试消息"`;
         }
-        return `收到了: "${input}"
-
-我是一个判断力处理智能体，支持自然语言交互。
-
-可用操作（直接说出即可）:
-  - "读取 README.md" - 读取并分析文档
-  - "总结文档" - 总结文档内容
-  - "改进文档，按照X要求" - 改进文档
-  - "查看节点" - 查看已连接的对等节点
-  - "向X发送消息Y" - 向对等节点发送消息
-  - "广播消息X" - 广播消息到所有节点
-  - "查看身份" - 查看当前智能体身份
-  - "查看日志" - 查看最近操作日志
-
-示例请求:
-  - "读取 src/index.ts 文件"
-  - "总结一下 README.md"
-  - "查看当前连接了哪些节点"
+        return `收到了: "${input}"
+
+我是一个判断力处理智能体，支持自然语言交互。
+
+可用操作（直接说出即可）:
+  - "读取 README.md" - 读取并分析文档
+  - "总结文档" - 总结文档内容
+  - "改进文档，按照X要求" - 改进文档
+  - "查看节点" - 查看已连接的对等节点
+  - "向X发送消息Y" - 向对等节点发送消息
+  - "广播消息X" - 广播消息到所有节点
+  - "查看身份" - 查看当前智能体身份
+  - "查看日志" - 查看最近操作日志
+
+示例请求:
+  - "读取 src/index.ts 文件"
+  - "总结一下 README.md"
+  - "查看当前连接了哪些节点"
   - "向 QmABC... 发送测试消息"`;
     }
     extractOperationsFromRef(ref) {
@@ -3540,13 +2620,13 @@ ${this.extractOperationsFromRef(operationsRef)}
             }
         }
         return operationLines.length > 0 ? operationLines.join('\n') :
-            `  - "读取 README.md" - 读取并分析文档
-  - "总结文档" - 总结文档内容
-  - "改进文档，按照X要求" - 改进文档
-  - "查看节点" - 查看已连接的对等节点
-  - "向X发送消息Y" - 向对等节点发送消息
-  - "广播消息X" - 广播消息到所有节点
-  - "查看身份" - 查看当前智能体身份
+            `  - "读取 README.md" - 读取并分析文档
+  - "总结文档" - 总结文档内容
+  - "改进文档，按照X要求" - 改进文档
+  - "查看节点" - 查看已连接的对等节点
+  - "向X发送消息Y" - 向对等节点发送消息
+  - "广播消息X" - 广播消息到所有节点
+  - "查看身份" - 查看当前智能体身份
   - "查看日志" - 查看最近操作日志`;
     }
     async suggestRename(messages) {
@@ -3886,14 +2966,11 @@ export async function createAgentSession(config, forceNew) {
         const key = config.peerId;
         if (!forceNew && independentSessions.has(key)) {
             console.log(`[createAgentSession] 找到现有独立 session, key=${key}`);
-            const existing = independentSessions.get(key);
-            await existing.whenReady();
-            return existing;
+            return independentSessions.get(key);
         }
         const session = new PiAgentSession(config);
         independentSessions.set(key, session);
         console.log(`[createAgentSession] 创建独立 session, key=${key}, DID=${incomingDid}`);
-        await session.whenReady();
         return session;
     }
     // 如果指定了 forceNew 但没有 peerId，生成带时间戳的 key
@@ -3902,7 +2979,6 @@ export async function createAgentSession(config, forceNew) {
         const session = new PiAgentSession(config);
         independentSessions.set(key, session);
         console.log(`[createAgentSession] 创建强制新 session, key=${key}`);
-        await session.whenReady();
         return session;
     }
     // 如果有新的 DID，强制重建 session
@@ -3922,13 +2998,11 @@ export async function createAgentSession(config, forceNew) {
                 createdAt: Date.now()
             });
         }
-        await sessionInstance.whenReady();
         return sessionInstance;
     }
     sessionInstance = new PiAgentSession(config);
     lastIdentityDid = config.identityDoc?.did || null;
     console.log(`[createAgentSession] 新建 session, DID=${lastIdentityDid}`);
-    await sessionInstance.whenReady();
     return sessionInstance;
 }
 export function getAgentSession() {