@bolloon/bolloon-agent 0.1.1 → 0.1.3

package/src/agents/pi-sdk.ts

@@ -12,6 +12,7 @@ import { p2pNetwork } from '../network/p2p.js';
 import { ConstraintLayer, WorkflowContext } from './constraint-layer.js';
 import { WorkflowEngine, WorkflowStep, StepResult, Workflow } from './workflow-engine.js';
 import { DeepThinkingEngine, AgentCoordinator, type ThinkResult, type AgentResult } from '@bolloon/constraint-runtime';
+import { WorkflowPivotLoop, createDefaultPivotConfig, type PivotLoopConfig, type LoopResult } from './workflow-pivot-loop.js';
 import {
   DiscoveredAgentsManager,
   SocialHeartbeat,
@@ -42,6 +43,8 @@ export interface AgentSessionConfig {
   cwd: string;
   peerId?: string;
   identityDoc?: IdentityDoc;
+  usePivotLoop?: boolean;
+  pivotLoopConfig?: PivotLoopConfig;
 }
 
 export interface IdentityDoc {
@@ -487,6 +490,7 @@ export interface HeartbeatConfig {
 export interface AgentSession {
   prompt(input: string): Promise<string>;
   promptStream(input: string, onStream: StreamCallback): Promise<string>;
+  promptWithPivotLoop(input: string, config?: PivotLoopConfig): Promise<LoopResult>;
   suggestRename(messages: { type: string; content: string }[]): Promise<string | null>;
   readDocument(filePath: string): Promise<string>;
   summarizeDocument(filePath: string, context?: string): Promise<{
@@ -546,11 +550,15 @@ class PiAgentSession implements AgentSession {
   private messageHistory: Message[] = [];
   private tools: Map<string, Tool> = new Map();
   private skillRegistry: SkillRegistry = new SkillRegistry();
-  private readonly MAX_REACT_ITERATIONS = 10;
+  private readonly MAX_REACT_ITERATIONS = 100;
+  private readonly MAX_REFINE_ATTEMPTS = 3;
+  private readonly QUALITY_THRESHOLD = 0.6;
   private thinkingEngine = new DeepThinkingEngine(3);
   private coordinator = new AgentCoordinator(3);
   private harness: any = null;
   private harnessEnabled = false;
+  private usePivotLoop: boolean = false;
+  private pivotLoopConfig?: PivotLoopConfig;
 
   constructor(config: AgentSessionConfig) {
     this.cwd = config.cwd;
@@ -561,6 +569,8 @@ class PiAgentSession implements AgentSession {
     this.workflowEngine = new WorkflowEngine(this.constraintLayer);
     this.sessionManager = new PiSessionManager(this.identity.did, this.cwd);
     this.agentsManager = new DiscoveredAgentsManager();
+    this.usePivotLoop = config.usePivotLoop ?? false;
+    this.pivotLoopConfig = config.pivotLoopConfig;
     this.initSession();
     this.registerTools();
     this.initHarness();
@@ -739,6 +749,58 @@ class PiAgentSession implements AgentSession {
         };
       }
     });
+
+    // 添加文件列表工具
+    this.tools.set('list_files', {
+      name: 'list_files',
+      description: '列出目录中的文件',
+      parameters: { path: '目录路径（可选，默认为当前目录）' },
+      execute: async (args) => {
+        try {
+          const fs = await import('fs');
+          const path = args.path || this.cwd;
+          const files = fs.readdirSync(path);
+          return {
+            success: true,
+            output: `📁 目录 ${path} 中的文件 (${files.length} 个):\n${files.slice(0, 20).map(f => `  - ${f}`).join('\n')}${files.length > 20 ? '\n  ...' : ''}`
+          };
+        } catch (e) {
+          return { success: false, error: String(e) };
+        }
+      }
+    });
+
+    // 添加目录读取工具（更完整的实现）
+    this.tools.set('read_directory', {
+      name: 'read_directory',
+      description: '读取目录内容，返回文件列表和目录结构',
+      parameters: { path: '目录路径（可选，默认为当前目录）' },
+      execute: async (args) => {
+        try {
+          const fs = await import('fs');
+          const pathModule = await import('path');
+          const targetPath = args.path || this.cwd;
+          const items = fs.readdirSync(targetPath);
+          const result: string[] = [];
+          for (const item of items.slice(0, 30)) {
+            const fullPath = pathModule.join(targetPath, item);
+            try {
+              const stat = fs.statSync(fullPath);
+              const type = stat.isDirectory() ? '📁' : '📄';
+              result.push(`${type} ${item}${stat.isDirectory() ? '/' : ''}`);
+            } catch {
+              result.push(`📄 ${item}`);
+            }
+          }
+          return {
+            success: true,
+            output: `📂 ${targetPath} (${items.length} 项):\n${result.join('\n')}${items.length > 30 ? '\n... 还有更多文件' : ''}`
+          };
+        } catch (e) {
+          return { success: false, error: `无法读取目录: ${String(e)}` };
+        }
+      }
+    });
   }
 
   private getToolDefinitions(): string {
@@ -803,7 +865,7 @@ class PiAgentSession implements AgentSession {
       content: input
     });
 
-    onStream({ type: 'thinking', content: '🤔 思考中...' });
+    onStream({ type: 'thinking', content: '🤔 开始思考...' });
 
     if (!this.minimaxAvailable) {
       const response = await this.handleFallback(input);
@@ -812,22 +874,113 @@ class PiAgentSession implements AgentSession {
       return response;
     }
 
-    const result = await this.runReActLoop();
+    const result = await this.runReActLoop(onStream);
     onStream({ type: 'done', content: '' });
     return result;
   }
 
-  private async runReActLoop(): Promise<string> {
+  async promptWithPivotLoop(input: string, config?: PivotLoopConfig): Promise<LoopResult> {
+    if (!this.minimaxAvailable) {
+      const response = await this.handleFallback(input);
+      return {
+        success: false,
+        response,
+        iterations: 0,
+        toolCalls: 0,
+        qualityScore: 0,
+        exitReason: 'error',
+        state: {
+          iteration: 0,
+          totalTokens: 0,
+          toolCallsCount: 0,
+          consecutiveNoProgress: 0,
+          qualityScores: [],
+          pendingToolUses: [],
+          lastMeaningfulWork: 0
+        }
+      };
+    }
+
+    const llm = getMinimax();
+    const loopConfig = config || this.pivotLoopConfig || createDefaultPivotConfig();
+    const loop = new WorkflowPivotLoop(loopConfig);
+
+    for (const tool of this.tools.values()) {
+      loop.registerTool(tool);
+    }
+
+    const personaSection = this.persona ? `
+角色描述: ${this.persona.description || '无'}
+性格特点: ${this.persona.personality || '无'}
+问候语: ${this.persona.greeting || '无'}
+` : '';
+
+    const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+当前工作目录: ${this.cwd}
+当前身份: ${this.identity.name} (${this.identity.did})
+
+${this.getToolDefinitions()}
+
+工作模式:
+1. 理解用户自然语言请求
+2. 分析需要哪些工具来完成
+3. 按顺序调用工具并观察结果
+4. 根据观察结果决定下一步
+5. 最终给出完整回答
+
+重要:
+- 每次只调用一个工具
+- 仔细分析工具返回结果
+- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+- 如果需要更多信息，继续调用工具`;
+
+    const result = await loop.execute(input, llm, systemPrompt);
+
+    this.messageHistory.push({ role: 'user', content: input });
+    if (result.response) {
+      this.messageHistory.push({ role: 'assistant', content: result.response });
+    }
+
+    return result;
+  }
+
+  private async runReActLoop(onStream?: StreamCallback): Promise<string> {
     const llm = getMinimax();
     let iteration = 0;
     let finalResponse = '';
+    let lastQualityScore = 0;
+    let refineAttempts = 0;
+    let consecutiveErrors = 0;
+    const MAX_CONSECUTIVE_ERRORS = 3;
+
+    // 发送循环开始的事件
+    if (onStream) {
+      onStream({ type: 'status', content: '🔄 开始 ReAct 循环...', tool: 'system' });
+    }
 
     while (iteration < this.MAX_REACT_ITERATIONS) {
       iteration++;
 
+      // 调试日志：显示每次循环开始
+      console.log(`[PiAgent] 循环 ${iteration}/${this.MAX_REACT_ITERATIONS} 开始`);
+      if (onStream) {
+        onStream({ type: 'status', content: `🔄 循环 ${iteration}/${this.MAX_REACT_ITERATIONS}`, tool: 'loop' });
+      }
+
       const context = this.buildContext();
       const toolDefs = this.getToolDefinitions();
 
+      // 动态构建 refine 上下文
+      let refineContext = '';
+      if (refineAttempts > 0 && lastQualityScore < this.QUALITY_THRESHOLD) {
+        refineContext = `\n【改进提示】上轮结果质量分 ${(lastQualityScore * 10).toFixed(1)}/10，请改进回答。`;
+      }
+
+      // 连续错误时的额外提示
+      if (consecutiveErrors > 0) {
+        refineContext += `\n【错误提示】上轮发生 ${consecutiveErrors} 次错误，请重新分析问题或换一种方式处理。`;
+      }
+
       const personaSection = this.persona ? `
 角色描述: ${this.persona.description || '无'}
 性格特点: ${this.persona.personality || '无'}
@@ -837,6 +990,7 @@ class PiAgentSession implements AgentSession {
       const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
 当前工作目录: ${this.cwd}
 当前身份: ${this.identity.name} (${this.identity.did})
+${refineContext}
 
 ${toolDefs}
 
@@ -850,13 +1004,30 @@ ${toolDefs}
 重要:
 - 每次只调用一个工具
 - 仔细分析工具返回结果
-- 如果任务完成，返回完整回答
+- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
 - 如果需要更多信息，继续调用工具`;
 
       const response = await llm.chat(context, systemPrompt);
       const reply = response.reply.trim();
 
+      console.log(`[PiAgent] LLM 回复长度: ${reply.length}, 内容预览: "${reply.substring(0, 80)}..."`);
+
+      // 通知前端：收到 LLM 回复
+      if (onStream) {
+        onStream({ type: 'token', content: reply.substring(0, 100) });
+      }
+
       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;
       }
@@ -869,30 +1040,132 @@ ${toolDefs}
           toolCall
         });
 
+        // 通知前端：检测到工具调用
+        if (onStream) {
+          onStream({ type: 'tool', content: `🔧 调用工具: ${toolCall.name}`, tool: toolCall.name });
+          if (toolCall.args && Object.keys(toolCall.args).length > 0) {
+            onStream({ type: 'status', content: `📋 参数: ${JSON.stringify(toolCall.args)}`, tool: toolCall.name });
+          }
+        }
+
         const tool = this.tools.get(toolCall.name);
         if (!tool) {
+          consecutiveErrors++;
           const errorResult: ToolResult = { success: false, error: `未知工具: ${toolCall.name}` };
           this.messageHistory.push({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
           this.logToHarness(toolCall.name, toolCall.args, errorResult);
+          console.warn(`[PiAgent] 未知工具: ${toolCall.name}，跳过并继续`);
           continue;
         }
 
-        const result = await tool.execute(toolCall.args);
-        this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result });
-        this.logToHarness(toolCall.name, toolCall.args, result);
+        try {
+          const result = await tool.execute(toolCall.args);
+          console.log(`[PiAgent] 工具 ${toolCall.name} 执行完成: success=${result.success}`);
+          this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result });
+          this.logToHarness(toolCall.name, toolCall.args, result);
+
+          // 通知前端工具执行结果
+          if (onStream) {
+            if (result.success) {
+              onStream({ type: 'status', content: `✅ ${toolCall.name} 执行成功`, tool: toolCall.name });
+              if (result.output) {
+                const outputPreview = result.output.substring(0, 200);
+                onStream({ type: 'tool', content: `📤 结果: ${outputPreview}${result.output.length > 200 ? '...' : ''}`, tool: toolCall.name });
+              }
+            } else {
+              onStream({ type: 'error', content: `❌ ${toolCall.name} 执行失败: ${result.error}`, tool: toolCall.name });
+            }
+          }
 
-        if (!result.success && result.error) {
-          console.warn(`Tool ${toolCall.name} error: ${result.error}`);
+          if (result.success) {
+            consecutiveErrors = 0; // 重置连续错误计数
+
+            // 检查工具执行质量
+            lastQualityScore = this.estimateToolResultQuality(result);
+            if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {
+              refineAttempts++;
+              console.log(`[PiAgent] 工具结果质量低，自动重试 (${refineAttempts}/${this.MAX_REFINE_ATTEMPTS})`);
+            } else {
+              console.log(`[PiAgent] 工具执行成功，质量评分: ${(lastQualityScore * 10).toFixed(1)}/10`);
+            }
+
+            // 工具执行成功后，继续循环获取下一个 LLM 响应
+            if (onStream) {
+              onStream({ type: 'status', content: `🔄 工具执行完成，继续循环...`, tool: 'loop' });
+            }
+            // 不 break，继续下一次循环
+          } else {
+            consecutiveErrors++;
+            console.warn(`[PiAgent] 工具执行失败 (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${result.error}`);
+
+            // 连续错误达到上限，尝试换一种方式
+            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+              console.log(`[PiAgent] 连续 ${MAX_CONSECUTIVE_ERRORS} 次错误，尝试换一种方式处理`);
+              // 添加错误上下文，让 LLM 换一种方式
+              this.messageHistory.push({
+                role: 'system',
+                content: `[注意] 前面的工具调用连续失败。请尝试其他工具或换一种方式完成用户请求。`
+              });
+              consecutiveErrors = 0; // 重置以继续尝试
+            }
+          }
+        } catch (execError) {
+          consecutiveErrors++;
+          const errorResult: ToolResult = { success: false, error: String(execError) };
+          this.messageHistory.push({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
+          this.logToHarness(toolCall.name, toolCall.args, errorResult);
+          console.error(`[PiAgent] 工具执行异常: ${execError}`);
         }
       } else {
-        this.messageHistory.push({ role: 'assistant', content: reply });
+        // LLM 返回的不是 tool call 格式
+        this.messageHistory.push({
+          role: 'assistant',
+          content: reply
+        });
+
+        // 通知前端收到非工具调用回复
+        if (onStream) {
+          onStream({ type: 'token', content: reply.substring(0, 150) });
+        }
+
+        // 检查是否需要继续循环处理
+        // 更严格的判断：只有当回复明确表示需要更多信息时才继续
+        const containsToolCallIntent = reply.includes('调用工具') || reply.includes('tool(') ||
+          reply.includes('使用工具') || reply.includes('需要获取') || reply.includes('需要查看');
+        const hasError = ['不存在', '找不到', '无法找到', 'not found', 'does not exist',
+          '错误', 'error', '失败', 'failed'].some(k => reply.includes(k));
+        const isTooShort = reply.length < 50 && reply.length > 0;
+        const hasQuestion = reply.includes('?') && (reply.includes('怎么') || reply.includes('如何') || reply.includes('什么'));
+
+        const needsMoreWork = hasError || containsToolCallIntent || isTooShort || hasQuestion;
+
+        if (needsMoreWork && iteration < this.MAX_REACT_ITERATIONS) {
+          console.log(`[PiAgent] 继续循环处理 (${iteration}/${this.MAX_REACT_ITERATIONS}): needsMoreWork=${needsMoreWork}, hasError=${hasError}, containsToolCallIntent=${containsToolCallIntent}`);
+          if (onStream) {
+            onStream({ type: 'status', content: `🔄 继续处理，循环 ${iteration}...`, tool: 'loop' });
+          }
+          continue;
+        }
+
+        // 否则把这个当作可能的最终回答
         finalResponse = reply;
+        if (onStream) {
+          onStream({ type: 'status', content: `📝 提取最终回答，长度 ${reply.length}`, tool: 'system' });
+        }
         break;
       }
     }
 
     if (!finalResponse) {
       finalResponse = '任务处理超时，请尝试更具体的请求。';
+      if (onStream) {
+        onStream({ type: 'error', content: '⚠️ 任务处理超时', tool: 'system' });
+      }
+    }
+
+    // 通知前端循环完成
+    if (onStream) {
+      onStream({ type: 'status', content: `✅ 处理完成，共 ${iteration - 1} 次循环`, tool: 'system' });
     }
 
     const now = new Date().toISOString();
@@ -975,30 +1248,23 @@ Workspace root folder: ${this.cwd}
   }
 
   private isFinalResponse(content: string): boolean {
-    const finalMarkers = ['最终回答', '完成', '答案如下', '结果是', 'final', 'answer:'];
-    const lower = content.toLowerCase();
-    // 更保守的判断：只有明确标记最终回答，且回复较短时才认为是最终回复
-    if (content.includes('✅') && content.length < 200 && finalMarkers.some(m => lower.includes(m))) {
-      return true;
-    }
-    return finalMarkers.some(m => lower.includes(m));
+    // 只有明确输出 <final gen> 才认为是最终回答
+    return content.includes('<final gen>');
   }
 
   private extractFinalAnswer(content: string): string {
-    // 移除任何 tool call 标记（保持完整回复）
+    // 提取 <final gen> 后的内容作为最终回答
+    const marker = '<final gen>';
+    const markerIndex = content.indexOf(marker);
+    if (markerIndex !== -1) {
+      content = content.substring(markerIndex + marker.length).trim();
+    }
+    // 移除任何 tool call 标记
     let cleaned = content
       .replace(/调用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
       .replace(/使用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
       .replace(/tool[_\w]*[：:]\s*\w+\s*\([^)]*\)/gi, '')
       .trim();
-
-    const lines = cleaned.split('\n');
-    const answerStart = lines.findIndex(l =>
-      ['最终回答', '完成', '答案如下', '结果是', 'final', 'answer:'].some(m => l.toLowerCase().includes(m))
-    );
-    if (answerStart >= 0) {
-      return lines.slice(answerStart + 1).join('\n').trim();
-    }
     return cleaned;
   }
 
@@ -1033,6 +1299,34 @@ Workspace root folder: ${this.cwd}
     return null;
   }
 
+  private estimateResponseQuality(response: string): number {
+    let score = 0.5;
+    if (response.length > 50) score += 0.1;
+    if (response.length > 200) score += 0.1;
+    if (response.length < 20) score -= 0.3;
+    if (response.includes('\n')) score += 0.1;
+    if (response.includes('-') || response.includes('•')) score += 0.05;
+    if (response.includes('```')) score += 0.1;
+    const conclusionWords = ['完成', '结果', '总结', '所以', '因此', '答案', '推荐'];
+    if (conclusionWords.some(w => response.includes(w))) score += 0.1;
+    if (response.includes('调用工具') || response.includes('tool(')) score -= 0.2;
+    return Math.max(0, Math.min(1, score));
+  }
+
+  private estimateToolResultQuality(result: ToolResult): number {
+    let score = 0.5;
+    if (!result.success) return 0.2;
+    if (result.output) {
+      score += 0.2;
+      if (result.output.length > 50) score += 0.1;
+      if (result.output.length < 10) score -= 0.1;
+      if (result.output.includes('❌') || result.output.includes('error')) score -= 0.2;
+      if (result.output.includes('✅') || result.output.includes('success')) score += 0.1;
+    }
+    if (result.error) score -= 0.3;
+    return Math.max(0, Math.min(1, score));
+  }
+
   private async handleFallback(input: string): Promise<string> {
     const lowerInput = input.toLowerCase();
     const parts = input.trim().split(/\s+/);
@@ -1551,9 +1845,34 @@ ${this.extractOperationsFromRef(operationsRef)}
 let sessionInstance: AgentSession | null = null;
 let lastIdentityDid: string | null = null;
 
-export async function createAgentSession(config: AgentSessionConfig): Promise<AgentSession> {
+// 独立的 session 实例缓存（用于多 session 支持）
+const independentSessions: Map<string, AgentSession> = new Map();
+
+export async function createAgentSession(config: AgentSessionConfig, forceNew?: boolean): Promise<AgentSession> {
   const incomingDid = config.identityDoc?.did;
 
+  // 如果有独立的 peerId (包含 :)，使用它作为 key
+  if (config.peerId && config.peerId.includes(':')) {
+    const key = config.peerId;
+    if (!forceNew && independentSessions.has(key)) {
+      console.log(`[createAgentSession] 找到现有独立 session, key=${key}`);
+      return independentSessions.get(key)!;
+    }
+    const session = new PiAgentSession(config);
+    independentSessions.set(key, session);
+    console.log(`[createAgentSession] 创建独立 session, key=${key}, DID=${incomingDid}`);
+    return session;
+  }
+
+  // 如果指定了 forceNew 但没有 peerId，生成带时间戳的 key
+  if (forceNew) {
+    const key = `force:${Date.now()}`;
+    const session = new PiAgentSession(config);
+    independentSessions.set(key, session);
+    console.log(`[createAgentSession] 创建强制新 session, key=${key}`);
+    return session;
+  }
+
   // 如果有新的 DID，强制重建 session
   if (sessionInstance && lastIdentityDid && incomingDid && lastIdentityDid !== incomingDid) {
     console.log(`[createAgentSession] DID 变化 ${lastIdentityDid} -> ${incomingDid}，重建 session`);

package/src/agents/protocol.ts

@@ -268,11 +268,105 @@ export class AgentProtocol {
     };
 
     const peers = p2pNetwork.getPeers();
+    const failedPeers: string[] = [];
+
     for (const peer of peers) {
       if (peer !== fromPeer) {
-        await p2pNetwork.sendMessage(peer, 'report', JSON.stringify(reportMsg));
+        try {
+          await p2pNetwork.sendMessage(peer, 'report', JSON.stringify(reportMsg));
+          console.log(`[${this.identityName}] 汇报已发送至 ${peer}`);
+        } catch (sendError) {
+          console.warn(`[${this.identityName}] 发送汇报至 ${peer} 失败: ${sendError}`);
+          failedPeers.push(peer);
+        }
+      }
+    }
+
+    // 重试失败的发送
+    if (failedPeers.length > 0) {
+      console.log(`[${this.identityName}] 尝试重新发送汇报至 ${failedPeers.length} 个失败节点`);
+      await this.retryFailedReports(reportMsg, failedPeers, 2);
+    }
+  }
+
+  private async retryFailedReports(
+    reportMsg: AgentMessage,
+    failedPeers: string[],
+    maxRetries: number
+  ): Promise<void> {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      if (failedPeers.length === 0) break;
+
+      console.log(`[${this.identityName}] 重试第 ${attempt}/${maxRetries} 次`);
+      await this.sleep(1000 * attempt); // 指数退避
+
+      const stillFailed: string[] = [];
+      for (const peer of failedPeers) {
+        try {
+          await p2pNetwork.sendMessage(peer, 'report', JSON.stringify(reportMsg));
+          console.log(`[${this.identityName}] 重试成功: ${peer}`);
+        } catch {
+          stillFailed.push(peer);
+        }
+      }
+      failedPeers = stillFailed;
+    }
+
+    if (failedPeers.length > 0) {
+      console.log(`[${this.identityName}] 最终仍有 ${failedPeers.length} 个节点发送失败，将加入待重试队列`);
+      this.queueFailedReports(reportMsg, failedPeers);
+    }
+  }
+
+  private failedReportsQueue: Array<{ msg: AgentMessage; peers: string[]; timestamp: number }> = [];
+
+  private queueFailedReports(msg: AgentMessage, peers: string[]): void {
+    this.failedReportsQueue.push({
+      msg,
+      peers,
+      timestamp: Date.now()
+    });
+    // 限制队列大小
+    if (this.failedReportsQueue.length > 50) {
+      this.failedReportsQueue = this.failedReportsQueue.slice(-50);
+    }
+  }
+
+  async processFailedReportsQueue(): Promise<void> {
+    if (this.failedReportsQueue.length === 0) return;
+
+    console.log(`[${this.identityName}] 处理待重试汇报队列 (${this.failedReportsQueue.length} 条)`);
+    const processed: number[] = [];
+
+    for (let i = 0; i < this.failedReportsQueue.length; i++) {
+      const item = this.failedReportsQueue[i];
+      const stillFailed: string[] = [];
+
+      for (const peer of item.peers) {
+        try {
+          await p2pNetwork.sendMessage(peer, 'report', JSON.stringify(item.msg));
+          console.log(`[${this.identityName}] 队列重试成功: ${peer}`);
+        } catch {
+          stillFailed.push(peer);
+        }
+      }
+
+      if (stillFailed.length === 0) {
+        processed.push(i);
+      } else {
+        item.peers = stillFailed;
+        item.timestamp = Date.now();
       }
     }
+
+    // 移除已成功的
+    for (let i = processed.length - 1; i >= 0; i--) {
+      this.failedReportsQueue.splice(processed[i], 1);
+    }
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
   }
 
   async submitImprovements(taskId: string, improvements: string): Promise<void> {