@bolloon/bolloon-agent 0.1.12 → 0.1.13

package/src/agents/p2p-chat-tools.ts

@@ -0,0 +1,383 @@
+/**
+ * p2p-chat-tools — 异步 chat 通道 + 持久化 inbox + 判断力外包 (draft)
+ *
+ * 解决痛点: 两个节点的智能体代替各自人类主人做异步判断
+ *
+ * 流程:
+ *   1. A 节点 (人类在线) 通过 sendChat(peerDID, text) 发消息 → iroh 'agent_chat'
+ *   2. B 节点 (人类可能离线):
+ *        - onMessage('agent_chat') → 落 ~/.bolloon/inbox/<peerDID>.jsonl
+ *        - 状态 = 'received' (未处理)
+ *   3. B 节点 wake-up (processPendingInbox) → 扫描 status='received' 的消息
+ *        - 调 LLM 生成 draft (注入主人历史判断 + ValueProfile)
+ *        - 写 status='drafted', draft 落盘
+ *        - 通过 'agent_chat' 消息类型回送 draft (前缀 [DRAFT] 表明是代回)
+ *   4. A 节点收到 draft → 写到 A 的 outbox (inbox 中 from=B 的那条)
+ *   5. B 人类上线 → getInbox() 看到 'drafted' 状态的条目, approveAndSend / dismissDraft
+ *
+ * 镜像 p2p-document-tools.ts 风格: iroh 消息 + 可注入 transport (支持多实例测试)
+ */
+
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { EventEmitter } from 'events';
+import { irohTransport as defaultIrohTransport, type IrohTransport } from '../network/iroh-transport.js';
+import { getRelevantValues, getValueProfile, loadAllJudgments } from '../pi-ecosystem-judgment/human-value-store.js';
+
+function homeDir(): string {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+// ============================================================================
+// 事件总线 — 任何状态变化都 emit, web SSE/UI 可订阅
+// ============================================================================
+export type ChatEvent =
+  | { kind: 'inbox_new';        peerDID: string; entry: ChatMessage }
+  | { kind: 'draft_ready';      peerDID: string; entry: ChatMessage }
+  | { kind: 'outbox_updated';   peerDID: string; entry: ChatMessage }
+  | { kind: 'outbox_draft_in';  peerDID: string; originalId: string; draft: string }
+  | { kind: 'inbox_sent';       peerDID: string; entry: ChatMessage }
+  | { kind: 'inbox_dismissed';  peerDID: string; entry: ChatMessage };
+
+class ChatEventBus extends EventEmitter {}
+export const chatEventBus = new ChatEventBus();
+
+// ============================================================================
+// 类型
+// ============================================================================
+
+export type ChatMessageStatus = 'received' | 'drafted' | 'sent' | 'dismissed';
+
+export interface ChatMessage {
+  id: string;
+  peerDID: string;
+  fromNodeId: string;
+  text: string;
+  timestamp: number;
+  receivedAt: number;
+  status: ChatMessageStatus;
+  draft?: string;
+  draftConfidence?: number;
+  draftReasoning?: string;
+  draftAt?: number;
+  sentText?: string;
+  sentAt?: number;
+  inboundDraft?: string;
+  inboundDraftAt?: number;
+}
+
+export type ChatMessageHandler = (msg: ChatMessage, from: string) => void;
+
+// ============================================================================
+// 每 transport 一份状态 (支持多 IrohTransport 实例)
+// ============================================================================
+
+interface ChatModuleState {
+  handlers: Set<ChatMessageHandler>;
+  listenerInstalled: boolean;
+}
+
+const states = new WeakMap<IrohTransport, ChatModuleState>();
+
+function getState(transport: IrohTransport): ChatModuleState {
+  let s = states.get(transport);
+  if (!s) {
+    s = { handlers: new Set(), listenerInstalled: false };
+    states.set(transport, s);
+  }
+  return s;
+}
+
+// ============================================================================
+// Inbox 存储
+// ============================================================================
+
+function inboxDir(): string {
+  return path.join(homeDir(), '.bolloon', 'inbox');
+}
+
+function inboxPath(peerDID: string): string {
+  const safe = peerDID.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return path.join(inboxDir(), `${safe}.jsonl`);
+}
+
+function outboxPath(): string {
+  return path.join(inboxDir(), '_outbox.jsonl');
+}
+
+async function appendInbox(peerDID: string, entry: ChatMessage): Promise<void> {
+  await fs.mkdir(inboxDir(), { recursive: true });
+  await fs.appendFile(inboxPath(peerDID), JSON.stringify(entry) + '\n', 'utf-8');
+}
+
+async function readInbox(peerDID: string): Promise<ChatMessage[]> {
+  try {
+    const content = await fs.readFile(inboxPath(peerDID), 'utf-8');
+    return content.split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l) as ChatMessage);
+  } catch { return []; }
+}
+
+async function rewriteInbox(peerDID: string, entries: ChatMessage[]): Promise<void> {
+  await fs.mkdir(inboxDir(), { recursive: true });
+  await fs.writeFile(inboxPath(peerDID), entries.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+}
+
+async function updateInboxEntry(peerDID: string, id: string, patch: Partial<ChatMessage>): Promise<ChatMessage | null> {
+  const entries = await readInbox(peerDID);
+  const idx = entries.findIndex((e) => e.id === id);
+  if (idx < 0) return null;
+  entries[idx] = { ...entries[idx], ...patch };
+  await rewriteInbox(peerDID, entries);
+  return entries[idx];
+}
+
+async function markOutboundDraft(originalId: string, draft: string, at: number): Promise<void> {
+  try {
+    const content = await fs.readFile(outboxPath(), 'utf-8');
+    const entries: ChatMessage[] = content.split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+    const idx = entries.findIndex((e) => e.id === originalId);
+    if (idx >= 0) {
+      entries[idx].inboundDraft = draft;
+      entries[idx].inboundDraftAt = at;
+      await fs.writeFile(outboxPath(), entries.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+    }
+  } catch { /* no outbox */ }
+}
+
+// ============================================================================
+// Listener 安装 (每个 transport 各装一次)
+// ============================================================================
+
+function ensureListener(transport: IrohTransport): void {
+  const s = getState(transport);
+  if (s.listenerInstalled) return;
+  s.listenerInstalled = true;
+  transport.onMessage('agent_chat', (msg) => {
+    try {
+      const data = JSON.parse(new TextDecoder().decode(msg.payload)) as { kind: string; id: string; text: string; originalId?: string };
+      void handleIncomingChat(transport, msg.from, data);
+    } catch (e) {
+      console.error('[ChatReceiver] parse err:', (e as Error).message);
+    }
+  });
+}
+
+async function handleIncomingChat(transport: IrohTransport, fromNodeId: string, data: { kind: string; id: string; text: string; originalId?: string }): Promise<void> {
+  const peerDID = fromNodeId;
+  if (data.kind === 'user') {
+    const entry: ChatMessage = {
+      id: data.id, peerDID, fromNodeId, text: data.text,
+      timestamp: Date.now(), receivedAt: Date.now(), status: 'received',
+    };
+    await appendInbox(peerDID, entry);
+    const preview = data.text.slice(0, 60);
+    const peerShort = peerDID.slice(0, 12);
+    console.log('[ChatReceiver] received from ' + peerShort + ': ' + preview);
+    chatEventBus.emit('chat', { kind: 'inbox_new', peerDID, entry } satisfies ChatEvent);
+    for (const h of getState(transport).handlers) {
+      try { h(entry, fromNodeId); } catch {}
+    }
+  } else if (data.kind === 'draft' && data.originalId) {
+    await markOutboundDraft(data.originalId, data.text, Date.now());
+    console.log('[ChatReceiver] inbound draft for ' + data.originalId);
+    chatEventBus.emit('chat', { kind: 'outbox_draft_in', peerDID, originalId: data.originalId, draft: data.text } satisfies ChatEvent);
+  }
+}
+
+// ============================================================================
+// 公共 API (可注入 transport)
+// ============================================================================
+
+export function onChatMessage(handler: ChatMessageHandler, transport: IrohTransport = defaultIrohTransport): void {
+  getState(transport).handlers.add(handler);
+  ensureListener(transport);
+}
+
+export async function initChatReceiver(transport: IrohTransport = defaultIrohTransport): Promise<void> {
+  ensureListener(transport);
+  await fs.mkdir(inboxDir(), { recursive: true });
+  console.log('[ChatReceiver] Initialized at', inboxDir(), 'transport=', (transport as any) === defaultIrohTransport ? 'singleton' : 'instance');
+}
+
+export async function sendChat(peerDID: string, text: string, transport: IrohTransport = defaultIrohTransport): Promise<string> {
+  const id = crypto.randomUUID();
+  const ok = await transport.sendMessage(
+    peerDID, 'agent_chat',
+    new TextEncoder().encode(JSON.stringify({ kind: 'user', id, text })),
+  );
+  if (ok) {
+    const entry: ChatMessage = {
+      id, peerDID,
+      fromNodeId: transport.getNodeId() || '',
+      text, timestamp: Date.now(), receivedAt: Date.now(),
+      status: 'sent', sentText: text, sentAt: Date.now(),
+    };
+    await fs.mkdir(inboxDir(), { recursive: true });
+    await fs.appendFile(outboxPath(), JSON.stringify(entry) + '\n', 'utf-8');
+    chatEventBus.emit('chat', { kind: 'outbox_updated', peerDID, entry } satisfies ChatEvent);
+  } else {
+    console.warn(`[ChatReceiver] send to ${peerDID.slice(0, 12)}... failed`);
+  }
+  return id;
+}
+
+export async function getInbox(peerDID?: string): Promise<ChatMessage[]> {
+  if (peerDID) return readInbox(peerDID);
+  try {
+    const files = await fs.readdir(inboxDir());
+    const all: ChatMessage[] = [];
+    for (const f of files) {
+      if (!f.endsWith('.jsonl') || f.startsWith('_')) continue;
+      const peerDID = f.replace('.jsonl', '').replace(/_/g, ':');
+      all.push(...await readInbox(peerDID));
+    }
+    return all.sort((a, b) => b.receivedAt - a.receivedAt);
+  } catch { return []; }
+}
+
+// ============================================================================
+// Draft 引擎
+// ============================================================================
+
+async function buildValueHint(text: string): Promise<string> {
+  try {
+    const allJudgments = await loadAllJudgments();
+    const relevant = await getRelevantValues(text, undefined);
+    const profile = await getValueProfile('me');
+    const profileHint = [
+      `quality_focus=${profile.quality_focus.toFixed(2)}`,
+      `efficiency_focus=${profile.efficiency_focus.toFixed(2)}`,
+      `safety_focus=${profile.safety_focus.toFixed(2)}`,
+      `collaboration_focus=${profile.collaboration_focus.toFixed(2)}`,
+      `learning_focus=${profile.learning_focus.toFixed(2)}`,
+    ].join(', ');
+    const reasons = allJudgments
+      .filter((j) => (j.reasons || []).length > 0)
+      .slice(-10)
+      .flatMap((j) => j.reasons || [])
+      .slice(0, 20);
+    return `\n[主人历史判断 (style 参考, 不可外泄)]\n关注维度: ${profileHint}\n关键理由示例: ${reasons.join(' | ').slice(0, 400) || '(无)'}\n`;
+  } catch (e) {
+    return '';
+  }
+}
+
+export async function generateDraft(
+  messageId: string,
+  peerDID: string,
+  transport: IrohTransport = defaultIrohTransport,
+): Promise<ChatMessage | null> {
+  const entries = await readInbox(peerDID);
+  const entry = entries.find((e) => e.id === messageId);
+  if (!entry) return null;
+  if (entry.status !== 'received') return entry;
+
+  const valueHint = await buildValueHint(entry.text);
+  const promptForDraft = `你是主人的代理. 对方发来这条消息: "${entry.text.slice(0, 1500)}"\n${valueHint}\n请基于主人的历史判断, 用 1-2 句话代主人拟一个回复草案. 草案要保留主人的语气和立场, 开头标注 [DRAFT]. 直接给草案文本, 不要解释.`;
+
+  let draftText = '';
+  let confidence = 0.5;
+  try {
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (!openaiKey) throw new Error('OPENAI_API_KEY not set');
+    const openaiBase = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
+    const openaiModel = process.env.OPENAI_MODEL || 'gpt-4';
+    const r = await fetch(`${openaiBase}/chat/completions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${openaiKey}` },
+      body: JSON.stringify({
+        model: openaiModel,
+        messages: [
+          { role: 'system', content: '你是主人的代理. 你的输出会被主人审阅后才发出. 请谨慎.' },
+          { role: 'user', content: promptForDraft },
+        ],
+        temperature: 0.4,
+        max_tokens: 300,
+      }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (r.ok) {
+      const data = await r.json() as any;
+      draftText = (data.choices?.[0]?.message?.content || '').trim();
+      confidence = 0.7;
+    } else {
+      console.warn(`[DraftEngine] LLM ${r.status}`);
+    }
+  } catch (e) {
+    console.warn(`[DraftEngine] LLM call failed: ${(e as Error).message}`);
+  }
+
+  if (!draftText) {
+    draftText = `[DRAFT] 已收到. (本地 draft 引擎未配置 LLM, 主人上线后请手写回复)`;
+    confidence = 0.1;
+  }
+
+  const updated = await updateInboxEntry(peerDID, messageId, {
+    status: 'drafted', draft: draftText, draftConfidence: confidence,
+    draftReasoning: valueHint.slice(0, 200), draftAt: Date.now(),
+  });
+
+  if (updated) {
+    const sent = await transport.sendMessage(
+      peerDID, 'agent_chat',
+      new TextEncoder().encode(JSON.stringify({ kind: 'draft', id: crypto.randomUUID(), text: draftText, originalId: messageId })),
+    );
+    if (sent) console.log('[DraftEngine] draft sent to ' + peerDID.slice(0, 12) + ' for ' + messageId.slice(0, 8));
+    else console.warn('[DraftEngine] failed to send draft');
+    chatEventBus.emit('chat', { kind: 'draft_ready', peerDID, entry: updated } satisfies ChatEvent);
+    chatEventBus.emit('chat', { kind: 'outbox_updated', peerDID, entry: updated } satisfies ChatEvent);
+  }
+  return updated;
+}
+
+export async function processPendingInbox(transport: IrohTransport = defaultIrohTransport): Promise<{ processed: number; skipped: number }> {
+  await fs.mkdir(inboxDir(), { recursive: true });
+  const files = await fs.readdir(inboxDir());
+  let processed = 0, skipped = 0;
+  for (const f of files) {
+    if (!f.endsWith('.jsonl') || f.startsWith('_')) continue;
+    const peerDID = f.replace('.jsonl', '').replace(/_/g, ':');
+    const entries = await readInbox(peerDID);
+    for (const e of entries) {
+      if (e.status === 'received') {
+        const r = await generateDraft(e.id, peerDID, transport);
+        if (r) processed++; else skipped++;
+      }
+    }
+  }
+  return { processed, skipped };
+}
+
+export async function approveAndSend(
+  messageId: string, peerDID: string, finalText?: string,
+  transport: IrohTransport = defaultIrohTransport,
+): Promise<boolean> {
+  const entries = await readInbox(peerDID);
+  const entry = entries.find((e) => e.id === messageId);
+  if (!entry || entry.status !== 'drafted') return false;
+  const text = finalText || entry.draft || '';
+  const ok = await transport.sendMessage(
+    peerDID, 'agent_chat',
+    new TextEncoder().encode(JSON.stringify({ kind: 'user', id: crypto.randomUUID(), text })),
+  );
+  if (ok) {
+    const updated = await updateInboxEntry(peerDID, messageId, { status: 'sent', sentText: text, sentAt: Date.now() });
+    if (updated) chatEventBus.emit('chat', { kind: 'inbox_sent', peerDID, entry: updated } satisfies ChatEvent);
+  }
+  return ok;
+}
+
+export async function dismissDraft(messageId: string, peerDID: string): Promise<boolean> {
+  const entries = await readInbox(peerDID);
+  const entry = entries.find((e) => e.id === messageId);
+  if (!entry) return false;
+  const updated = await updateInboxEntry(peerDID, messageId, { status: 'dismissed' });
+  if (updated) chatEventBus.emit('chat', { kind: 'inbox_dismissed', peerDID, entry: updated } satisfies ChatEvent);
+  return true;
+}
+
+export const p2pChatTools = {
+  sendChat, getInbox, processPendingInbox, generateDraft, approveAndSend, dismissDraft, onChatMessage, initChatReceiver,
+};

package/src/agents/p2p-document-tools.ts

@@ -4,6 +4,7 @@
 
 import * as crypto from 'crypto';
 import * as fs from 'fs/promises';
+import * as path from 'path';
 import { irohTransport } from '../network/iroh-transport.js';
 import { documentReader, type DocumentContent } from '../documents/reader.js';
 import { documentStore, type DocumentChunk, type ReceivedDocument } from '../documents/store.js';
@@ -20,6 +21,11 @@ function getMimeType(filename: string): string {
   const mimeTypes: Record<string, string> = {
     'txt': 'text/plain',
     'md': 'text/markdown',
+    'html': 'text/html',
+    'htm': 'text/html',
+    'yaml': 'application/yaml',
+    'yml': 'application/yaml',
+    'json': 'application/json',
     'pdf': 'application/pdf',
     'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
   };
@@ -29,8 +35,10 @@ function getMimeType(filename: string): string {
 export async function initDocumentReceiver(): Promise<void> {
   await documentStore.initialize();
 
-  documentStore.onDocumentReceived((doc) => {
+  documentStore.onDocumentReceived(async (doc) => {
     console.log(`[DocumentReceiver] Document received: ${doc.fileName} from ${doc.fromNodeIdShort}`);
+    // 异步调用 LLM 解析（不阻塞接收流程）
+    void parseDocumentWithLLM(doc);
   });
 
   irohTransport.onMessage('document_chunk', async (msg) => {
@@ -48,6 +56,148 @@ export async function initDocumentReceiver(): Promise<void> {
   console.log('[DocumentReceiver] Initialized and listening for document chunks');
 }
 
+// ============================================================================
+// AI 解析反馈：接收方解析完文档后把摘要回送给发送方
+// ============================================================================
+
+export interface AIFeedbackMessage {
+  docId: string;
+  fileName: string;
+  mimeType: string;
+  summary: string;
+  qualityScore: number;
+  feedbackAt: number;
+  fromNodeId: string;
+}
+
+export type AIFeedbackHandler = (feedback: AIFeedbackMessage, fromNodeId: string) => void;
+const feedbackHandlers: Set<AIFeedbackHandler> = new Set();
+
+/** 注册 AI 解析反馈监听器（发送方调用） */
+export function onAIFeedback(handler: AIFeedbackHandler): void {
+  feedbackHandlers.add(handler);
+  // iroh listener 只挂一次
+  ensureFeedbackListenerInstalled();
+}
+
+let feedbackListenerInstalled = false;
+function ensureFeedbackListenerInstalled(): void {
+  if (feedbackListenerInstalled) return;
+  feedbackListenerInstalled = true;
+  irohTransport.onMessage('ai_feedback', (msg) => {
+    try {
+      const fb: AIFeedbackMessage = JSON.parse(new TextDecoder().decode(msg.payload));
+      for (const h of feedbackHandlers) {
+        try {
+          h(fb, msg.from);
+        } catch (e) {
+          console.error('[AIFeedback] handler error:', e);
+        }
+      }
+    } catch (e) {
+      console.error('[AIFeedback] failed to parse message:', e);
+    }
+  });
+}
+
+/** 文档解析服务：优先走 web 统一入口 (含 judgment + harness), fallback 到本地 LLM */
+async function callAIParseService(text: string, fileName: string, mimeType: string, fromNodeId?: string): Promise<{ summary: string; qualityScore: number; source: 'web' | 'local'; judgmentId?: string; gateArtifact?: string }> {
+  // 1) 优先: 调 web 端 POST /api/ai-parse (统一入口, 含 judgment + harness)
+  const webBase = process.env.BOLLOON_WEB_URL || process.env.PORTAL_URL || 'http://127.0.0.1:54188';
+  try {
+    const r = await fetch(`${webBase}/api/ai-parse`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text, mimeType, fileName, fromNodeId, source: 'p2p-document' }),
+      // 短超时, fallback 友好
+      signal: AbortSignal.timeout(8000),
+    });
+    if (r.ok) {
+      const data = await r.json() as any;
+      return {
+        summary: data.summary,
+        qualityScore: data.qualityScore,
+        source: 'web',
+        judgmentId: data.judgmentId,
+        gateArtifact: data.gateArtifact,
+      };
+    }
+    console.warn(`[AIParse] web returned ${r.status}, fallback to local`);
+  } catch (e) {
+    console.warn(`[AIParse] web ${webBase} unreachable (${(e as Error).message}), fallback to local`);
+  }
+
+  // 2) Fallback: 直接调本地 LLM (不调 judgment/harness, 仅在 web 不可用时使用)
+  const apiKey = process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.MINIMAX_API_KEY || process.env.OPENROUTER_API_KEY || process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error('No web endpoint and no LLM API key configured. Set BOLLOON_WEB_URL or OPENAI_API_KEY.');
+  }
+  const { getMinimax } = await import('../constraints/index.js');
+  const llm = getMinimax();
+  const truncated = text.length > 6000 ? text.substring(0, 6000) + '...[截断]' : text;
+  const prompt = `请分析以下 ${mimeType} 文档，并给出 (1) 一句话中文摘要 (2) 关键要点列表 (3) 文档质量评分(0-1)。\n\n文件名: ${fileName}\n\n内容:\n${truncated}`;
+  const r = await llm.summarize(prompt);
+  return { summary: r.summary, qualityScore: r.qualityScore, source: 'local' };
+}
+
+async function parseDocumentWithLLM(doc: ReceivedDocument): Promise<void> {
+  try {
+    const filePath = path.join(
+      process.env.HOME || '/tmp',
+      '.bolloon', 'documents', 'received',
+      doc.id, doc.fileName
+    );
+    const content = await fs.readFile(filePath, 'utf-8');
+
+    const r = await callAIParseService(content, doc.fileName, doc.mimeType, doc.fromNodeId);
+
+    const sidecar = {
+      filename: doc.fileName,
+      mimeType: doc.mimeType,
+      fromNodeId: doc.fromNodeId,
+      receivedAt: doc.receivedAt,
+      summary: r.summary,
+      qualityScore: r.qualityScore,
+      parseSource: r.source,
+      judgmentId: r.judgmentId,
+      gateArtifact: r.gateArtifact,
+      analyzedAt: Date.now(),
+    };
+    const sidecarPath = path.join(
+      process.env.HOME || '/tmp',
+      '.bolloon', 'documents', 'received',
+      doc.id, 'ai-analysis.json'
+    );
+    await fs.writeFile(sidecarPath, JSON.stringify(sidecar, null, 2));
+    console.log(`[DocumentReceiver] AI parsed ${doc.fileName} via ${r.source} (score=${r.qualityScore.toFixed(2)})${r.judgmentId ? ` judgment=${r.judgmentId}` : ''}${r.gateArtifact ? ` gate=${r.gateArtifact}` : ''}`);
+
+    // 把 AI 解析结果回送给发送方 (doc.fromNodeId)，形成 "接收 → 解析 → 反馈" 闭环
+    if (doc.fromNodeId) {
+      const feedback: AIFeedbackMessage = {
+        docId: doc.id,
+        fileName: doc.fileName,
+        mimeType: doc.mimeType,
+        summary: r.summary,
+        qualityScore: r.qualityScore,
+        feedbackAt: Date.now(),
+        fromNodeId: irohTransport.getNodeId() || '',
+      };
+      const sent = await irohTransport.sendMessage(
+        doc.fromNodeId,
+        'ai_feedback',
+        new TextEncoder().encode(JSON.stringify(feedback))
+      );
+      if (sent) {
+        console.log(`[DocumentReceiver] Feedback sent to ${doc.fromNodeIdShort}`);
+      } else {
+        console.warn(`[DocumentReceiver] Failed to send feedback to ${doc.fromNodeIdShort}`);
+      }
+    }
+  } catch (e) {
+    console.error(`[DocumentReceiver] AI parse failed for ${doc.fileName}:`, e);
+  }
+}
+
 export const p2pDocumentTools: Tool[] = [
   {
     name: 'list_online_peers',

package/src/agents/workflow-pivot-loop.ts

@@ -38,6 +38,7 @@ export interface ToolDefinition {
   name: string;
   description: string;
   parameters: Record<string, string>;
+  args?: Record<string, string>;
 }
 
 export interface LoopResult {
@@ -137,7 +138,7 @@ export class WorkflowPivotLoop {
   private config: Required<PivotLoopConfig>;
   private state: PivotLoopState;
   private tools: Map<string, Tool>;
-  private messageHistory: Array<{ role: string; content: string; toolCall?: { name: string; args: Record<string, string> }; toolResult?: ToolResult }>;
+  private messageHistory: Array<{ role: string; content: string; toolCall?: ToolDefinition; toolResult?: ToolResult }>;
   private streamCallback?: StreamCallback;
   
   constructor(config: PivotLoopConfig) {
@@ -318,7 +319,7 @@ export class WorkflowPivotLoop {
           });
           
           try {
-            const result = await tool.execute(toolCall.args);
+            const result = await tool.execute(toolCall.args ?? {});
             
             this.emit({
               type: result.success ? 'status' : 'error',
@@ -416,9 +417,9 @@ export class WorkflowPivotLoop {
   /**
    * Extract pending tool uses from LLM response
    */
-  private extractPendingToolUses(content: string): Array<{ name: string; args: Record<string, string> }> {
-    const pending: Array<{ name: string; args: Record<string, string> }> = [];
-    
+  private extractPendingToolUses(content: string): ToolDefinition[] {
+    const pending: ToolDefinition[] = [];
+
     // Pattern 1: Chinese format "调用工具: tool_name(args)"
     const pattern1 = /调用工具[：:]\s*(\w+)\s*\(([^)]*)\)/g;
     let match;
@@ -427,10 +428,10 @@ export class WorkflowPivotLoop {
       const argsStr = match[2];
       const args = this.parseArgs(argsStr);
       if (this.tools.has(name)) {
-        pending.push({ name, args });
+        pending.push({ name, args, description: '', parameters: {} });
       }
     }
-    
+
     // Pattern 2: tool_name(args) format
     const pattern2 = /(\w+)\s*\(\s*([^)]*)\s*\)/g;
     while ((match = pattern2.exec(content)) !== null) {
@@ -439,11 +440,11 @@ export class WorkflowPivotLoop {
       // Skip if already matched or doesn't look like a tool call
       if (pending.some(p => p.name === name)) continue;
       if (!this.tools.has(name)) continue;
-      
+
       const args = this.parseArgs(argsStr);
-      pending.push({ name, args });
+      pending.push({ name, args, description: '', parameters: {} });
     }
-    
+
     // Pattern 3: JSON format tool calls
     try {
       const jsonMatch = content.match(/\{[\s\S]*"tool_calls"[\s\S]*\}/);
@@ -452,7 +453,7 @@ export class WorkflowPivotLoop {
         if (Array.isArray(parsed.tool_calls)) {
           for (const tc of parsed.tool_calls) {
             if (this.tools.has(tc.name)) {
-              pending.push({ name: tc.name, args: tc.args || {} });
+              pending.push({ name: tc.name, args: tc.args || {}, description: '', parameters: {} });
             }
           }
         }
@@ -460,7 +461,7 @@ export class WorkflowPivotLoop {
     } catch {
       // JSON parsing failed, ignore
     }
-    
+
     return pending;
   }
   

package/src/bollharness-integration/channel-judgment-engine.ts

@@ -505,7 +505,7 @@ export class ChannelJudgmentEngine {
    * 确定 Skills（基于 Gate 和上下文）
    */
   private determineSkills(gate: Gate, context: JudgmentContext): string[] {
-    const baseSkills = GATE_PROMPTS[gate]?.skills || ['arch'];
+    const baseSkills = (GATE_PROMPTS as Record<number, { skills: string[] }>)[gate]?.skills || ['arch'];
 
     // 根据上下文调整 Skills
     const { currentMessage } = context;

package/src/documents/reader.ts

@@ -23,6 +23,11 @@ export class DocumentReader {
     switch (ext) {
       case '.txt':
       case '.md':
+      case '.html':
+      case '.htm':
+      case '.yaml':
+      case '.yml':
+      case '.json':
         text = await fs.readFile(filePath, 'utf-8');
         break;
       case '.pdf':

package/src/documents/store.ts

@@ -205,11 +205,11 @@ export class DocumentStore {
   async readDocument(docId: string): Promise<{ content: string; metadata: ReceivedDocument } | null> {
     const docDir = path.join(this.baseDir, docId);
     const manifestPath = path.join(docDir, 'manifest.json');
-    const filePath = path.join(docDir);
 
     try {
       const manifestData = await fs.readFile(manifestPath, 'utf-8');
       const manifest = JSON.parse(manifestData);
+      const filePath = path.join(docDir, manifest.fileName);
       const fileContent = await fs.readFile(filePath, 'utf-8');
 
       return {