@bolloon/bolloon-agent 0.4.33 → 0.5.1

package/dist/electron-build/agents/pi-sdk-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"pi-sdk-types.js","sourceRoot":"","sources":["../../../src/agents/pi-sdk-types.ts"],"names":[],"mappings":";;;AA4Ha,QAAA,gBAAgB,GAAG;;;;;;;;;;;;CAY/B,CAAC"}
+{"version":3,"file":"pi-sdk-types.js","sourceRoot":"","sources":["../../../src/agents/pi-sdk-types.ts"],"names":[],"mappings":";;;AAwIa,QAAA,gBAAgB,GAAG;;;;;;;;;;;;CAY/B,CAAC"}

package/dist/electron-build/agents/pi-sdk.js

@@ -67,6 +67,9 @@ const workflow_pivot_loop_js_1 = require("./workflow-pivot-loop.js");
 const p2p_document_tools_js_1 = require("./p2p-document-tools.js");
 const run_store_js_1 = require("./run-store.js");
 const goal_store_js_1 = require("./goal-store.js");
+const model_selection_js_1 = require("../llm/model-selection.js");
+// 2026-09-26: 工具名出网净化 (pi-ai.ts 唯一边界) + 回程派发还原 (原名 ↔ API 名)
+const tool_name_js_1 = require("../llm/tool-name.js");
 const pi_harness_js_1 = require("./pi-harness.js");
 const heartbeat_js_1 = require("../social/heartbeat.js");
 const constraint_runtime_2 = require("@bolloon/constraint-runtime");
@@ -688,6 +691,18 @@ class PiAgentSession {
             return false;
         }
     }
+    /**
+     * 2026-09-26: 这个 Run 开始那一刻**真实生效**的模型配置快照, 由 startRun 落进 Run 记录。
+     * 拿不到 (配置读不出来) 就返回 undefined —— 宁可这个字段缺, 也不编一个假的进去。
+     */
+    async runModelSnapshot() {
+        try {
+            return await (0, model_selection_js_1.captureRunModelConfig)();
+        }
+        catch {
+            return undefined;
+        }
+    }
     /** 2026-08-07: prompt 出口统一上报 token 用量到 ContextManager (fallback/pivot/react 全路径覆盖) —
      *   之前只有 runReActLoop 迭代内上报, chitchat/fallback/pivot 路径状态栏恒 0 */
     reportUsageToContextManager() {
@@ -792,6 +807,7 @@ class PiAgentSession {
                     goalId: boundGoalId,
                     channelId: this.currentChannelId || undefined,
                     agentId: this.currentAgentId || undefined,
+                    modelConfig: await this.runModelSnapshot(),
                 });
                 this.lastRunId = rec.runId;
                 await (0, goal_store_js_1.attachRun)(boundGoalId, rec.runId).catch(() => null);
@@ -800,6 +816,30 @@ class PiAgentSession {
                     status: 'needs_human',
                     error: 'LLM 不可用: provider 未初始化或无 apiKey (fallback 不是执行结果, 需要配置或人工处理)',
                 });
+                // ★ M0: "工具/权限不可用"也是一条终止路径 → 同样进收尾漏斗 (规则 ④)。
+                const wiring = await Promise.resolve().then(() => __importStar(require('./goal-flywheel-wiring.js')));
+                const closed = await wiring.closeRunOnce({
+                    goalId: boundGoalId,
+                    runId: rec.runId,
+                    caller: 'runner',
+                    now: new Date().toISOString(),
+                    finalReview: `LLM 不可用 → fallback 收尾 (不是执行结果): ${response}`,
+                });
+                if (!wiring.isRefusal(closed) && closed.outcome) {
+                    const { reduceGoalState } = await Promise.resolve().then(() => __importStar(require('./goal-state-reducer.js')));
+                    await reduceGoalState({
+                        goalId: boundGoalId,
+                        intent: 'closure_outcome',
+                        now: new Date().toISOString(),
+                        by: 'runner',
+                        outcome: {
+                            goalStatus: wiring.goalStatusFromDecision(closed.outcome.decision),
+                            continuation: wiring.toGoalStoreContinuation(closed.outcome.continuation),
+                            reason: closed.outcome.decision.reason,
+                        },
+                        runId: rec.runId,
+                    });
+                }
                 console.log(`[PiAgent] LLM 不可用 → 本次仍落 Run ${rec.runId} (needs_human), 不伪装成正常执行`);
             }
             catch (err) {
@@ -1100,7 +1140,7 @@ class PiAgentSession {
             const backoffMs = 1000 * Math.pow(2, attempt - 1); // 1s, 2s, 4s
             console.log(`[PiAgent] loop 自动重试 ${attempt}/${MAX_LOOP_RETRIES}, 等待 ${backoffMs}ms`);
             if (onStream) {
-                onStream({ type: 'status', content: `↻ 自动重试 loop ${attempt}/${MAX_LOOP_RETRIES} (${(backoffMs / 1000).toFixed(0)}s 后)`, tool: 'system' });
+                onStream({ type: 'status', internal: true, content: `↻ 自动重试 loop ${attempt}/${MAX_LOOP_RETRIES} (${(backoffMs / 1000).toFixed(0)}s 后)`, tool: 'system' });
             }
             // 中途 abort 也要响应
             await new Promise((resolve, reject) => {
@@ -1400,17 +1440,51 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
      * 2026-09-16 (M2): 从 checkpoint 恢复一次运行 —— **不是**重发原 prompt。
      * 语义: prepareResume (校验状态 + 读 checkpoint + 记 recovery + 落 recovering) → 用恢复指令
      * 驱动同一个 runId 继续 (历史保留), 非幂等动作由重放守卫挡住。
+     *
+     * 2026-09-26: 恢复前**反查一次模型配置**。Run 记录里存的 `modelConfig` 快照此前只被写进
+     * 快照和回显, 没人拿它核对现状 —— 于是"快照记的是 A, 现在盘上生效的是 B"这种情况会被
+     * 静默继续下去 (长任务的历史执行链就说不清了)。现在: 漂了就 `console.warn` 说清哪几个字段漂了,
+     * 并把结论放进返回值 (`modelDrift`) 让调用方能上报; 一致时也有一句明确结论。
+     * 判断失败 (读不到 Run 等) 不阻塞恢复。
      */
     async resumeRun(runId) {
+        let modelDrift;
+        let modelApplied;
+        try {
+            const { detectRunConfigDrift } = await Promise.resolve().then(() => __importStar(require('../llm/model-selection.js')));
+            modelDrift = (await detectRunConfigDrift(runId)) || undefined;
+            if (modelDrift?.drifted) {
+                console.warn('[pi-sdk] 恢复时模型配置已偏离 Run 快照:', modelDrift.message);
+            }
+            else if (modelDrift) {
+                console.log('[pi-sdk] 恢复前核对:', modelDrift.message);
+            }
+        }
+        catch { /* 核对本身失败不阻塞恢复 */ }
         const prep = await (0, run_store_js_1.prepareResume)(runId);
         if (!prep.ok || !prep.plan)
-            return { ok: false, reason: prep.reason };
+            return { ok: false, reason: prep.reason, ...(modelDrift ? { modelDrift } : {}) };
+        // 2026-09-26 (P6 × P7): 恢复一个在跑的 Run, 用的是**它自己那份快照**, 不是盘上现在的全局默认 ——
+        //   否则这次恢复就是"带着漂移继续跑", 之后再存快照会把漂移固化成历史。
+        //   只在"漂了"或"核对不了"时重装 (一致时运行时本来就是对的, 重装是白跑一趟)。
+        //   装配只有一处实现: `applyRunModelConfigToRuntime` → `installRuntime` (这里不自己 initMinimax)。
+        if (modelDrift && (modelDrift.drifted || !modelDrift.verified)) {
+            try {
+                const { applyRunModelConfigToRuntime } = await Promise.resolve().then(() => __importStar(require('../llm/model-selection.js')));
+                modelApplied = await applyRunModelConfigToRuntime(modelDrift.snapshot);
+                console.log(`[pi-sdk] 已按 Run 快照装配运行时: ${modelApplied.provider}/${modelApplied.model} (configHash ${String(modelApplied.configHash).slice(0, 12)})`);
+            }
+            catch (e) {
+                // 装配失败不阻塞恢复 (如实说; 调用方可以从返回值里看出没装成)
+                console.warn('[pi-sdk] 按 Run 快照装配运行时失败, 保持当前运行时:', String(e?.message || e).slice(0, 160));
+            }
+        }
         this.resumeRunId = runId;
         this.resumePlan = prep.plan;
         this.currentGoalId = prep.plan.goalId || this.currentGoalId;
         try {
             const reply = await this.prompt((0, run_store_js_1.buildResumeInstruction)(prep.plan), {});
-            return { ok: true, reply };
+            return { ok: true, reply, ...(modelDrift ? { modelDrift } : {}), ...(modelApplied ? { modelApplied } : {}) };
         }
         finally {
             this.resumeRunId = '';
@@ -1480,7 +1554,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         const loopActionLog = [];
         // 发送循环开始的事件
         if (onStream) {
-            onStream({ type: 'status', content: '🔄 开始 ReAct 循环...', tool: 'system' });
+            onStream({ type: 'status', internal: true, content: '🔄 开始 ReAct 循环...', tool: 'system' });
         }
         // React Harness: 循环开始 (重置 turn 计数 + 触发 harness sessionStart)
         // 失败静默 (fail-open), 不阻塞主循环
@@ -1512,7 +1586,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             }
             const doneN = this.resumePlan?.completedSteps.length ?? 0;
             const guards = this.resumePlan?.replayGuards.length ?? 0;
-            onStream?.({ type: 'status', content: `♻️ 从 checkpoint 恢复运行 ${this.currentRunId} (已完成 ${doneN} 步, 非幂等重放守卫 ${guards} 条)`, tool: 'harness' });
+            onStream?.({ type: 'status', internal: true, content: `♻️ 从 checkpoint 恢复运行 ${this.currentRunId} (已完成 ${doneN} 步, 非幂等重放守卫 ${guards} 条)`, tool: 'harness' });
         }
         else {
             // 2026-09-16 (M2): 目标绑定 —— 有 goalId 就在该 Goal 下执行; 没有就建 Goal 再建 Run。
@@ -1555,6 +1629,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     goalId: boundGoalId || undefined,
                     channelId: this.currentChannelId || undefined,
                     agentId: this.currentAgentId || undefined,
+                    modelConfig: await this.runModelSnapshot(),
                 });
                 this.currentRunId = rec.runId;
                 this.lastRunId = rec.runId;
@@ -1563,7 +1638,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     // Run → Goal 反查链: runId → goalId → objective / success criteria
                     await (0, goal_store_js_1.attachRun)(this.currentGoalId, rec.runId).catch((err) => console.warn('[PiAgent] attachRun 失败:', err?.message));
                 }
-                onStream?.({ type: 'status', content: `🧷 运行已登记 (run=${rec.runId}${this.currentGoalId ? `, goal=${this.currentGoalId}` : ''}, 预算 ${rec.budget.maxSteps} 步 / ${Math.round(rec.budget.deadlineMs / 60000)} 分钟)`, tool: 'harness' });
+                onStream?.({ type: 'status', internal: true, content: `🧷 运行已登记 (run=${rec.runId}${this.currentGoalId ? `, goal=${this.currentGoalId}` : ''}, 预算 ${rec.budget.maxSteps} 步 / ${Math.round(rec.budget.deadlineMs / 60000)} 分钟)`, tool: 'harness' });
             }
             catch (err) {
                 // 核心写失败: 不再 warn 后继续 —— 没有运行记录就不执行 (strict 模式默认如此)
@@ -1681,7 +1756,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             if ((0, react_loop_js_1.shouldCompactBeforeIteration)(estimatedTokensBefore, compactThreshold)) {
                 const tokensBeforeCompact = estimatedTokensBefore;
                 console.log(`[PiAgent] loop 入口 token ${tokensBeforeCompact} > ${compactThreshold}, 触发自动压缩`);
-                onStream?.({ type: 'status', content: `🗜️ loop 自动压缩 (token ${tokensBeforeCompact} > ${compactThreshold})`, tool: 'compactor' });
+                onStream?.({ type: 'status', internal: true, content: `🗜️ loop 自动压缩 (token ${tokensBeforeCompact} > ${compactThreshold})`, tool: 'compactor' });
                 try {
                     await this.maybeAutoCompact(onStream, signal);
                 }
@@ -1703,7 +1778,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             // 调试日志：显示每次循环开始
             console.log(`[PiAgent] 循环 ${iteration}/${this.MAX_REACT_ITERATIONS} 开始`);
             if (onStream) {
-                onStream({ type: 'status', content: `🔄 循环 ${iteration}/${this.MAX_REACT_ITERATIONS}`, tool: 'loop' });
+                onStream({ type: 'status', internal: true, content: `🔄 循环 ${iteration}/${this.MAX_REACT_ITERATIONS}`, tool: 'loop' });
             }
             const context = this.buildContext();
             // M3.5 (2026-06-17): 也构造 messages 数组版本, 让 LLM 看到结构化 tool 角色
@@ -1892,7 +1967,10 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             }
             // 路径 B: 文本解析 (parseAllToolCalls 收集全部)
             if (toolCalls.length === 0) {
-                const knownTools = new Set(Array.from(this.tools.keys()));
+                // 2026-09-26: 已知名集合 = 注册表原名 + 它们的 API 名 (净化后的).
+                //   出网时工具面给的是 API 名 (见 pi-ai.ts 的唯一净化边界), LLM 在文本里
+                //   回吐的也可能是 API 名 —— 只用原名集合过滤会把这类调用整个丢掉.
+                const knownTools = (0, tool_name_js_1.expandKnownToolNames)(this.tools.keys());
                 toolCalls = (0, parse_tool_call_js_1.parseAllToolCalls)(reply, { tools: knownTools });
             }
             // 回退路径 C: 原生 parseToolCall (单个)
@@ -1901,6 +1979,12 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 if (single)
                     toolCalls.push(single);
             }
+            // 2026-09-26: **回程派发的唯一还原点** —— LLM 回吐的是 API 名 (净化过的), 这里
+            //   还原成注册表真名再交给 this.tools.get(); 原名 (LLM 照 system prompt 抄的) 原样穿透.
+            for (const tc of toolCalls) {
+                if (typeof tc.name === 'string' && tc.name)
+                    tc.name = (0, tool_name_js_1.resolveApiToolName)(tc.name);
+            }
             // 给每个 toolCall 分配稳定 id
             for (const tc of toolCalls) {
                 if (!tc.id) {
@@ -1925,7 +2009,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     if (onStream) {
                         onStream({ type: 'tool', content: `🔧 调用工具 (${ti + 1}/${toolCalls.length}): ${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 });
+                            onStream({ type: 'status', internal: true, content: `📋 参数: ${JSON.stringify(toolCall.args)}`, tool: toolCall.name });
                         }
                         onStream({
                             type: 'step_start',
@@ -2055,7 +2139,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         const toolDurationMs = Date.now() - toolStart;
                         if (replaySkip) {
                             console.log(`[PiAgent] 恢复重放守卫: 跳过已完成的非幂等工具 ${toolCall.name}`);
-                            onStream?.({ type: 'status', content: `🛡️ 恢复保护: ${toolCall.name} 此前已成功执行, 本次不重复执行`, tool: toolCall.name });
+                            onStream?.({ type: 'status', internal: true, content: `🛡️ 恢复保护: ${toolCall.name} 此前已成功执行, 本次不重复执行`, tool: toolCall.name });
                         }
                         console.log(`[PiAgent] 工具 ${toolCall.name} 执行完成: success=${result.success} (${toolDurationMs}ms)`);
                         // 2026-09-16 (M3): 失败接线 —— 分类 + recovery 留痕 + 熔断 / 外部等待
@@ -2128,7 +2212,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         }
                         if (onStream) {
                             if (result.success) {
-                                onStream({ type: 'status', content: `✅ ${toolCall.name} 执行成功`, tool: toolCall.name });
+                                onStream({ type: 'status', internal: true, content: `✅ ${toolCall.name} 执行成功`, tool: toolCall.name });
                                 if (result.output) {
                                     onStream({ type: 'tool', content: `📤 结果: ${result.output.substring(0, 200)}${result.output.length > 200 ? '...' : ''}`, tool: toolCall.name });
                                 }
@@ -2158,7 +2242,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                                 refineAttempts++;
                             }
                             if (onStream) {
-                                onStream({ type: 'status', content: `🔄 工具执行完成，继续循环...`, tool: 'loop' });
+                                onStream({ type: 'status', internal: true, content: `🔄 工具执行完成，继续循环...`, tool: 'loop' });
                             }
                         }
                         else {
@@ -2244,7 +2328,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             content: `[dive-into stop condition] 你之前已成功执行了 ${unreported} 个工具, 但当前回复里没把它们的结果告诉用户. 请基于已有的工具结果 (在 history 里) 写一个完整总结回复给用户, 用 <final gen> 结尾. 不要再调工具.`
                         });
                         if (onStream) {
-                            onStream({ type: 'status', content: `🔄 还有 ${unreported} 个工具结果未汇报, 让 LLM 继续总结 (${unreportedRetries}/${MAX_UNREPORTED_RETRIES})`, tool: 'system' });
+                            onStream({ type: 'status', internal: true, content: `🔄 还有 ${unreported} 个工具结果未汇报, 让 LLM 继续总结 (${unreportedRetries}/${MAX_UNREPORTED_RETRIES})`, tool: 'system' });
                         }
                         continue;
                     }
@@ -2257,7 +2341,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             content: `[dive-into stop condition] 已多次提示汇报工具结果仍未完成 (超过 ${MAX_UNREPORTED_RETRIES} 次). 现在直接基于你已知的信息写最终回复给用户, 用 <final gen> 结尾, 不要再调任何工具.`
                         });
                         if (onStream) {
-                            onStream({ type: 'status', content: `🔄 工具结果汇报超限, 强制收尾`, tool: 'system' });
+                            onStream({ type: 'status', internal: true, content: `🔄 工具结果汇报超限, 强制收尾`, tool: 'system' });
                         }
                     }
                     lastQualityScore = this.estimateResponseQuality(reply);
@@ -2287,7 +2371,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         console.log(`[PiAgent] review ${loopReviewCount}/${loop_review_js_1.DEFAULT_MAX_REVIEWS}: LLM 想 final 但先对齐需求深挖一次`);
                         this.messageHistory.push({ role: 'system', content: reviewDecision.hint });
                         if (onStream) {
-                            onStream({ type: 'status', content: `🔄 目标对齐 review ${loopReviewCount}/${loop_review_js_1.DEFAULT_MAX_REVIEWS}: 深挖续跑`, tool: 'system' });
+                            onStream({ type: 'status', internal: true, content: `🔄 目标对齐 review ${loopReviewCount}/${loop_review_js_1.DEFAULT_MAX_REVIEWS}: 深挖续跑`, tool: 'system' });
                         }
                         continue; // 让 LLM 看到 hint, 深挖或确认完成后再次 final
                     }
@@ -2311,14 +2395,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 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' });
+                        onStream({ type: 'status', internal: true, content: `🔄 继续处理，循环 ${iteration}...`, tool: 'loop' });
                     }
                     continue;
                 }
                 // 否则把这个当作可能的最终回答
                 finalResponse = reply;
                 if (onStream) {
-                    onStream({ type: 'status', content: `📝 提取最终回答，长度 ${reply.length}`, tool: 'system' });
+                    onStream({ type: 'status', internal: true, content: `📝 提取最终回答，长度 ${reply.length}`, tool: 'system' });
                 }
                 break;
             }
@@ -2336,7 +2420,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         }
         // 通知前端循环完成
         if (onStream) {
-            onStream({ type: 'status', content: `✅ 处理完成，共 ${iteration - 1} 次循环`, tool: 'system' });
+            onStream({ type: 'status', internal: true, content: `✅ 处理完成，共 ${iteration - 1} 次循环`, tool: 'system' });
         }
         this.messageHistory.push({ role: 'assistant', content: finalResponse });
         // React Harness: 循环结束
@@ -2384,30 +2468,61 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 await (0, run_store_js_1.recordDegradation)({ kind: 'core', op: 'pi-sdk.finishRun', runId: this.currentRunId, message }).catch(() => { });
                 onStream?.({ type: 'error', content: `⚠️ ${message}`, tool: 'harness' });
             }
-            // 2026-09-16 (M4): Goal 侧完成门 —— Run 结束 ≠ Goal 完成; 只有判据全满足 + 有证据 + 无未解决项才算
+            // ★ 2026-09-25 (M0 接线冻结, 规则 ③ + ④): Run 结束**必过收尾漏斗**。
+            //
+            // 旧写法在这里另起了一套 Goal 侧收尾 (读证据 → `evaluateGoalCompletion` →
+            // `completeGoalIfEligible` / `setUnresolved`): 它**不收尾** —— 不写 Memory、不生成 Skill 候选、
+            // 不写权威 continuation、不留决策记录。于是同一条 Run 在 Supervisor 那里还会再收一次 (或反过来
+            // 这条路径根本不收), 全仓就有了两套"这一轮跑完意味着什么"。那一套已删除。
+            //
+            // 现在: `closeRunOnce` (幂等) → 9 步收尾 → 产物落盘; 再由 Goal reducer 把"下一步是什么"
+            // 落进 Goal (没有 Supervisor 宿主时 Runner 也要留下 continuation, 否则下一次还是从零开始)。
             if (this.currentGoalId) {
                 try {
-                    const full = await (0, run_store_js_1.readRun)(this.currentRunId).catch(() => null);
-                    const ev = (full?.evidence || []).slice(-10);
-                    if (ev.length)
-                        await (0, goal_store_js_1.addEvidence)(this.currentGoalId, ev);
-                    const goal = await (0, goal_store_js_1.readGoal)(this.currentGoalId);
-                    if (goal) {
-                        const verdict = (0, goal_store_js_1.evaluateGoalCompletion)(goal);
-                        if (verdict.complete) {
-                            const done = await (0, goal_store_js_1.completeGoalIfEligible)(this.currentGoalId);
-                            onStream?.({ type: 'status', content: `🎯 目标已达成: ${done.reason} (goal=${this.currentGoalId})`, tool: 'harness' });
-                        }
-                        else {
-                            // 不静默: 未达成的目标留在 active, 未解决项写清楚 (下次 prompt 会继续这个 Goal)
-                            const items = verdict.missing.length ? verdict.missing : [`run=${this.currentRunId} 结束但目标未达成: ${verdict.reason}`];
-                            await (0, goal_store_js_1.setUnresolved)(this.currentGoalId, items);
-                            onStream?.({ type: 'status', content: `🎯 目标仍在进行 (未判完成): ${verdict.reason}`, tool: 'harness' });
-                        }
+                    const wiring = await Promise.resolve().then(() => __importStar(require('./goal-flywheel-wiring.js')));
+                    const { reduceGoalState } = await Promise.resolve().then(() => __importStar(require('./goal-state-reducer.js')));
+                    const nowIso = new Date().toISOString();
+                    const closed = await wiring.closeRunOnce({
+                        goalId: this.currentGoalId,
+                        runId: this.currentRunId,
+                        caller: 'runner',
+                        now: nowIso,
+                        finalReview: finalResponse ? String(finalResponse).slice(0, 2000) : '',
+                    });
+                    if (wiring.isRefusal(closed)) {
+                        onStream?.({ type: 'status', content: `⚠️ 收尾被拒 (不当作收过): ${closed.reason}`, tool: 'harness' });
+                    }
+                    else if (closed.outcome) {
+                        const view = closed.outcome;
+                        const applied = await reduceGoalState({
+                            goalId: this.currentGoalId,
+                            intent: 'closure_outcome',
+                            now: nowIso,
+                            by: 'runner',
+                            outcome: {
+                                goalStatus: wiring.goalStatusFromDecision(view.decision),
+                                continuation: wiring.toGoalStoreContinuation(view.continuation),
+                                reason: view.decision.reason,
+                            },
+                            runId: view.runId,
+                        });
+                        const line = view.decision.decision === 'complete'
+                            ? `🎯 目标已达成 (仍要过完成门): ${view.decision.reason}`
+                            : `🎯 目标仍在进行 (未判完成): ${view.decision.reason}`;
+                        onStream?.({
+                            type: 'status', internal: true,
+                            content: `${line}${applied.gateRejected ? ` [完成门拒绝: ${applied.gateRejected}]` : ''} `
+                                + `(收尾 ${view.steps} 步 · memory ${view.memories} · skill 候选 ${view.candidates} · goal=${this.currentGoalId})`,
+                            tool: 'harness',
+                        });
+                    }
+                    else {
+                        // 幂等: 别处 (或上一次) 已经收过尾 —— 事实读不回来就如实说, 不重收也不假装
+                        onStream?.({ type: 'status', content: `🎯 ${closed.reason}`, tool: 'harness' });
                     }
                 }
                 catch (err) {
-                    await (0, run_store_js_1.recordDegradation)({ kind: 'observational', op: 'pi-sdk.goalCompletion', runId: this.currentRunId, message: String(err?.message || err).slice(0, 160) }).catch(() => { });
+                    await (0, run_store_js_1.recordDegradation)({ kind: 'observational', op: 'pi-sdk.runClosure', runId: this.currentRunId, message: String(err?.message || err).slice(0, 160) }).catch(() => { });
                 }
             }
             this.currentRunId = '';
@@ -2585,7 +2700,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         const estimated = this.estimateHistoryTokens();
         if (estimated > this.maxContextTokens() * 0.8) {
             console.warn(`[PiAgent] reactive compaction pre-check (${estimated} tokens > 80% threshold)`);
-            onStream?.({ type: 'status', content: '⚠️ reactive compaction 预检触发', tool: 'recovery' });
+            onStream?.({ type: 'status', internal: true, content: '⚠️ reactive compaction 预检触发', tool: 'recovery' });
             try {
                 const compacted = this.compressHistorySync(this.messageHistory);
                 this.messageHistory = compacted;
@@ -2739,7 +2854,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
     async maybeAutoCompact(onStream, signal) {
         if (this.messageHistory.length < 10)
             return; // 历史太短, 不值得压
-        onStream?.({ type: 'status', content: '🗜️ 评估是否需要压缩上下文...', tool: 'compactor' });
+        onStream?.({ type: 'status', internal: true, content: '🗜️ 评估是否需要压缩上下文...', tool: 'compactor' });
         // 注入 LLM (用 getMinimax().chat, 与 judgment 注入门 / ReAct 循环同一来源)
         // 给 Context Collapse (虚拟投影) 和 Auto-Compact (摘要) 共用
         const llm = (0, index_js_1.getMinimax)();
@@ -2767,7 +2882,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             const savedTokens = Math.max(0, beforeTokens - afterTokens);
             cm.markCompressStart(beforeTokens);
             onStream?.({
-                type: 'status',
+                type: 'status', internal: true,
                 content: `🗜️ 上下文压缩: ${stagesApplied || 'no-op'} | 节省 ${saved} 条 / ${savedTokens.toLocaleString()} tokens (剩余 ${result.history.length}, collapse=${isContextCollapseEnabled() ? 'on' : 'off'})`,
                 tool: 'compactor',
             });