@bolloon/bolloon-agent 0.3.52 → 0.4.0

package/bin/bolloon.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+const path = require("path");
+const { spawn } = require("child_process");
+const fs = require("fs");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const MAGENTA = "\x1b[35m";
+
+function log(msg, color) {
+  console.log((color || RESET) + msg + RESET);
+}
+
+function printBanner() {
+  console.log("\n" + CYAN + BOLD + [
+    "   ╔═══════════════════════════════════════════╗",
+    "   ║      🤖 Bolloon Agent                     ║",
+    "   ║      P2P AI Document Processor            ║",
+    "   ╚═══════════════════════════════════════════╝"
+  ].join("\n") + RESET + "\n");
+}
+
+function getMainEntry() {
+  const distDir = path.dirname(require.main.filename);
+  const distIndex = path.join(distDir, "index.js");
+  if (fs.existsSync(distIndex)) {
+    return distIndex;
+  }
+  return path.join(process.cwd(), "src", "index.ts");
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    return { mode: "gui", args: [] };
+  }
+  const first = args[0];
+  switch (first) {
+    case "-v":
+    case "--version":
+      return { mode: "version", args: [] };
+    case "-h":
+    case "--help":
+      return { mode: "help", args: [] };
+    case "-g":
+    case "--gui":
+      return { mode: "gui", args: args.slice(1) };
+    case "-w":
+    case "--web":
+      return { mode: "web", args: args.slice(1) };
+    case "-c":
+    case "--cli":
+      return { mode: "cli", args: args.slice(1) };
+    default:
+      return { mode: "passthrough", args };
+  }
+}
+
+async function startElectron(additionalArgs) {
+  try {
+    const electron = require("electron");
+    const distDir = path.dirname(require.main.filename);
+    let mainPath = path.join(distDir, "electron.js");
+    if (!fs.existsSync(mainPath)) {
+      mainPath = path.join(process.cwd(), "src", "electron.ts");
+    }
+    log("启动 Electron...", CYAN);
+    const child = spawn(electron, [mainPath, ...additionalArgs], {
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    child.on("error", (err) => {
+      log("Electron 启动失败: " + err.message, MAGENTA);
+      process.exit(1);
+    });
+    child.on("exit", (code) => process.exit(code || 0));
+  } catch (err) {
+    log("Electron 不可用，切换到 Web 模式...", CYAN);
+    await startWebServer(additionalArgs);
+  }
+}
+
+async function startWebServer(additionalArgs) {
+  const mainPath = getMainEntry();
+  const webArgs = ["--web", ...additionalArgs];
+  log("启动 Web 服务...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...webArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("Web 服务启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function startCLI(additionalArgs) {
+  const mainPath = getMainEntry();
+  log("启动命令行界面...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...additionalArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("CLI 启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function main() {
+  const { mode, args } = parseArgs();
+  switch (mode) {
+    case "version":
+      console.log("Bolloon Agent v0.1.1");
+      break;
+    case "help":
+      printBanner();
+      console.log(BOLD + "用法:" + RESET + "  bolloon [选项] [命令] [参数]");
+      console.log(BOLD + "选项:" + RESET + "  --gui, -g           启动图形界面");
+      console.log("         --web, -w           启动 Web UI");
+      console.log("         --cli, -c           启动命令行界面");
+      console.log("         --version, -v       显示版本");
+      console.log("         --help, -h          显示帮助");
+      console.log(BOLD + "示例:" + RESET + "  bolloon              # 启动图形界面");
+      console.log("         bolloon --web        # 启动 Web UI");
+      console.log("         bolloon --read file  # 读取文档");
+      break;
+    case "gui":
+      printBanner();
+      await startElectron(args);
+      break;
+    case "web":
+      printBanner();
+      await startWebServer(args);
+      break;
+    case "cli":
+      await startCLI(args);
+      break;
+    case "passthrough":
+      const mainPath = getMainEntry();
+      const child = spawn(process.execPath, [mainPath, ...args], { stdio: "inherit" });
+      child.on("error", (err) => {
+        log("执行失败: " + err.message, MAGENTA);
+        process.exit(1);
+      });
+      child.on("exit", (code) => process.exit(code || 0));
+      break;
+    default:
+      log("未知模式: " + mode, MAGENTA);
+      printBanner();
+      console.log("输入 --help 查看帮助");
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/dist/agents/constraint-layer.js

@@ -7,25 +7,25 @@ import { ToolPermissionContext, BudgetTracker } from '@bolloon/constraint-runtim
  * System prompt for constraint layer
  * Defines boundaries and autonomous permissions
  */
-export const SYSTEM_PROMPT = `
-你是一个文档处理Agent，在以下规则下运行：
-
-【边界规则】
-1. 只处理：txt, md, pdf, docx 格式文档
-2. 不修改原始文件，只输出改进版本
-3. 发送前必须记录操作日志
-
-【自主权限】
-- ✅ 自主决定：摘要详细程度、chunk分块策略
-- ✅ 自主决定：重试次数（最多3次）
-- ✅ 自主决定：是否需要补充信息
-- ❌ 必须确认：首次向新对等节点发送文档
-- ❌ 必须确认：删除操作
-
-【敏感操作拦截】
-if (操作 === '发送文档' && 对等节点不在已知列表) {
-  拦截 → 记录 → 等待确认
-}
+export const SYSTEM_PROMPT = `
+你是一个文档处理Agent，在以下规则下运行：
+
+【边界规则】
+1. 只处理：txt, md, pdf, docx 格式文档
+2. 不修改原始文件，只输出改进版本
+3. 发送前必须记录操作日志
+
+【自主权限】
+- ✅ 自主决定：摘要详细程度、chunk分块策略
+- ✅ 自主决定：重试次数（最多3次）
+- ✅ 自主决定：是否需要补充信息
+- ❌ 必须确认：首次向新对等节点发送文档
+- ❌ 必须确认：删除操作
+
+【敏感操作拦截】
+if (操作 === '发送文档' && 对等节点不在已知列表) {
+  拦截 → 记录 → 等待确认
+}
 `;
 /**
  * Actions that can be executed autonomously without confirmation

package/dist/agents/judgment-protocol.js

@@ -148,20 +148,20 @@ export async function distillDissent(ask) {
         .slice(-10)
         .flatMap((j) => j.reasons || [])
         .slice(0, 20);
-    const prompt = `你是用户的判断力代理. 用户发起了一个决定: "${ask.decision}"
-${ask.context ? `\n补充: ${ask.context}` : ''}
-
-[用户价值画像] ${valueHint}
-[相关历史判断 (${relevant.length} 条)] ${relevant.slice(0, 3).map((j) => j.decision || '').join(' | ').slice(0, 300)}
-[历史理由样本] ${recentReasons.join(' | ').slice(0, 400) || '(无)'}
-
-请基于上述判断力, 生成正好 3 个"反方观点" (用户应该考虑但可能忽略的风险/盲点).
-要求:
-- 每个反方 1-2 句, 总长 < 80 字
-- 必须是这个特定决定的"反对声音", 不是通用建议
-- 第 1 个: 历史/经验类风险
-- 第 2 个: 关系/信任类风险
-- 第 3 个: 隐藏代价/时间类风险
+    const prompt = `你是用户的判断力代理. 用户发起了一个决定: "${ask.decision}"
+${ask.context ? `\n补充: ${ask.context}` : ''}
+
+[用户价值画像] ${valueHint}
+[相关历史判断 (${relevant.length} 条)] ${relevant.slice(0, 3).map((j) => j.decision || '').join(' | ').slice(0, 300)}
+[历史理由样本] ${recentReasons.join(' | ').slice(0, 400) || '(无)'}
+
+请基于上述判断力, 生成正好 3 个"反方观点" (用户应该考虑但可能忽略的风险/盲点).
+要求:
+- 每个反方 1-2 句, 总长 < 80 字
+- 必须是这个特定决定的"反对声音", 不是通用建议
+- 第 1 个: 历史/经验类风险
+- 第 2 个: 关系/信任类风险
+- 第 3 个: 隐藏代价/时间类风险
 - 用 JSON 数组返回: ["反方1", "反方2", "反方3"]`;
     // LLM 调用 (OpenAI 兼容, 复用 p2p-chat-tools 的方式)
     let dissents = [];

package/dist/agents/loop-review.js

@@ -61,6 +61,7 @@ export function buildReviewHint(state, maxReviews = DEFAULT_MAX_REVIEWS) {
         `\n用户需求: ${intent.slice(0, 300)}` +
         actionLines +
         `\n已完成工具: ${tools}` +
+        `\n[完成契约] 宣布 <final gen> 前必须展示具体证据 (命令输出 / 文件内容 / 测试结果), 只写结论不算完成.` +
         `\n请对照需求逐条自查: 用户需求是否每一项都真正完成了? 如果还有未完成的子目标或自然衔接的后续步骤 → 继续调用工具推进 (已完成动作不要重复, 直接基于已有结果做下一步); ` +
         `如果用户需求已全部满足 → 直接输出 <final gen> 结束.` +
         `\n[重要] 不要因为做了一部分就提前结束 — 结束前逐条对照「用户需求」确认每一项都完成.`);
@@ -69,3 +70,23 @@ export function buildReviewHint(state, maxReviews = DEFAULT_MAX_REVIEWS) {
 export function shouldReviewAgain(state, maxReviews = DEFAULT_MAX_REVIEWS) {
     return decideAfterReview(state, maxReviews).kind === 'continue-review';
 }
+/** 判定连续 window 次完全相同的工具调用 (循环签名) */
+export function detectRepeatingCalls(recent, window = 3) {
+    if (recent.length < window)
+        return { repeating: false };
+    const tail = recent.slice(-window);
+    const first = tail[0];
+    const same = tail.every((c) => c.name === first.name && c.argsHash === first.argsHash);
+    return same ? { repeating: true, name: first.name } : { repeating: false };
+}
+/** 工具调用参数稳定哈希 (排序键, 顺序无关) */
+export function toolCallArgsHash(args) {
+    try {
+        const obj = (args ?? {});
+        const keys = Object.keys(obj).sort();
+        return JSON.stringify(keys.map((k) => [k, obj[k]]));
+    }
+    catch {
+        return String(args ?? {});
+    }
+}

package/dist/agents/pi-sdk-tools.js

@@ -490,13 +490,25 @@ export function registerBuiltinTools(ctx) {
                 return { success: false, error: 'prompt 必填' };
             const cwd = args.cwd ? String(args.cwd).trim() : undefined;
             const model = args.model ? String(args.model).trim() : undefined;
-            const result = await delegateToEngine(engine, prompt, { cwd: cwd || undefined, ...(model ? { model } : {}) });
+            // 2026-08-11: 委派句柄 — ownerDid 绑当前 agent DID (防跨 channel 使用),
+            // correlationId 幂等去重 (同一 agent 重复 correlation 只应出现一次)
+            const ownerDid = ctx.identity?.did || 'unknown';
+            const correlationId = `delegate:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
+            const result = await delegateToEngine(engine, prompt, {
+                cwd: cwd || undefined,
+                ...(model ? { model } : {}),
+                ownerDid,
+                correlationId,
+            });
             if (!result.success) {
                 return { success: false, error: result.error, output: result.output };
             }
+            const handleLine = result.handle
+                ? `\n[delegate handle] contractVersion=${result.handle.contractVersion} delegateId=${result.handle.delegateId} ownerDid=${result.handle.ownerDid} correlationId=${result.handle.correlationId ?? '-'} capability=${result.handle.capability.slice(0, 16)}...`
+                : '';
             return {
                 success: true,
-                output: `🤖 ${engine} 执行结果 (exitCode=${result.exitCode}):\n${result.output || '(无输出)'}`
+                output: `🤖 ${engine} 执行结果 (exitCode=${result.exitCode}):\n${result.output || '(无输出)'}${handleLine}`
             };
         }
     });
@@ -1930,6 +1942,78 @@ export function registerBuiltinTools(ctx) {
             }
         }
     });
+    // ============================================================
+    // verify_project (2026-08-11, Hermes agent/verify recipes 模式)
+    // 从项目 package.json scripts 提取验证命令依序执行 (build→typecheck→test→check→lint)
+    // 完成契约 (B7) 的证据工具: 宣布完成前跑一遍, 输出命令/exit code/耗时
+    // ============================================================
+    ctx.tools.set('verify_project', {
+        name: 'verify_project',
+        description: '运行项目验证配方 (Hermes verify recipes 模式): 从 package.json scripts 自动提取 build/typecheck/test/check/lint 依序执行, 返回每步命令+exit code+耗时+输出尾部. 修改代码后、宣布完成前调用 — 提供完成契约要求的证据. cwd 选项目根 (默认当前工作目录).',
+        parameters: {
+            cwd: '项目根目录 (可选, 默认当前 cwd)',
+        },
+        execute: async (args) => {
+            try {
+                const { readFileSync, readdirSync } = await import('fs');
+                const { extractVerifyCommands, detectPackageManager, runVerifyCommands } = await import('./verify-recipe.js');
+                const cwd = String(args.cwd || process.cwd()).trim() || process.cwd();
+                let pkg = {};
+                try {
+                    pkg = JSON.parse(readFileSync(`${cwd}/package.json`, 'utf-8'));
+                }
+                catch {
+                    return { success: false, error: `${cwd}/package.json 不存在或非法 — verify_project 只支持 npm/pnpm/yarn/bun 项目` };
+                }
+                const scripts = (pkg.scripts ?? {});
+                const pm = detectPackageManager(readdirSync(cwd).map((f) => f.toLowerCase()));
+                const commands = extractVerifyCommands(scripts, pm);
+                if (commands.length === 0) {
+                    return { success: false, error: 'package.json scripts 里没有 build/typecheck/test/check/lint 任何一步 — 无可验证' };
+                }
+                const r = await runVerifyCommands({ cwd, commands });
+                const lines = r.steps.map((s) => `  ${s.exitCode === 0 ? '✅' : '❌'} ${s.name} (${s.command}) → exit ${s.exitCode ?? 'ERR'} ${s.durationMs}ms${s.timedOut ? ' [超时]' : ''}`);
+                const failedStep = r.steps.find((s) => s.exitCode !== 0 || s.timedOut);
+                return {
+                    success: r.allPassed,
+                    output: `${r.allPassed ? '✅ 验证全部通过' : '❌ 验证失败'} (${r.steps.filter((s) => s.exitCode === 0).length}/${r.steps.length} 步):\n${lines.join('\n')}${failedStep ? `\n\n失败输出尾部:\n${failedStep.outputTail.slice(-1500)}` : ''}`,
+                    ...(r.allPassed ? {} : { error: `验证失败于 ${failedStep?.name} (exit ${failedStep?.exitCode})` }),
+                };
+            }
+            catch (e) {
+                return { success: false, error: `verify_project 失败: ${String(e).slice(0, 200)}` };
+            }
+        },
+    });
+    ctx.tools.set('mcp_list_catalog', {
+        name: 'mcp_list_catalog',
+        description: '列出 Bolloon 审核过的可选 MCP 目录 (Hermes optional-mcps 模式: 默认禁用, 显式安装才生效). 想看"有哪些外部工具可以接"时用这个; 已接入的看 mcp_list_tools.',
+        parameters: {},
+        execute: async () => {
+            try {
+                // fs 读 manifests/mcp-catalog.json — 构建后 dist/agents/../../manifests = 仓库根/manifests
+                const { readFileSync } = await import('fs');
+                const raw = readFileSync(new URL('../../manifests/mcp-catalog.json', import.meta.url), 'utf-8');
+                const catalog = JSON.parse(raw);
+                const entries = (catalog?.entries ?? []);
+                if (entries.length === 0) {
+                    return { success: true, output: '📦 MCP 目录为空. 新增条目: manifests/mcp-catalog.json (实测可用才收录).' };
+                }
+                const lines = entries.map((e) => {
+                    const t = e.transport?.type ?? 'unknown';
+                    const addr = e.transport?.url ?? e.transport?.command ?? '';
+                    return `  - ${e.name} [${t}] ${addr ? '(' + addr + ')' : ''}: ${e.description?.slice(0, 70) || ''}`;
+                });
+                return {
+                    success: true,
+                    output: `📦 可选 MCP 目录 (${entries.length} 条, 默认禁用):\n${lines.join('\n')}\n\n安装: 把条目按 mcpServers 格式写进 ~/.mcp.json, 重启后 mcp_list_tools 可见. 版本必须精确 pin (Hermes 纪律).`,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `mcp_list_catalog 失败: ${String(e).slice(0, 200)}` };
+            }
+        },
+    });
     ctx.tools.set('mcp_tool', {
         name: 'mcp_tool',
         description: '调用外部 MCP 工具 (真实 stdio JSON-RPC 通信). tool = 工具名 (先用 mcp_list_tools 查看), arguments = 参数 JSON 对象.',

package/dist/agents/pi-sdk-types.js

@@ -1,13 +1,13 @@
-export 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() - 获取操作日志
+export 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() - 获取操作日志
 `;

package/dist/agents/pi-sdk.js

@@ -1042,38 +1042,38 @@ export 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)
-- 工具调用后必须等结果, 不要在同一个回复里继续输出
+        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}`;
         // 2026-06-15: 把 currentOnStream 传给 loop, 让 step-timeline 在 pivot 循环里也能 emit step_start/done
         //   之前 loop.execute() 不接 streamCallback, 导致 step-timeline 只能看到老 runReActLoop 路径
@@ -1265,10 +1265,10 @@ ${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;
@@ -1286,26 +1286,26 @@ ${this.getToolDefinitions()}
                     .join('\n');
                 loopProgressSection = `\n【本轮循环进度】你已完成以下 ${loopActionLog.length} 个动作, 这是连续执行的同一轮任务:\n${actionLines}\n请基于已有结果继续推进, 不要重复执行上面已成功的动作. 全部完成后用 <final gen> 结束.\n`;
             }
-            const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
-当前工作目录: ${this.cwd}
-当前身份: ${this.identity.name} (${this.identity.did})
-${refineContext}
-${this.currentIntentHint}
-${loopProgressSection}
-
-${toolDefs}
-
-工作模式:
-1. 理解用户自然语言请求
-2. 分析需要哪些工具来完成
-3. 按顺序调用工具并观察结果
-4. 根据观察结果决定下一步
-5. 最终给出完整回答
-
-重要:
-- 每次只调用一个工具
-- 仔细分析工具返回结果
-- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+            const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+当前工作目录: ${this.cwd}
+当前身份: ${this.identity.name} (${this.identity.did})
+${refineContext}
+${this.currentIntentHint}
+${loopProgressSection}
+
+${toolDefs}
+
+工作模式:
+1. 理解用户自然语言请求
+2. 分析需要哪些工具来完成
+3. 按顺序调用工具并观察结果
+4. 根据观察结果决定下一步
+5. 最终给出完整回答
+
+重要:
+- 每次只调用一个工具
+- 仔细分析工具返回结果
+- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
 - 如果需要更多信息，继续调用工具${this.judgmentGateAddition}${this.contextHintAddition}`;
             // 3 个恢复机制 (Claude Code 论文 9-step pipeline 内部):
             //   1. max output token 升级 (最多 3 次, 每次 maxOutputTokens 翻倍)
@@ -2376,37 +2376,37 @@ ${toolDefs}
     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) {
@@ -2431,13 +2431,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) {