@bolloon/bolloon-agent 0.3.44 → 0.3.46

package/dist/agents/pi-sdk.js

@@ -596,9 +596,57 @@ export class PiAgentSession {
         }
         catch { /* 非致命 */ }
     }
+    // ============================================================
+    // 2026-08-08: 运行轨迹采集 (trajectory) — 每轮运行 → 落盘 + OrbitDB, 失败静默
+    // ============================================================
+    async createTrajectoryRecorder(input, channelId) {
+        try {
+            const { TrajectoryRecorder } = await import('../orbitdb/trajectory-store.js');
+            const { resolveUserDid } = await import('../storage/did-catalog-bridge.js');
+            const did = await resolveUserDid();
+            const model = this.llmConfig?.model || this.model || '';
+            return new TrajectoryRecorder({
+                agentId: this.currentAgentId || 'default',
+                input,
+                channelId: channelId || this.currentChannelId,
+                did: did || undefined,
+                model: typeof model === 'string' && model ? model : undefined,
+            });
+        }
+        catch {
+            return null; // 轨迹采集失败静默 (增强层)
+        }
+    }
+    wrapTrajectoryStream(onStream, rec) {
+        return (ev) => {
+            try {
+                rec?.recordStep?.(ev);
+            }
+            catch { /* 记录失败不影响转发 */ }
+            onStream(ev);
+        };
+    }
+    finishTrajectory(rec, reply, status = 'ok') {
+        if (!rec)
+            return;
+        // fire-and-forget: 不阻塞回复返回
+        (async () => {
+            try {
+                const { recordTrajectory } = await import('../orbitdb/trajectory-store.js');
+                const run = rec.endRun(reply, status);
+                await recordTrajectory(run, {});
+            }
+            catch { /* 静默 */ }
+        })();
+    }
     async prompt(input, options) {
         this.minimaxAvailable = this.checkMinimax();
         this.currentChannelId = options?.channelId ?? this.currentChannelId;
+        // 2026-08-08: 运行轨迹采集 (落盘 + OrbitDB, 失败静默) — 包裹 onStream 收集步骤事件
+        const trajRec = await this.createTrajectoryRecorder(input, options?.channelId);
+        if (trajRec && options?.onStream) {
+            options = { ...options, onStream: this.wrapTrajectoryStream(options.onStream, trajRec) };
+        }
         this.messageHistory.push({
             role: 'user',
             content: input
@@ -607,6 +655,7 @@ export class PiAgentSession {
             const response = await this.handleFallback(input);
             this.messageHistory.push({ role: 'assistant', content: response });
             this.reportUsageToContextManager();
+            this.finishTrajectory(trajRec, response);
             return response;
         }
         // P0 注入门
@@ -638,6 +687,7 @@ export class PiAgentSession {
         if (this.usePivotLoop) {
             try {
                 const lr = await this.promptWithPivotLoop(input, undefined, options?.channelId);
+                this.finishTrajectory(trajRec, lr.response || '');
                 return lr.response || '';
             }
             finally {
@@ -653,6 +703,7 @@ export class PiAgentSession {
         try {
             // 2026-06-16: runReActLoop 现在返回 { reply, aiFailed, aiFailureReason } — 这里只需 reply 字符串
             const loopResult = await this.runReActLoop(this.currentOnStream ?? undefined, options?.signal);
+            this.finishTrajectory(trajRec, loopResult.reply, loopResult.aiFailed ? 'error' : 'ok');
             return loopResult.reply;
         }
         finally {
@@ -673,6 +724,10 @@ export class PiAgentSession {
         this.minimaxAvailable = this.checkMinimax();
         console.log(`[PiAgent.promptStream] minimaxAvailable=${this.minimaxAvailable}`);
         this.currentChannelId = channelId ?? this.currentChannelId;
+        // 2026-08-08: 运行轨迹采集 (落盘 + OrbitDB, 失败静默) — 包裹 onStream 收集步骤事件
+        const trajRec = await this.createTrajectoryRecorder(input, channelId);
+        if (trajRec)
+            onStream = this.wrapTrajectoryStream(onStream, trajRec);
         // 2026-06-18 (supervisor): web server 把 46K markedPrompt 喂过来
         //   (【本轮用户请求】\n<text>\n【请求结束】\n\n<contextHint>).
         //   整个 input 走下游, pivot loop 之前拿 47K buildContext 当 user message 发出去,
@@ -693,6 +748,7 @@ export class PiAgentSession {
             this.messageHistory.push({ role: 'assistant', content: response });
             onStream({ type: 'done', content: '' });
             this.reportUsageToContextManager();
+            this.finishTrajectory(trajRec, response);
             return response;
         }
         // P0 注入门: 缓存 onStream + signal, computeJudgmentGate 用 currentOnStream 广播 phase
@@ -840,6 +896,7 @@ export class PiAgentSession {
                 this.promptStartTime = 0;
                 this.reportUsageToContextManager();
             }
+            this.finishTrajectory(trajRec, pivotResult);
             return pivotResult;
         }
         // 2026-06-16: loop 自动重试 — runReActLoop 内部遇到 [AI 服务调用失败] sentinel 时,
@@ -929,6 +986,8 @@ export class PiAgentSession {
         this.currentSignal = null;
         this.bootstrapAddition = '';
         this.promptStartTime = 0;
+        // 2026-08-08: 轨迹收尾 — 落盘 + OrbitDB (失败静默, 不阻塞回复)
+        this.finishTrajectory(trajRec, result);
         return result;
     }
     async promptWithPivotLoop(input, config, channelId) {
@@ -972,38 +1031,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 路径
@@ -1070,6 +1129,10 @@ ${this.getToolDefinitions()}
         //   上限=2 次 (用户要求"运行一两次"), 结束后按用户需求为准.
         let loopReviewCount = 0;
         const loopReviewCompletedTools = new Set();
+        // 2026-08-09: 本轮行动日志 — 每轮工具执行都记录 (args + 结果摘要),
+        //   final 前 review 用逐条核查目标; 也注入 system prompt 让 LLM 看到连续进度
+        //   (防"每轮都像重启" — 之前 LLM 看不到自己已完成什么, 容易重复 react)
+        const loopActionLog = [];
         // 发送循环开始的事件
         if (onStream) {
             onStream({ type: 'status', content: '🔄 开始 ReAct 循环...', tool: 'system' });
@@ -1186,32 +1249,47 @@ ${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> 标记表示结束
+            // 2026-08-09: 循环进度段 — 让 LLM 看到本轮已完成的动作 (连续进度, 不重启)
+            //   Hermes 式 Agent Runtime: 循环是状态机, LLM 每次看到的是"第 N 步 + 已完成 X"
+            //   (之前每轮都是全新上下文, LLM 不知道做过什么 → 重复 react / 衔接差)
+            let loopProgressSection = '';
+            if (loopActionLog.length > 0) {
+                const actionLines = loopActionLog
+                    .map((a, i) => {
+                    const args = a.argsPreview ? `(${a.argsPreview.slice(0, 60)})` : '';
+                    const res = a.success ? '✓' : '✗';
+                    return `  ${i + 1}. ${res} ${a.tool}${args}`;
+                })
+                    .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> 标记表示结束
 - 如果需要更多信息，继续调用工具${this.judgmentGateAddition}${this.contextHintAddition}`;
             // 3 个恢复机制 (Claude Code 论文 9-step pipeline 内部):
             //   1. max output token 升级 (最多 3 次, 每次 maxOutputTokens 翻倍)
@@ -1302,9 +1380,10 @@ ${toolDefs}
             }
             console.log(`[PiAgent] LLM 回复长度: ${reply.length}, 内容预览: "${reply.substring(0, 80)}..."`);
             console.log(`[PiAgent] LLM 完整回复:\n${reply}`);
-            // 通知前端：收到 LLM 回复
+            // 通知前端：收到 LLM 回复 (2026-08-09: 不再截断 100 字符 — 前端流式渲染完整内容,
+            //   配合 Hermes 式回复框: 加载中显示完整文本, 完成后封闭底框)
             if (onStream) {
-                onStream({ type: 'token', content: reply.substring(0, 100) });
+                onStream({ type: 'token', content: reply });
             }
             // 2026-06-19 架构 fix: parseToolCall 优先于 isFinalResponse
             //   之前: 思考块里的 "<final gen>" 触发 isFinalResponse 提前 break, 工具从未真正执行
@@ -1356,9 +1435,10 @@ ${toolDefs}
                     content: reply,
                     toolCalls: toolCalls.length > 1 ? toolCalls : [toolCalls[0]],
                 });
-                // 顺序执行每个工具
-                for (let ti = 0; ti < toolCalls.length; ti++) {
-                    const toolCall = toolCalls[ti];
+                // 2026-08-09: 并发执行本轮所有工具 (Hermes 式 Agent Runtime: 一轮内多工具并行,
+                //   一轮没跑完之前不中断 — 工具执行不检查 abort, 全部完成才 continue 下一轮)
+                //   旧实现顺序 for 循环, 一个工具等一个, 慢; 且多工具时 LLM 要等全部串完才能看到结果.
+                await Promise.all(toolCalls.map(async (toolCall, ti) => {
                     const isMulti = toolCalls.length > 1;
                     // 通知前端
                     if (onStream) {
@@ -1391,7 +1471,7 @@ ${toolDefs}
                         const denyResultMsg = { success: false, error: `拒绝: [${denyResult.source}] ${denyResult.reason}` };
                         this.messageHistory.push({ role: 'tool', content: JSON.stringify(denyResultMsg), toolResult: denyResultMsg });
                         this.logToHarness(toolCall.name, toolCall.args, denyResultMsg);
-                        continue;
+                        return;
                     }
                     if (denyResult.systemAddition) {
                         this.contextHintAddition += '\n' + denyResult.systemAddition;
@@ -1410,7 +1490,7 @@ ${toolDefs}
                         if (onStream)
                             onStream({ type: 'status', content: `💡 Reflection: ${obs.summary}`, tool: 'system' });
                         console.warn(`[PiAgent] 未知工具: ${toolCall.name} (累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS})，跳过并继续`);
-                        continue;
+                        return;
                     }
                     // Bootstrap PreToolUse hook: 调工具前校验 (危险命令拦截)
                     // 失败静默 — hook 自身挂掉 = 放行
@@ -1454,7 +1534,7 @@ ${toolDefs}
                                 this.messageHistory.push({ role: 'system', content: `[注意] 连续 ${consecutiveErrors} 次工具调用被系统拒绝. 请换其他工具或直接回答用户, 末尾加 <final gen>.` });
                                 consecutiveErrors = 0;
                             }
-                            continue;
+                            return;
                         }
                     }
                     catch (err) {
@@ -1491,7 +1571,7 @@ ${toolDefs}
                                 this.messageHistory.push({ role: 'system', content: `[注意] 连续 ${consecutiveErrors} 次工具调用被 Harness 拒绝. 请换其他工具或直接回答.` });
                                 consecutiveErrors = 0;
                             }
-                            continue;
+                            return;
                         }
                     }
                     catch (err) {
@@ -1528,6 +1608,20 @@ ${toolDefs}
                         }
                         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.logToHarness(toolCall.name, toolCall.args, result);
+                        // 2026-08-09: 记录到本轮行动日志 (循环进度 + final 前目标核查用)
+                        //   去重: 同一工具同 args 连续成功只记一次 (防 LLM 重复 react 刷屏)
+                        const argsPreview = JSON.stringify(toolCall.args || {}).slice(0, 120);
+                        const isDup = loopActionLog.some((a) => a.tool === toolCall.name && a.argsPreview === argsPreview && a.success === !!result.success);
+                        if (!isDup) {
+                            loopActionLog.push({
+                                tool: toolCall.name,
+                                argsPreview,
+                                resultPreview: result.success
+                                    ? String(result.output || '(无输出)').slice(0, 200)
+                                    : String(result.error || 'failed').slice(0, 200),
+                                success: !!result.success,
+                            });
+                        }
                         if (onStream) {
                             if (result.success) {
                                 onStream({ type: 'status', content: `✅ ${toolCall.name} 执行成功`, tool: toolCall.name });
@@ -1585,7 +1679,7 @@ ${toolDefs}
                                 lastFailedTool = '';
                                 lastFailedToolCount = 0;
                                 consecutiveErrors = 0;
-                                continue;
+                                return;
                             }
                             if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
                                 this.messageHistory.push({ role: 'system', content: `[注意] 前面的工具调用连续失败。请尝试其他工具或换一种方式完成用户请求, 或用 <final gen> 给出最终回答.` });
@@ -1606,7 +1700,7 @@ ${toolDefs}
                             onStream({ type: 'status', content: `💡 Reflection: ${obs.summary}`, tool: 'system' });
                         console.error(`[PiAgent] 工具执行异常 (累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS}): ${execError}`);
                     }
-                } // end for (ti)
+                })); // end Promise.all(toolCalls.map(async ...))
                 // 所有工具执行完毕后, continue while 循环, 让 LLM 看到结果
                 continue;
             }
@@ -1616,9 +1710,9 @@ ${toolDefs}
                     role: 'assistant',
                     content: reply
                 });
-                // 通知前端收到非工具调用回复
+                // 通知前端收到非工具调用回复 (2026-08-09: 完整内容, 不再截断 150)
                 if (onStream) {
-                    onStream({ type: 'token', content: reply.substring(0, 150) });
+                    onStream({ type: 'token', content: reply });
                 }
                 // 2026-06-19 架构 fix: 只有 strip <think> 后才检查 isFinalResponse
                 //   (parseToolCall 已先尝试, 既然没解析出 tool_call, 现在检查 final gen 是否真的在最终回答区)
@@ -1661,6 +1755,7 @@ ${toolDefs}
                         reviewsDone: loopReviewCount,
                         userIntent: this.currentIntentHint,
                         completedTools: Array.from(loopReviewCompletedTools),
+                        actionLog: loopActionLog,
                     }, DEFAULT_MAX_REVIEWS);
                     if (reviewDecision.kind === 'continue-review') {
                         loopReviewCount++;
@@ -2248,37 +2343,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) {
@@ -2303,13 +2398,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) {

package/dist/agents/skill-writer.js

@@ -61,6 +61,8 @@ export async function createSkill(name, description, body, opts = {}) {
     try {
         await fs.mkdir(skillDir, { recursive: true });
         await fs.writeFile(file, content, 'utf-8');
+        // 2026-08-08 (DID 目录写穿): skill 落盘同步进 DID 目录 skills 表 (失败静默)
+        catalogSkillUpsert(`skill/${safeName}`, { name: safeName, kind: 'skill', description, file, size: content.length, updatedAt: Date.now() });
         return { ok: true, path: file };
     }
     catch (e) {
@@ -115,6 +117,8 @@ export async function updateSkill(name, opts) {
         }
         const content = '---\n' + fmLines.join('\n') + '\n---\n\n' + body + '\n';
         await fs.writeFile(file, content, 'utf-8');
+        // 2026-08-08 (DID 目录写穿): skill 更新同步进 DID 目录 skills 表 (失败静默)
+        catalogSkillUpsert(`skill/${safeName}`, { name: safeName, kind: 'skill', description: String(opts.description || ''), file, size: content.length, updatedAt: Date.now() });
         return { ok: true, path: file };
     }
     catch (e) {
@@ -166,8 +170,23 @@ export async function writeSkillCandidate(c) {
     catch { /* 新文件 */ }
     const merged = { ...c, runs, body, timestamp: c.timestamp || new Date().toISOString() };
     await fs.writeFile(file, JSON.stringify(merged, null, 2), 'utf-8');
+    // 2026-08-08 (DID 目录写穿): 候选同步进 DID 目录 skills 表 (失败静默)
+    catalogSkillUpsert(`candidate/${safeName}`, {
+        name: safeName, kind: 'candidate', description: c.description,
+        file, runs, signature: c.signature, size: merged.body.length, updatedAt: Date.now(),
+    });
     return file;
 }
+/** 2026-08-08: skill 写入 → DID 目录 skills 表写穿 (WAL 事件 → 多设备同步/OrbitDB 复制). 失败静默. */
+function catalogSkillUpsert(key, data) {
+    (async () => {
+        try {
+            const { catalogUpsertQuiet } = await import('../storage/did-catalog-bridge.js');
+            await catalogUpsertQuiet('skills', key, data);
+        }
+        catch { /* 静默 */ }
+    })();
+}
 export async function listSkillCandidates(home = os.homedir()) {
     const dir = getCandidateDir(home);
     let entries;

package/dist/agents/workflow-pivot-loop.js

@@ -260,7 +260,7 @@ export class WorkflowPivotLoop {
                 const llmResponse = await llm.chat(context, headerForThisIter, signal, openAITools);
                 const reply = (llmResponse.reply || '').trim();
                 this.vlog(`[pivot] iter=${this.state.iteration} LLM took=${Date.now() - t0}ms reply=${reply.length} nativeToolCalls=${llmResponse.toolCalls?.length ?? 0} head=${reply.substring(0, 80).replace(/\n/g, ' ')}`);
-                this.emit({ type: 'token', content: reply.substring(0, 100) });
+                this.emit({ type: 'token', content: reply });
                 // 2026-07-06: 把完整 reply 推给前端 — 前端按需更新临时气泡
                 //   之前只 emit token(100B 截断), 前端拿到 100B 看不清. 现在 emit preview 带完整 content.
                 //   折叠 / 清洗交给前端的 message-renderer.addMessage (类型 ai 入口统一 strip).
@@ -778,8 +778,8 @@ export class WorkflowPivotLoop {
         //   完整重装只在 iter=1 和 compact 之后两次
         const lines = fullSystemPrompt.split('\n');
         const identityLine = lines.find((l) => l.includes('你是') && !l.includes('(续)')) ?? '';
-        return `[continuation] 你的 persona + tools + judgments 已在首轮 messageHistory 中.
-${identityLine ? identityLine + '\n' : ''}当前 step 别再读 persona 全文, 继续推进任务即可.
+        return `[continuation] 你的 persona + tools + judgments 已在首轮 messageHistory 中.
+${identityLine ? identityLine + '\n' : ''}当前 step 别再读 persona 全文, 继续推进任务即可.
 > <final gen> 只在真完成时输出.`;
     }
     /**

package/dist/bollharness/src/scripts/deploy-guard.js

@@ -104,17 +104,17 @@ function checkRsync(cmd) {
 function block(reason, host = null) {
     let guidance;
     if (host === PROD_IP) {
-        guidance = `请使用标准部署流程：
-  后端: bash scripts/deploy.sh --yes
-  Demo 正式: bash scripts/deploy-demo.sh <name> --channel prod --yes
-  Demo 内测: bash scripts/deploy-demo.sh <name> --channel preview --yes
-  Edge/Nginx: bash scripts/deploy-edge.sh --yes
+        guidance = `请使用标准部署流程：
+  后端: bash scripts/deploy.sh --yes
+  Demo 正式: bash scripts/deploy-demo.sh <name> --channel prod --yes
+  Demo 内测: bash scripts/deploy-demo.sh <name> --channel preview --yes
+  Edge/Nginx: bash scripts/deploy-edge.sh --yes
 详见 Bolloon.md Development Commands。`;
     }
     else if (BRIDGE_VPS_HOSTS.includes(host ?? "")) {
-        guidance = `Bridge VPS 必须走 git pull 更新路径：
-  ssh root@${host} 'sudo -u boll git -C /opt/boll pull --ff-only'
-  scp/rsync 直传会重新制造 orphan worktree。
+        guidance = `Bridge VPS 必须走 git pull 更新路径：
+  ssh root@${host} 'sudo -u boll git -C /opt/boll pull --ff-only'
+  scp/rsync 直传会重新制造 orphan worktree。
   详见 docs/issues/guard-20260408-0445-bridge-vps-orphan-worktree.md。`;
     }
     else {

package/dist/bollharness-integration/context-router-judgment.js

@@ -253,9 +253,9 @@ export async function generateJudgmentInjection(filePath, gate, options = {}) {
     const header = gate === 3
         ? '# Plan Freeze - Decision Principles'
         : `# Gate ${gate} - Active Judgments`;
-    return `${header}
-# Path: ${filePath}
-# Confidence: ${(result.confidence * 100).toFixed(0)}%
-
+    return `${header}
+# Path: ${filePath}
+# Confidence: ${(result.confidence * 100).toFixed(0)}%
+
 ${result.contextYaml}`;
 }