@bolloon/bolloon-agent 0.5.0 → 0.5.2

package/dist/agents/pi-sdk.js

@@ -30,6 +30,11 @@ import { WorkflowPivotLoop, createDefaultPivotConfig } from './workflow-pivot-lo
 import { initDocumentReceiver } from './p2p-document-tools.js';
 import { startRun, recordStep, finishRun, readRun, budgetVerdict, recordDegradation, recordHarnessEvent, recordRecovery, setRunStatus, prepareResume, markRunRunning, buildResumeInstruction, argsDigestOf, repeatedFailureCount, classifyError as classifyRunError } from './run-store.js';
 import { createGoal, attachRun, findActiveGoal } from './goal-store.js';
+import { captureRunModelConfig } from '../llm/model-selection.js';
+// 2026-09-26: 工具名出网净化 (pi-ai.ts 唯一边界) + 回程派发还原 (原名 ↔ API 名)
+import { resolveApiToolName, expandKnownToolNames } from '../llm/tool-name.js';
+// 2026-09-28 (前缀 KV 可命中): CURRENT TURN 注入标记 —— "当前轮是否已注入"的唯一判据
+import { CURRENT_TURN_MARKER } from '../llm/pi-ai.js';
 import { PiAgentHarness } from './pi-harness.js';
 import { DiscoveredAgentsManager, createSocialHeartbeat } from '../social/heartbeat.js';
 import { SkillRegistry } from '@bolloon/constraint-runtime';
@@ -76,6 +81,55 @@ import { DEFAULT_MAX_REVIEWS } from './loop-review.js';
  *   循环内: 注入 system 提示强制 LLM 收尾; 运行层 (M3): 熔断 → needs_human (交人)。
  */
 const MAX_SAME_TOOL_FAILURES = 3;
+/**
+ * 2026-09-28 (前缀 KV 可命中): 把 chat() 回带的「当前轮已注入」内容写回调用方自己的 history.
+ *
+ * 谁是调用方: ReAct 循环每轮用 `buildMessages()` **重建全新对象** —— 注入只活在那一份里.
+ *   不写回的话下一轮那条 user 就退回注入前, 前缀从它起分叉:
+ *     第 1 次 `S H [D1 U1]`   第 2 次 `S H U1 U2`   ← U1 丢了 D1
+ *   正确形态: `S H [D1 U1] U2` (D1 成了 U1 的一部分, 于是成为后续轮的稳定前缀).
+ *
+ * 为什么是纯函数 (不塞进类里): 门 `scripts/verify-kv-prefix.ts` 要能**直接驱它**断言,
+ *   而不是绕一整条 ReAct 循环才验到"写回"这一下.
+ *
+ * 匹配判据 (只做加法, 绝不乱改历史):
+ *   1. wire 最后一条 content 必须以 CURRENT TURN 标记开头 (没注入过 → 0, 不动);
+ *   2. 从 history **末尾往前**找第一条 `content` 是它后缀的条目 ——
+ *      去掉后缀剩下的那截必须仍以标记开头 (证明"注入是前部加了一段");
+ *   3. 命中就整段写回 (tool 条目拿到的是含 `[工具结果]\n` 前缀 + 注入的整段),
+ *      写回后该条 `content` 已等于 wire → 第二次调用前缀为空, 自然返回 0 (幂等).
+ *
+ * @returns 真写回的条数 (0 = 没注入过 / 匹配不上 / 已经写回过)
+ */
+export function writeBackCurrentTurnInto(history, wire) {
+    try {
+        if (!Array.isArray(history) || history.length === 0)
+            return 0;
+        if (!Array.isArray(wire) || wire.length === 0)
+            return 0;
+        const last = wire[wire.length - 1];
+        const wireContent = typeof last?.content === 'string' ? last.content : '';
+        if (!wireContent.startsWith(CURRENT_TURN_MARKER))
+            return 0; // 没注入过 → 不动
+        for (let i = history.length - 1; i >= 0; i--) {
+            const entry = history[i];
+            const inner = typeof entry?.content === 'string' ? entry.content : '';
+            if (!inner)
+                continue;
+            if (!wireContent.endsWith(inner))
+                continue;
+            const prefix = wireContent.slice(0, wireContent.length - inner.length);
+            if (!prefix || !prefix.startsWith(CURRENT_TURN_MARKER))
+                continue;
+            entry.content = wireContent;
+            return 1;
+        }
+        return 0;
+    }
+    catch {
+        return 0; // 写回失败绝不影响对话本身
+    }
+}
 export class PiAgentSession {
     cwd;
     peerId;
@@ -645,6 +699,18 @@ export class PiAgentSession {
             return false;
         }
     }
+    /**
+     * 2026-09-26: 这个 Run 开始那一刻**真实生效**的模型配置快照, 由 startRun 落进 Run 记录。
+     * 拿不到 (配置读不出来) 就返回 undefined —— 宁可这个字段缺, 也不编一个假的进去。
+     */
+    async runModelSnapshot() {
+        try {
+            return await captureRunModelConfig();
+        }
+        catch {
+            return undefined;
+        }
+    }
     /** 2026-08-07: prompt 出口统一上报 token 用量到 ContextManager (fallback/pivot/react 全路径覆盖) —
      *   之前只有 runReActLoop 迭代内上报, chitchat/fallback/pivot 路径状态栏恒 0 */
     reportUsageToContextManager() {
@@ -749,6 +815,7 @@ export class PiAgentSession {
                     goalId: boundGoalId,
                     channelId: this.currentChannelId || undefined,
                     agentId: this.currentAgentId || undefined,
+                    modelConfig: await this.runModelSnapshot(),
                 });
                 this.lastRunId = rec.runId;
                 await attachRun(boundGoalId, rec.runId).catch(() => null);
@@ -1081,7 +1148,7 @@ export 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) => {
@@ -1381,17 +1448,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 import('../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 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 import('../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(buildResumeInstruction(prep.plan), {});
-            return { ok: true, reply };
+            return { ok: true, reply, ...(modelDrift ? { modelDrift } : {}), ...(modelApplied ? { modelApplied } : {}) };
         }
         finally {
             this.resumeRunId = '';
@@ -1461,7 +1562,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), 不阻塞主循环
@@ -1493,7 +1594,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。
@@ -1536,6 +1637,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;
@@ -1544,7 +1646,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     // Run → Goal 反查链: runId → goalId → objective / success criteria
                     await 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 模式默认如此)
@@ -1662,7 +1764,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             if (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);
                 }
@@ -1684,7 +1786,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 角色
@@ -1724,12 +1826,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     .join('\n');
                 loopProgressSection = `\n【本轮循环进度】你已完成以下 ${loopActionLog.length} 个动作, 这是连续执行的同一轮任务:\n${actionLines}\n请基于已有结果继续推进, 不要重复执行上面已成功的动作. 全部完成后用 <final gen> 结束.\n`;
             }
+            // 2026-09-28 (前缀 KV 可命中): `refineContext` / `loopProgressSection` 是**每轮都在变**的段
+            //   (质量分 / 连续错误数 / 本轮已完成动作). 留在 system 里 = 每轮把 IMMUTABLE PREFIX 打碎 =
+            //   服务端前缀 KV 永远 miss. 移到 CURRENT TURN 区 (注入到最后一条 user 前部) —— 文本一字未改, 只换位置.
+            const currentTurnContext = `${refineContext}${loopProgressSection}`;
             const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
 当前工作目录: ${this.cwd}
 当前身份: ${this.identity.name} (${this.identity.did})
-${refineContext}
 ${this.currentIntentHint}
-${loopProgressSection}
 
 ${toolDefs}
 
@@ -1779,7 +1883,11 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             // 2026-09-16 (Milestone 1-B): 模型调用前后走唯一门面 (扩展点 + 计数留痕; 默认不加新 hook 事件, 避免改变现有触发次数)
             this.piHarness().beforeModelCall(this.harnessCtx());
             const _modelCallT0 = Date.now();
-            const response = await this.callLlmWithRecovery(llm, messages, systemPrompt, signal, onStream, openaiFormattedTools);
+            const response = await this.callLlmWithRecovery(llm, messages, systemPrompt, signal, onStream, openaiFormattedTools, currentTurnContext);
+            // 2026-09-28 (前缀 KV 可命中): 把注入了 CURRENT TURN 的当前轮**原样写回自己的 messageHistory** ——
+            //   buildMessages() 每轮重建全新对象, 不写回的话下一轮那条 user 就退回注入前, 前缀从那里分叉.
+            //   用 chat() 回带的 wire (真正发出去的那一份), 而不是把 messages 再拼一遍.
+            this.writeBackCurrentTurn(response.messages);
             this.piHarness().afterModelCall(this.harnessCtx(), { ms: Date.now() - _modelCallT0 });
             const reply = (response.reply || '').trim();
             // 2026-06-30: OpenAI 协议 native tool_calls (LLM 真产了 tool_call 时, minimax/M3 会返回 id)
@@ -1873,7 +1981,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 = expandKnownToolNames(this.tools.keys());
                 toolCalls = parseAllToolCalls(reply, { tools: knownTools });
             }
             // 回退路径 C: 原生 parseToolCall (单个)
@@ -1882,6 +1993,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 = resolveApiToolName(tc.name);
+            }
             // 给每个 toolCall 分配稳定 id
             for (const tc of toolCalls) {
                 if (!tc.id) {
@@ -1906,7 +2023,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',
@@ -2036,7 +2153,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 留痕 + 熔断 / 外部等待
@@ -2109,7 +2226,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 });
                                 }
@@ -2139,7 +2256,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                                 refineAttempts++;
                             }
                             if (onStream) {
-                                onStream({ type: 'status', content: `🔄 工具执行完成，继续循环...`, tool: 'loop' });
+                                onStream({ type: 'status', internal: true, content: `🔄 工具执行完成，继续循环...`, tool: 'loop' });
                             }
                         }
                         else {
@@ -2225,7 +2342,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;
                     }
@@ -2238,7 +2355,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);
@@ -2268,7 +2385,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         console.log(`[PiAgent] review ${loopReviewCount}/${DEFAULT_MAX_REVIEWS}: LLM 想 final 但先对齐需求深挖一次`);
                         this.messageHistory.push({ role: 'system', content: reviewDecision.hint });
                         if (onStream) {
-                            onStream({ type: 'status', content: `🔄 目标对齐 review ${loopReviewCount}/${DEFAULT_MAX_REVIEWS}: 深挖续跑`, tool: 'system' });
+                            onStream({ type: 'status', internal: true, content: `🔄 目标对齐 review ${loopReviewCount}/${DEFAULT_MAX_REVIEWS}: 深挖续跑`, tool: 'system' });
                         }
                         continue; // 让 LLM 看到 hint, 深挖或确认完成后再次 final
                     }
@@ -2292,14 +2409,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;
             }
@@ -2317,7 +2434,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: 循环结束
@@ -2407,7 +2524,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             ? `🎯 目标已达成 (仍要过完成门): ${view.decision.reason}`
                             : `🎯 目标仍在进行 (未判完成): ${view.decision.reason}`;
                         onStream?.({
-                            type: 'status',
+                            type: 'status', internal: true,
                             content: `${line}${applied.gateRejected ? ` [完成门拒绝: ${applied.gateRejected}]` : ''} `
                                 + `(收尾 ${view.steps} 步 · memory ${view.memories} · skill 候选 ${view.candidates} · goal=${this.currentGoalId})`,
                             tool: 'harness',
@@ -2511,6 +2628,11 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             const source = this.projectedHistory ?? this.messageHistory;
             const WINDOW = 15;
             const out = [];
+            // 2026-09-28 (前缀 KV 可命中): 带 CURRENT TURN 注入的条目要**原样回带**.
+            // 两个理由: (1) 注入块是"当前轮的前缀", 重渲染 (重加 `[工具结果]` 前缀 / 再 slice 截断)
+            //   会改字节 → 下一轮前缀从这条起分叉; (2) 已注入的 tool 条目在 wire 上已经是 user 形状,
+            //   再套一次前缀就是双前缀, 连内容都变了.
+            const isInjectedEntry = (m) => typeof m.content === 'string' && m.content.includes(CURRENT_TURN_MARKER);
             // 早期历史压缩: 超过窗口时, 不直接丢弃 — 提取前段用户意图摘要注入 (同步, 无 LLM).
             // 结构对齐 Context OS: System Prompt(persona) + 压缩摘要 + 最近消息.
             if (source.length > WINDOW) {
@@ -2526,6 +2648,10 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 });
                 for (const m of slice) {
                     const r = m.role;
+                    if (isInjectedEntry(m)) {
+                        out.push({ role: 'user', content: String(m.content) });
+                        continue;
+                    }
                     if (r === 'tool') {
                         out.push({ role: 'user', content: `[工具结果]\n${(m.content || '').slice(0, 2000)}` });
                         continue;
@@ -2548,6 +2674,10 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             const slice = source.slice(-WINDOW);
             for (const m of slice) {
                 const r = m.role;
+                if (isInjectedEntry(m)) {
+                    out.push({ role: 'user', content: String(m.content) });
+                    continue;
+                }
                 if (r === 'tool') {
                     out.push({ role: 'user', content: `[工具结果]\n${m.content || ''}` });
                     continue;
@@ -2571,6 +2701,20 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             return [{ role: 'user', content: this.buildContext() }];
         }
     }
+    /**
+     * 2026-09-28 (前缀 KV 可命中): 把 chat() 回带的当前轮写回自己的 messageHistory.
+     * 逻辑在模块级 `writeBackCurrentTurnInto` (纯函数, 门可以直接驱它断言);
+     * 这里只负责接到 `this.messageHistory` 上, 并保证任何异常都静默 (写回失败不影响对话).
+     */
+    writeBackCurrentTurn(wire) {
+        try {
+            return writeBackCurrentTurnInto(this.messageHistory, wire);
+        }
+        catch (err) {
+            console.warn('[PiAgent] writeBackCurrentTurn failed (silent):', err);
+            return 0;
+        }
+    }
     /**
      * 估算 messageHistory 的 token 数 (4 字符 ≈ 1 token, 与 context-compaction 同步).
      * 失败静默: 任何异常 → 0 (不阻塞)
@@ -2592,12 +2736,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
      *
      * 失败静默: 全部失败 → 返回空 reply, 让上层 no-tool_use 终止
      */
-    async callLlmWithRecovery(llm, contextOrMessages, systemPrompt, signal, onStream, tools) {
+    async callLlmWithRecovery(llm, contextOrMessages, systemPrompt, signal, onStream, tools, 
+    /** 2026-09-28: 当前轮易变段 (循环进度/改进提示) —— 进 CURRENT TURN 区, 不进 system */
+    currentTurnContext) {
         // Reactive compaction 预检: 估算 token 超 80% 阈值, 跑一次
         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;
@@ -2646,9 +2792,13 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 // M3.5 (2026-06-17): 传 messages 数组 (如果 contextOrMessages 是数组) 或字符串
                 //   数组版让 LLM 看到结构化的 user/assistant/tool role, 而不是把 history 拼成单字符串
                 // Bug 5: pass tool IDs for native OpenAI tool calling
-                const response = await llm.chat(contextOrMessages, systemPrompt, signal, tools);
+                // 2026-09-28 (前缀 KV 可命中): 显式 purpose/source —— pi-sdk 的 ReAct 循环**就是主对话**
+                //   (完整 IMMUTABLE PREFIX + 工具全集 + CURRENT TURN, 也只有它带 cache_prompt);
+                //   currentTurnContext 是调用方自己的当前轮易变段 (循环进度/改进提示), 走 CURRENT TURN 区.
+                // 2026-09-28: 回带最终 wire messages (含注入后的当前轮) → 上层据此写回 messageHistory.
+                const response = await llm.chat(contextOrMessages, systemPrompt, signal, tools, 'main-agent', 'react-loop', undefined, currentTurnContext);
                 // 2026-06-30: 透传 toolCalls (OpenAI 协议 native) 给上层, 让 assistant message 能 emit 真 id
-                return { reply: response.reply || '', toolCalls: response.toolCalls };
+                return { reply: response.reply || '', toolCalls: response.toolCalls, messages: response.messages };
             }
             catch (err) {
                 // 用户主动 abort: 不重试, 立即抛
@@ -2751,12 +2901,14 @@ ${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 = getMinimax();
         const llmChat = async (systemPrompt, userPrompt) => {
-            const r = await llm.chat(userPrompt, systemPrompt, signal);
+            // 2026-09-28 (前缀 KV 可命中): 压缩摘要是**非主对话的一次性调用** → 轻量前缀
+            //   (它不该拖满 IMMUTABLE PREFIX, 更不该把主对话的 KV slot 顶掉).
+            const r = await llm.chat(userPrompt, systemPrompt, signal, undefined, 'auto-compact', 'pi-sdk-compact');
             return r.reply;
         };
         // 2026-08-06: 预算 = ContextManager 配置 (1M * 55% ≈ 550K), 不再写死 8000.
@@ -2779,7 +2931,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',
             });
@@ -3022,7 +3174,8 @@ ${this.extractOperationsFromRef(operationsRef)}
         const conversation = messages.map(m => `${m.type === 'user' ? '用户' : '助手'}: ${m.content}`).join('\n');
         const llm = getMinimax();
         try {
-            const response = await llm.chat(`根据以下对话内容，为这个对话生成一个简短的名称（不超过20个字）：\n\n${conversation}\n\n直接输出名称，不要其他解释。`, '命名建议');
+            const response = await llm.chat(`根据以下对话内容，为这个对话生成一个简短的名称（不超过20个字）：\n\n${conversation}\n\n直接输出名称，不要其他解释。`, '命名建议', undefined, undefined, 'chat', 'session-namer' // 非主对话: 轻量前缀, 不抢主对话的 KV slot
+            );
             const name = response.reply.trim();
             // 拒绝错误回退串 (LLM 不可用时返回的占位文本)
             if (!name)

package/dist/agents/run-store.js

@@ -39,6 +39,8 @@ export function canTransition(from, to) {
     return (RUN_TRANSITIONS[from] || []).includes(to);
 }
 export const MAX_HARNESS_EVENTS = 50;
+/** 模型切换账本只留最近 N 条 (审计账本, 不是全量日志) */
+export const MAX_MODEL_SWITCHES = 20;
 const DEFAULT_HARNESS = {
     maxSteps: Number(process.env.BOLLOON_RUN_MAX_STEPS || 60),
     deadlineMs: Number(process.env.BOLLOON_RUN_DEADLINE_MS || 30 * 60_000),
@@ -343,6 +345,7 @@ export async function startRun(opts) {
         steps: [],
         budget: { maxSteps: cfg.maxSteps, deadlineMs: cfg.deadlineMs },
         recovery: [],
+        modelConfig: opts.modelConfig,
     };
     await coreWrite('startRun', rec.runId, () => writeRun(rec));
     return rec;
@@ -453,6 +456,56 @@ export async function recordHarnessEvent(runId, evt) {
         await recordDegradation({ kind: 'observational', op: 'recordHarnessEvent', runId, message: `${evt.event}/${evt.kind} 写入失败: ${String(err?.message || err).slice(0, 150)}` });
     }
 }
+/**
+ * 2026-09-26 (P7): 记一次模型切换决定 (Run 事件)。
+ *
+ * 与 `recordHarnessEvent` 同一纪律: 决策**已经**做出, 记账失败绝不反过来改决策 ——
+ * 所以这里只记降级 + 返回 `{ok:false}` 让调用方能如实上报, 不抛。
+ * 写两处事实: ① `modelSwitches` 账本 (机器可查的切换链); ② `harness` 事件 (人工审计的那本账)。
+ * 本次写入**不改** `modelConfig` —— Run 快照一旦定稿就不再改写。
+ */
+export async function recordModelSwitch(runId, evt) {
+    const full = {
+        ts: evt.ts || new Date().toISOString(),
+        ...evt,
+        runId: evt.runId || runId,
+    };
+    try {
+        const rec = await withRunLock(runId, async () => {
+            const cur = await readRun(runId);
+            if (!cur)
+                return null;
+            cur.modelSwitches = cur.modelSwitches || [];
+            cur.modelSwitches.push(full);
+            if (cur.modelSwitches.length > MAX_MODEL_SWITCHES) {
+                cur.modelSwitches = cur.modelSwitches.slice(-MAX_MODEL_SWITCHES);
+            }
+            // 人工审计账本: 同一件事在 harness 事件里也留一条 (kind 按结果映射, 不美化)
+            cur.harness = cur.harness || [];
+            cur.harness.push({
+                ts: full.ts,
+                event: 'model.switch',
+                kind: full.outcome === 'switched' ? 'note' : 'deny',
+                reason: `${full.outcome} mode=${full.mode} source=${full.source} → ${full.to.provider}/${full.to.model}#${full.to.configHash} · 守卫 ${full.guardsCarried} 条 · ${full.reason}`.slice(0, 400),
+                runId,
+                goalId: full.goalId,
+            });
+            if (cur.harness.length > MAX_HARNESS_EVENTS)
+                cur.harness = cur.harness.slice(-MAX_HARNESS_EVENTS);
+            cur.updatedAt = new Date().toISOString();
+            await writeRun(cur);
+            return cur;
+        });
+        if (!rec)
+            return { ok: false, reason: `run 不存在: ${runId}` };
+        return { ok: true, record: rec };
+    }
+    catch (err) {
+        const reason = `模型切换事件写入失败: ${String(err?.message || err).slice(0, 160)}`;
+        await recordDegradation({ kind: 'observational', op: 'recordModelSwitch', runId, message: reason });
+        return { ok: false, reason };
+    }
+}
 /** 防止"同一个工具 + 同一组参数"无限重试: 返回该指纹最近的连续失败次数 */
 export function repeatedFailureCount(rec, tool, argsDigest) {
     let n = 0;

package/dist/agents/task/task-runner.js

@@ -19,6 +19,7 @@ import * as fs from 'fs';
 import * as crypto from 'crypto';
 import { createGoal, attachRun, markCriterion, readGoal, setCriteria, } from '../goal-store.js';
 import { startRun, recordStep, finishRun, readRun } from '../run-store.js';
+import { captureRunModelConfig } from '../../llm/model-selection.js';
 import { listTransactions, updateTransaction, setTransactionStatus } from '../x402/transaction-store.js';
 import { bridgeTransactionToRunGoal } from '../x402/goal-run-bridge.js';
 import { buyInfoAsTransaction } from '../x402/trade.js';
@@ -315,7 +316,13 @@ export async function runTask(opts) {
             return { ok: false, card, text: renderReportCard(card), stages, budget, outputIssues: [] };
         }
     }
-    const run = await startRun({ surface: 'cli', goal: opts.task, goalId: goal.goalId });
+    const run = await startRun({
+        surface: 'cli',
+        goal: opts.task,
+        goalId: goal.goalId,
+        // 2026-09-26: 任务执行链同样要记下"这一跑用的是哪一份模型配置"
+        modelConfig: await captureRunModelConfig().catch(() => undefined),
+    });
     await attachRun(goal.goalId, run.runId);
     const fail = async (stage, note, cardOpts, runStatus = 'needs_human') => {
         mark(stage, note);