@bolloon/bolloon-agent 0.5.4 → 0.6.0

package/dist/agents/pi-sdk.js

@@ -9,9 +9,28 @@
  *   - factory      → ./pi-sdk-session-factory.ts  (createAgentSession / getAgentSession / resetAgentSession / runSelfImproveLoop)
  *   - 本文件                                       (PiAgentSession 类: LLM 循环 / 系统提示 / 工具调用分发 / 压缩 / persistence)
  */
+import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { createRunContext } from './run-context.js';
+import { createPrivateActor } from '../kernel/channel-actor.js';
+import { expandHomeArgs } from './tool-path-args.js';
+import { renderDelegateNotices, pushNotice, renderNoticeBlock } from './background-notices.js';
+import { runWithWriteOrigin } from './skill-ledger.js';
+import { createHash } from 'node:crypto';
+import { shouldReviewTask, runExperienceReview } from './experience-review.js';
+import { decideLessonSink, skillsFromDirs, logLessonSuggestions, routeLessonToSkill } from './lesson-to-skill.js';
+import { managedServices } from './managed-services.js';
+import { IterationBudget, isRefundableTool } from './iteration-budget.js';
+import { recordToolCall, argsFingerprint } from './tool-telemetry.js';
+import { capToolResult } from './tool-result-gate.js';
+import { renderToolListWithParams } from './tool-subset.js';
+import { codeWriteTarget, decideTypecheck, formatTypecheckResult } from './code-write-gate.js';
+// 2026-10-01: 身份解析必须**静态导入** —— 之前在函数体里用 require(), 而打包后是 ESM ⇒
+//   require 是 undefined ⇒ 抛错被 catch 静默吞掉 ⇒ "自愈"根本没跑, DID 一直是空的 ✗。
+import { loadOrCreateAgentIdentity } from './agent-identity.js';
+import { agentPersonaName } from './channel-identity.js';
 import { getContextManager } from '../bootstrap/context-manager.js';
 import { createRequire } from 'module';
 import { currentPackageRoot } from '../utils/version-info.js';
@@ -68,7 +87,7 @@ import { ReactHarness } from '../security/react-harness.js';
 import { HooksEngine } from '../hooks/hooks-engine.js';
 import { DenyPipeline } from './deny-pipeline.js';
 import { parseToolCall as parseToolCallImpl, parseAllToolCalls, isFinalResponse as isFinalResponseImpl, extractFinalAnswer as extractFinalAnswerImpl } from './parse-tool-call.js';
-import { buildObservation, buildReflection, formatObservationWithReflection } from './error-classifier.js';
+import { buildObservation, buildReflection, formatObservationWithReflection, classifyError } from './error-classifier.js';
 import { sessionStore as defaultSessionStore } from './session-store.js';
 import { ToolRegistry } from './tool-registry.js';
 import { decideMaxIterations, decideContextOverflow, shouldCompactBeforeIteration } from './react-loop.js';
@@ -130,6 +149,62 @@ export function writeBackCurrentTurnInto(history, wire) {
         return 0; // 写回失败绝不影响对话本身
     }
 }
+import { LoopStallState, observeToolCall, batchHint } from './tool-loop-guard.js';
+/**
+ * 写操作"读回自证" (2026-10-01 优化 #4): 写类工具成功后**自动**核一次, 把事实拼进结果。
+ * 为什么: 过程纪律写了"读回一次", 但**没人执行** ✗ ⇒ 现在由机制执行: "工具说成功 ≠ 任务成功"。
+ * 只做**便宜**的核对(存在性/大小); 失败静默(核对不该把工具搞失败)。
+ */
+export function verifyWriteOutcome(toolName, args, cwd) {
+    try {
+        const fsMod = require('node:fs');
+        const pathMod = require('node:path');
+        const WRITE = new Set(['write_file', 'edit_file', 'mkdir', 'move_file', 'copy_file']);
+        if (!WRITE.has(String(toolName)))
+            return null;
+        const rel = String(args?.path ?? args?.to ?? args?.dir ?? '').trim();
+        if (!rel)
+            return null;
+        const abs = pathMod.isAbsolute(rel) ? rel : pathMod.resolve(cwd, rel);
+        const st = fsMod.statSync(abs);
+        if (st.isDirectory())
+            return `[已核对] 目录存在: ${rel}`;
+        return `[已核对] 文件已落盘: ${rel} (${st.size} 字节, ${new Date(st.mtimeMs).toISOString()})`;
+    }
+    catch (e) {
+        return `[未核对] 读回失败: ${String(e?.message || e).slice(0, 80)} —— 别急着说"已完成", 先确认路径/权限`;
+    }
+}
+/**
+ * 过程纪律 (2026-10-01, 用户: 「智能体回复方式没有主动性 … 在过程里面更加主动考虑」)。
+ *
+ * 诊断: 系统提示里只有"理解→分析→调用→观察"这种**反应式**循环描述 ⇒ 模型容易"问一句答一句、
+ *   试一次就收尾、把方案当交付"。主动不是靠一句"请主动"能给的, 要落成**可判定的规矩**。
+ * 落地方式 (7 条, 都是"做/不做"能验收的): 先动手别先问 · 做到底别停在半成品 · 一个工具不够就换法继续 ·
+ *   工具说成功 ≠ 任务成功(读回验证) · 被阻塞如实说绝不编 · 每轮要么推进要么交付 · 顺手想影响面并给下一步建议。
+ */
+export const PROACTIVE_WORK_DISCIPLINE = `
+过程纪律 (比"答得漂亮"更重要, 逐条可判定):
+0. **先动手, 别先问**: 请求有显而易见的默认解释时, 按它做, 不要为了确认而停下 —— 只有"不同解释会让我做不同的事"时才问。
+0.5 **别把"主动"用在闲聊上**: 寒暄 / 感受 / 纯闲聊这类**没有任务**的消息 ⇒ 直接回答, **不要**为此调工具
+    (用户实测: 一句「你好」去跑了 git_status 花 4.1s ✗ —— 那是浪费)。"主动"= 接到任务后**想在你前面**,
+    不是"每句话都先把环境查一遍" ✗。
+1. **做到底**: 交付的是**能跑的东西 + 真实的工具输出**, 不是"我打算怎么做"。只写方案、只搭一半、只报告打算做什么, 都算没做完。
+2. **一个工具不够就换法继续**: 同一件事试到确实不通为止 —— 换参数/换命令/换路径/换工具接着试, 不要试一次就收尾。
+3. **工具说成功 ≠ 任务成功**: 写入/生成/发布这类动作, **读回一次**再声称完成(内容/存在/大小/哈希都可)。
+4. **被阻塞就如实说**: 讲清卡在哪一步、为什么、还缺什么; **绝不**用编造的结果顶替(编一个"看起来对"的输出比说"没做成"更糟)。
+5. **每一轮要么用工具推进, 要么给出结论**: 不要把"下一步我打算…"当成回答。
+6. **收尾时说三句**: 改了什么 · 验过什么(拿什么读到的) · 还剩什么。不重述过程。
+7.4 **技能是"要用时先读再照做"**: 库里有一批已装载技能(名字+说明), 用 list_skills <关键词> 找,
+    用 read_skill <名字> 读全文 —— **相关时先读它再动手**, 别凭印象做(技能里往往写着踩过的坑与判据 ✓)。
+7.5 **一轮里可以同时调多个独立工具** (并行执行已支持): 互不依赖的读取/查询**一次发出去**, 别一个一个来回 —
+    零碎调用既慢又费预算(批量工具还会退还额度 ✓)。
+7.6 **收尾标记的语义**(别猜, 就按这条): 写完那个结束标记 = "**我已收尾, 且自己验过**(改了什么/拿什么验证的), 请复核"。
+    只在这两种情况下写: ① 任务真的做完了(不是"我打算做") · ② 纯对话/问答也**不用**写(直接答即可)。
+    没做完就**别写** —— 写了会被当成"已完成"进入复核, 反而浪费一轮 ✓。
+7. **过程中主动考虑**: 动手前先想这个改动的**影响面**(同类调用点 · 相邻功能 · 已有数据/契约), 发现关联问题就说出来,
+   并给出你建议的下一步 —— 主动是指"想在你前面", 不是"多问几句"。
+`;
 export class PiAgentSession {
     cwd;
     peerId;
@@ -142,7 +217,90 @@ export class PiAgentSession {
     sessionManager;
     agentsManager;
     socialHeartbeat = null;
-    messageHistory = [];
+    /**
+     * **K5 第 4 步 (所有权转移)**: history 的**本体**。
+     *   · 未绑定 actor ⇒ 本体在这里 (绑定前的暂存);
+     *   · 绑定 actor 后 ⇒ 本体是 `actor.state.messageHistory`, 本地那份被**收养**并清空。
+     * 绑定由 `attachActor()` 做, 且**只在会话身份已知时**发生 (见 session factory) —— 没有身份就不归属。
+     */
+    /**
+     * **K5 第 4 步 — history 写入的唯一漏斗 (push)**。
+     * 为什么必须同步: 调用点遍布 ReAct 循环 / 工具回灌 / 压缩, 而且**写完立刻读** (length / 索引 / slice),
+     * 改成 await 会改变同拍可见性。所以这里有意识地**不排队** —— 归属收敛 + 可数 (门能断言"零处直写"),
+     * 并发安全由入口投递进 mailbox 负责 (K5 第 5 步)。
+     */
+    pushHistory(...msgs) {
+        for (const m of msgs) {
+            // 步骤⑧ 起**只有一条路径**: 写 actor (实例侧暂存字段已删除) —— 也彻底消除了"自递归"的可能
+            this.actor.appendMessageSync(m);
+        }
+    }
+    /** **K5 第 4 步 — history 写入漏斗 (pop)** —— 同 pushHistory 的性质 */
+    popHistory() {
+        return this.actor.popMessageSync();
+    }
+    /** **K5 第 4 步 — history 写入漏斗 (整体替换)**: hydrate 回灌 / 压缩后的整块赋值都走这里 */
+    /**
+     * **整体替换**历史 —— 唯一漏斗之一, 步骤⑧ 起是**唯一**的"种历史"入口 (公开)。
+     *   公开的理由: 上层/测试要种一份历史时必须走这里; 直接给对象赋一个新数组会**换掉数组身份**
+     *   (actor 里那份仍是空的) —— 那是静默丢数据 (实测: 删掉 setter 后 `session.messageHistory = [...]`
+     *   变成写在一个凭空出现的自有属性上, 测试于是看到 0 条)。
+     */
+    replaceHistory(next) {
+        this.actor.replaceHistory(next);
+    }
+    /**
+     * **K5 步骤⑦ — 把一次性请求里的绑定落到位** (入口不再散着设字段: 只交一个请求)。
+     * 写入都走访问器 ⇒ 本体落进 `actor.state` (步骤③ 起就是这样); 没给的不覆盖 (与环境变量"只覆盖显式给出的"同秩)。
+     */
+    applyExecutionRequest(req) {
+        if (req.channelId)
+            this.actor.state.channelId = req.channelId;
+        if (req.agentId)
+            this.actor.state.agentId = req.agentId;
+        if (req.goalId)
+            this.actor.state.goalBinding = req.goalId;
+        if (req.resumeRunId)
+            this.resumeRunId = req.resumeRunId;
+    }
+    /**
+     * **K5 步骤⑦ — Pi 的唯一执行入口**: 只接收一次性 `ExecutionRequest`。
+     * 有 `onStream` ⇒ 走 `promptStream` (流式); 否则走 `prompt`。绑定由 `applyExecutionRequest` 落位。
+     * 入口侧只需: `deliverThroughActor(session, () => session.runExecution(req))`。
+     */
+    async runExecution(req) {
+        this.applyExecutionRequest(req);
+        if (req.onStream) {
+            return this.promptStream(req.input, req.onStream, req.signal, req.channelId);
+        }
+        return this.prompt(req.input, { signal: req.signal, channelId: req.channelId });
+    }
+    /**
+     * **K5 第 4 步**: 绑定 actor 并**收养**绑定前已存在的本地历史。
+     * 收养规则: actor 侧为空 且 本地非空 ⇒ 搬过去 (任何绑定时序都不丢历史); 收养后清空本地。
+     * 约束 (全量回归打出来的): 调用方必须用**会话身份**当注册键; 没有身份就**不要调**这个方法。
+     */
+    attachActor(actor) {
+        const prev = this.actor;
+        this.actor = actor;
+        if (!prev || prev === actor)
+            return;
+        // **收养**: 把上一个 actor (通常是"出生时的私有 actor") 的状态搬进新家。
+        //   新家已有值时不覆盖 —— 同一会话身份以先到者为准 (禁止"后到的调用把先建的状态冲掉")。
+        const from = prev.state;
+        const to = actor.state;
+        if (from.messageHistory.length > 0 && to.messageHistory.length === 0) {
+            to.messageHistory.push(...from.messageHistory);
+        }
+        if (from.channelId && !to.channelId)
+            to.channelId = from.channelId;
+        if (from.agentId && !to.agentId)
+            to.agentId = from.agentId;
+        if (from.goalBinding && !to.goalBinding)
+            to.goalBinding = from.goalBinding;
+        if (from.activeRun && !to.activeRun)
+            to.activeRun = from.activeRun;
+    }
     tools = new Map();
     /** 2026-06-30: tool registry 模块 — 独立 alias resolve, 测试可消融. */
     _toolRegistry = new ToolRegistry();
@@ -150,7 +308,51 @@ export class PiAgentSession {
     /** M2.4: 缓存 tool 列表, registerTools() 之后不变, runReActLoop 多次循环复用 */
     cachedToolDefinitions = '';
     /** M2.4: 缓存 persona section */
+    /**
+     * 当前活跃计划 (待办) 的**重注入段** (2026-10-01 落实④)。
+     * 每轮都带 —— 因为上下文压缩会把早先注入的计划文本丢掉, 一次性注入等于"压完就忘"。
+     * 有界 (条数/字符都封顶); 读不到就返回空串, 绝不影响主流程。
+     */
+    async renderActivePlansSection() {
+        // 2026-10-01: 后台委派的结果**自动回灌** —— 完成后的第一轮在这里给一行提示(只提一次)
+        let bg = '';
+        try {
+            bg = renderDelegateNotices();
+        }
+        catch { /* 提示失败不打断主流程 */ }
+        try {
+            const block = renderNoticeBlock(); // 通用回流(复盘产出/后台任务) —— 空闲排空 ⇒ 新一轮 ✓
+            if (block)
+                bg = bg ? `${bg}\n${block}` : block;
+        }
+        catch { /* 回流失败不打断 */ }
+        let plans = '';
+        try {
+            const { listActivePlans, formatPlansForPrompt } = await import('./plan-store.js');
+            const list = await listActivePlans();
+            plans = formatPlansForPrompt(list, { maxChars: 1200, maxItems: 3 });
+        }
+        catch {
+            return bg;
+        }
+        return bg ? `${bg}\n${plans}` : plans;
+    }
     cachedPersonaSection = '';
+    /** 本轮迭代预算 (每轮重置; 批处理工具会退还 —— 见 iteration-budget.ts) */
+    /** 上一个工具调用的参数指纹 (遥测判"是否重复调用") */
+    lastToolSig = null;
+    /** 最近一条用户消息 (按需子集档用来判 intent) */
+    lastUserIntent = '';
+    /** 本回合改过的 TS 文件 (回合收尾自动类型检查用) */
+    tsTouchedThisTurn = [];
+    /** 本回合是否已跑过类型检查 (一轮只跑一次) */
+    typecheckRanThisTurn = false;
+    iterBudget = null;
+    iterBudgetWarned = false;
+    /** 上一次已复盘的**任务签名** (签名变了 ⇒ 立刻复盘, 对应"每次任务都总结" ✓) */
+    lastReviewedTaskSig = undefined;
+    /** 上一次回合后自审的时间 (节流; 0 = 从未) */
+    lastExperienceReviewAt = 0;
     /** 2026-06-30: 持久化层 — 默认走 ~/.bolloon/sessions/cache/, 测试可注入临时目录. */
     _sessionStore;
     /** 构造期间 fire-and-forget 任务的 promise — whenReady() 等它 */
@@ -261,11 +463,29 @@ export class PiAgentSession {
     //   拼到 systemPrompt 末尾, 别再混进 user message
     contextHintAddition = '';
     /**
-     * 当前 onStream 引用 + abort signal (computeJudgmentGate 需要 onStream 广播 phase)
-     * 每次 prompt / promptStream / promptWithPivotLoop 入口设置, 用完即清
+     * **K2 收尾 (leo 2026-10-02 口径)**: **唯一一处**把"已有的恢复身份"播种进 RunContext。
+     *
+     *   · `currentRunId` 属 **run-boundary**, 不是循环内部的可变 RunContext 状态 ⇒ 只允许这一次显式播种读取;
+     *   · 冻结 `CURRENT_RUN_ID_SEED_READS = 1` (见 src/kernel/plan-runcontext.ts), 由门强制;
+     *   · 只发生在**进入一次 Run 时**; 不得在循环中新增读取点; 不得成为新的写入口;
+     *   · K5 Channel Actor 完成后改为 `createRunContext({ runId: request.resumeRunId })`, 届时删除 `currentRunId` 字段本体。
+     */
+    seedRunContext(extra = {}) {
+        return createRunContext({ runId: this.actor.state.activeRun, ...extra });
+    }
+    /**
+     * **K5 迁移中**: 本会话所属 channel 的 Actor (由 session factory 在创建时绑定)。
+     * 现在只做**归属** —— 会话状态 (messageHistory / channelId / agentId / goalId) **仍然**在实例字段上,
+     * 逐项迁入 Actor 见 `src/kernel/plan-channel-actor.ts` 的 8 步。
      */
-    currentOnStream = null;
-    currentSignal = null;
+    actor;
+    /**
+     * **K2 迁移中**: 一次 Run 的显式状态载体 (见 src/agents/run-context.ts)。
+     * 入口 (prompt / promptStream / promptWithPivotLoop) 用 createRunContext() 快照一次, 用完即清。
+     * **已外置**: `eventSink` (原 currentOnStream) · `abortSignal` (原 currentSignal)。
+     * 其余 6 个字段仍以本类实例字段为准, 逐格迁移。
+     */
+    runCtx = createRunContext();
     /** Bootstrap SessionStart 拼的 system prompt 片段 (用完即清) */
     bootstrapAddition = '';
     /** 2026-08-12 (Task3 认知卸载): 工具选择与认知卸载指南 — 注入 system prompt, 降低"模型不触发 write/edit/read"率. */
@@ -279,12 +499,17 @@ export class PiAgentSession {
 - 每步只选一个最合适的工具, 先读后写, 写完验证 (跑 tsc/vitest 或读回文件).`;
     /** 当前 prompt 开始时间 (供 Stop hook 计算 durationMs) */
     promptStartTime = 0;
-    /** 当前 channel id (由 getAgentForChannel / prompt 4 参注入, 供 hook / log 使用) */
-    currentChannelId = '';
-    /** 2026-07-04: 当前 agentId (server.ts 通过 createAgentSession 选项注入), 供 onSessionStart 加载 persona docs */
-    currentAgentId = '';
-    /** M2.2 (2026-06-17): 当前轮的用户请求 intent, runReActLoop 拼 systemPrompt 时会读这个 */
-    currentIntent = 'chitchat';
+    /**
+     * **K5 步骤③ (会话绑定迁入 Actor)**: 三处绑定 (channelId / agentId / goalBinding) 的本体住进
+     * `actor.state`, 实例上只留**绑定前的暂存** (`_channelId` 等), 由 `attachActor()` 收养后清空。
+     * 用访问器而不是改调用点: 写入点 (prompt 入口 / Goal 绑定 / snapshot) 分散且语义各异, 逐个改风险大;
+     * 访问器让所有读写自动落到 actor (同一个值对象), 调用点零改动。
+     * 注意: 这三个字段的**访问数不变** (台账按 "self.currentX" 形态计数) —— 迁的是**所有权**, 不是删访问。
+     *   本注释刻意不写出那种带 `this.` 前缀的字面形态: 计数口径只剥 `//` 行注释, 块注释里的同形串会被算进去
+     *   (曾因此把 currentChannelId 的计数虚增 1, 被门照出)。
+     */
+    // **K5 步骤⑧ 批次4**: channelId 的访问器已删 —— 本体 `actor.state.channelId`, 直接影响本体。
+    // M2.2 intent 已外置到 runCtx.intent (K2); 拼 systemPrompt 时读 this.runCtx.intent
     /** 2026-08-10: 本轮用户原始输入 (loop-review 任务动词兜底检测用) */
     currentUserInput = '';
     /**
@@ -292,7 +517,16 @@ export class PiAgentSession {
      * 之前只有"跑完才写"的轨迹 (trajectory-store, fire-and-forget, 崩了就没有), 没有跨重载可见的
      * 运行事实, 也没有预算闸门/失速巡检; 这里补的就是那一层。
      */
-    currentRunId = '';
+    /**
+     * **K5 步骤⑥ (Run 身份归属 Actor)**: 本体是 `actor.state.activeRun`。
+     *   · 未绑定 actor ⇒ 住在这里 (`_runId`, 绑定前的暂存);
+     *   · 绑定后 ⇒ 读写全落 actor (同一个值), 由 `attachActor()` 收养绑定前的值。
+     * 语义: "本会话当前活跃的 Run" —— 一个会话身份同时只有一个活跃 Run ✓ 与 Actor 的粒度一致。
+     * 注意: 访问数**不变** —— 迁的是**所有权**不是删访问 (与步骤③同理)。
+     *   本注释刻意不写出"带 self. 前缀 + 该字段名"的那种字面形态: K2 的计数只剥 `//` 行注释,
+     *   块注释里的同形串会被算进去 (同类踩过三次, 每次都被门照出)。
+     */
+    // **K5 步骤⑧ 批次5 (收尾)**: currentRunId 访问器已删 —— Run 身份的本体是 `actor.state.activeRun`, 直接读写本体。
     /** 上一次运行的 runId (收尾不清空; 见 getLastRunId) */
     lastRunId = '';
     runSurface = 'cli';
@@ -309,14 +543,14 @@ export class PiAgentSession {
     currentIntentHint = '';
     /**
      * 算 judgment 注入门: 失败静默, 不阻塞主对话
-     * 期间通过 currentOnStream 广播 phase 事件, 前端可显示 "正在检索判断力..." 状态
+     * 期间通过 runCtx.eventSink 广播 phase 事件, 前端可显示 "正在检索判断力..." 状态
      * 调用方负责用完即清 (judgmentGateAddition='')
      */
     async computeJudgmentGate(input) {
         const safePhase = (phase, extra = {}) => {
             try {
-                if (this.currentOnStream) {
-                    this.currentOnStream({ type: 'phase', phase, ...extra, content: '' });
+                if (this.runCtx.eventSink) {
+                    this.runCtx.eventSink({ type: 'phase', phase, ...extra, content: '' });
                 }
             }
             catch { /* 静默 */ }
@@ -358,17 +592,51 @@ export class PiAgentSession {
         this.judgmentGateNegativeUsedIds = [];
     }
     constructor(config) {
+        // **K5 步骤⑧**: actor 从出生就在 —— 工厂通常在**构造前**就把身份 actor 注进来 (`config.actor`);
+        //   没有身份时用一份**私有 actor** (不注册 ⇒ 谁也拿不到, 隔离性优先)。
+        //   ⇒ 实例侧不再需要"绑定前暂存"字段 (那些字段本步删除)。
+        this.actor = config.actor ?? createPrivateActor();
         this.cwd = config.cwd;
         this.peerId = config.peerId || 'local';
         this.identity = config.identityDoc || this.createDefaultIdentity();
         this.minimaxAvailable = this.checkMinimax();
         // 2026-07-04: 透传 agentId (server.ts 通过 createAgentSession 选项注入)
-        this.currentAgentId = config.agentId || '';
+        this.actor.state.agentId = config.agentId || '';
+        // 2026-10-01 **身份自愈** (用户实测: get_identity 返回 "DID: " 空 + 各 channel 名字串台):
+        //   工具上下文里的身份来自 this.identity, 而它可能是 config.identityDoc 与 session 实例身份的
+        //   合并结果 —— **空 did 会盖掉真 did** ✗; 名字也可能缺失或被别处覆盖。
+        //   规矩: 缺 did / 名字时, 按 **currentAgentId** 从真身份生成器补齐 (did:key + 落盘密钥),
+        //   名字优先取该 agent 自己的 persona.json。绝不回落到全局/用户身份名。
+        try {
+            if (this.actor.state.agentId) {
+                const cur = this.identity || {};
+                const curDid = String(cur.did || '');
+                const badDid = !curDid || /^did:(local|pi):/i.test(curDid);
+                const missingName = !String(cur.name || '').trim();
+                // 2026-10-01 加固: **did 与本人密钥不符** 也算坏 —— 用户实测 get_identity 返回一个
+                //   数据里根本不存在的 did (按 peerId 当 scope 新造的), 而它非空、非假值 ⇒ 上一版判据漏过 ✗。
+                //   规矩: 只要 currentAgentId 有值, 身份的 did 就必须等于该 agent 自己的密钥 did。
+                const mine = loadOrCreateAgentIdentity(this.actor.state.agentId);
+                const mismatch = !!mine?.did && !!curDid && curDid !== mine.did;
+                if (badDid || missingName || mismatch) {
+                    if (badDid || mismatch) {
+                        console.warn(`[identity] 身份纠正: ${this.actor.state.agentId} 的 did ${curDid ? curDid.slice(0, 26) : '(空)'} ⇒ ${mine.did.slice(0, 26)} (以该 agent 自己的密钥为准)`);
+                    }
+                    // 2026-10-01: 同样必须**原地改** —— 这段在 registerTools() **之后**跑, 工具上下文已经按引用
+                    //   捕获了 this.identity; 换对象 ⇒ 工具看不到纠正结果 ✗ (同类 bug, 一并修)
+                    Object.assign(this.identity, {
+                        ...(mine?.did ? { did: mine.did, publicKey: mine.publicKey || cur.publicKey } : {}),
+                        ...(missingName ? { name: agentPersonaName(this.actor.state.agentId) || this.actor.state.agentId } : {}),
+                    });
+                }
+            }
+        }
+        catch { /* 自愈失败不致命 */ }
         // 2026-06-30: 持久化层可注入 — 测试传 tmpDir, 业务用默认 ~/.bolloon/sessions/cache/
         this._sessionStore = config.sessionStore ?? defaultSessionStore;
         this.constraintLayer = new ConstraintLayer();
         this.workflowEngine = new WorkflowEngine(this.constraintLayer);
-        this.sessionManager = new PiSessionManager(this.identity.did, this.cwd);
+        this.sessionManager = new PiSessionManager(this.identity.did, this.cwd, this.actor.state.agentId);
         this.agentsManager = new DiscoveredAgentsManager();
         this.usePivotLoop = config.usePivotLoop ?? false;
         this.pivotLoopConfig = config.pivotLoopConfig;
@@ -454,6 +722,18 @@ export class PiAgentSession {
      */
     async hydrateMessageHistory(sessionKey, maxMessages) {
         try {
+            // **K5 第 4 步**: 实现体 (load → filter → 截断 → 替换) 已搬进 Actor —— 走邮箱 ⇒ 与 append/persist 串行。
+            //   业务侧只交两个**纯回调** (内核因此不必 import 业务模块); 未绑定 actor 的会话走下面原路径 (行为不变)。
+            if (this.actor) {
+                const n = await this.actor.hydrateHistory({
+                    load: () => this._sessionStore.loadMessages(sessionKey),
+                    filter: (loaded) => this._filterToMessage(loaded),
+                    maxMessages,
+                });
+                if (n > 0)
+                    console.log(`[PiAgent] 从 ${sessionKey} 回灌 ${n} 条历史 (经 Channel Actor)`);
+                return;
+            }
             const loaded = await this._sessionStore.loadMessages(sessionKey);
             if (!loaded) {
                 console.log(`[PiAgent] hydrate: 没有 ${sessionKey} 的历史`);
@@ -461,7 +741,7 @@ export class PiAgentSession {
             }
             const hydrated = this._filterToMessage(loaded).slice(-maxMessages);
             if (hydrated.length > 0) {
-                this.messageHistory = hydrated;
+                this.replaceHistory(hydrated);
                 console.log(`[PiAgent] 从 ${sessionKey} 回灌 ${hydrated.length} 条历史`);
             }
         }
@@ -481,7 +761,10 @@ export class PiAgentSession {
      *   即可获得"重启 / 跨进程接续"的语义.
      */
     async saveCurrentSession(key) {
-        const persisted = this.messageHistory.map((m) => ({
+        // **K5 第 4 步**: 取数拍走 Actor 的快照 (走邮箱 ⇒ 与 append 串行, 不会抓到"边写边读"的半截状态);
+        //   未绑定 actor 的会话走原路径 (行为不变)。
+        const source = this.actor ? await this.actor.historySnapshot() : this.actor.state.messageHistory;
+        const persisted = source.map((m) => ({
             role: m.role,
             content: m.content,
             toolCall: m.toolCall,
@@ -498,9 +781,9 @@ export class PiAgentSession {
      * 与 loadSessionKey (构造时读) 不同: 这个是 session 已建好后再读.
      */
     async resumeSession(key, maxMessages = 30) {
-        const before = this.messageHistory.length;
+        const before = this.actor.state.messageHistory.length;
         await this.hydrateMessageHistory(key, maxMessages);
-        return this.messageHistory.length - before;
+        return this.actor.state.messageHistory.length - before;
     }
     /**
      * 2026-06-30: 读历史不修改 messageHistory.
@@ -606,6 +889,59 @@ export class PiAgentSession {
         this._inboxMessages = [];
         const toolCtx = {
             tools: this.tools,
+            // 2026-10-01 (用户: 「process 也要可以管理群聊和去中心化交流进程」):
+            //   把**常驻的交流类服务**也挂进 process —— 能启停的给启停(社交心跳 ✓), 只能看的如实标"仅状态" ✓(不假装能停 ✗)
+            managedServices: (() => {
+                const ms = managedServices;
+                ms.register({
+                    name: 'social-heartbeat',
+                    description: '社交心跳: 主动发现节点/发起对话/组织群聊的常驻循环(去中心化交流用)',
+                    status: () => (this.socialHeartbeat ? '运行中' : '已停止'),
+                    start: () => this.startSocialHeartbeat(),
+                    stop: () => this.stopSocialHeartbeat(),
+                });
+                ms.register({
+                    name: 'p2p-network',
+                    description: 'P2P 网络: 与其他 bolloon 节点的连接(群聊/消息都走它)',
+                    status: () => { try {
+                        const peers = this.getPeers?.() ?? [];
+                        return `已连接 ${peers.length} 个节点`;
+                    }
+                    catch {
+                        return '状态不可用';
+                    } },
+                });
+                ms.register({
+                    name: 'orbitdb-groups',
+                    description: 'OrbitDB 群聊存储: 本地群列表与消息持久化',
+                    status: () => { try {
+                        const g = this.listGroupsShallow?.();
+                        return g ? `本地群 ${g}` : '已就绪(用 /group 看列表)';
+                    }
+                    catch {
+                        return '状态不可用';
+                    } },
+                });
+                ms.register({
+                    name: 'document-receiver',
+                    description: '文档接收器: 监听并接收其他节点发来的文档分片',
+                    status: () => '监听中(随进程启动)',
+                });
+                return ms;
+            })(),
+            // 2026-10-01: 技能发现(list_skills / read_skill)的实现 —— 技能原先只注册不露面 ✗, 现在模型能自己找
+            listSkills: () => this.skillRegistry.list().map((sk) => ({ name: sk.name, description: String(sk.description || '') })),
+            getSkillBody: async (name) => {
+                const sk = this.skillRegistry.get(name);
+                if (!sk)
+                    return null;
+                try {
+                    return await sk.execute({});
+                }
+                catch {
+                    return null;
+                }
+            },
             cwd: this.cwd,
             identity: this.identity,
             persona: this.persona,
@@ -619,7 +955,7 @@ export class PiAgentSession {
                     const { CHANNELS_PATH } = await import('../web/server-types.js');
                     const { loadChannels } = await import('../web/server-storage.js');
                     const channels = await loadChannels();
-                    const ch = channels.find((c) => c.id === this.currentChannelId);
+                    const ch = channels.find((c) => c.id === this.actor.state.channelId);
                     if (ch && ch.encryptedPrivateKey && ch.encryptedPrivateKeyIv && ch.walletAddress) {
                         return {
                             encryptedPrivateKey: ch.encryptedPrivateKey,
@@ -668,16 +1004,18 @@ export class PiAgentSession {
         // 2026-07-29: 拒绝列表变化时清空缓存, 重新生成
         if (this.cachedToolDefinitions)
             return this.cachedToolDefinitions;
-        const defs = ['可用工具 (name(params) - 简介):'];
         // 2026-07-29: 使用 allowedTools() 过滤掉拒绝列表中的工具
-        for (const tool of this.allowedTools()) {
-            // 2026-06-19: 压缩 tool 定义 — 只显示参数名 (不显示描述, 减少 60% 长度)
-            //   完整 description 在 history 第一轮注入 (getToolDefinitionsFull 调用), 后续轮只看简短
-            //   避免 system prompt 太大导致 minimax 撞 max_tokens 输出空
-            const paramNames = Object.keys(tool.parameters).join(',');
-            defs.push(`- ${tool.name}(${paramNames})`);
-        }
-        this.cachedToolDefinitions = defs.join('\n');
+        const allowed = Array.from(this.allowedTools());
+        const header = '可用工具 (按类分组; name(params) - 简介):';
+        // 2026-06-19: 压缩 tool 定义 — 只显示参数名 (不显示描述, 减少 60% 长度)
+        //   完整 description 在 history 第一轮注入 (getToolDefinitionsFull 调用), 后续轮只看简短
+        //   避免 system prompt 太大导致 minimax 撞 max_tokens 输出空
+        // 2026-10-01 (优化 #2 v2): 按类**分组**列 + 说明"未列出的也能按名字调" ⇒ 治选择过载, 且不丢能力。
+        //   BOLLOON_TOOL_SUBSET=on 时改走"按 intent 只展开相关桶"(仍带 list_tools + 能力提示 ✓)。
+        const subsetOn = String(process.env.BOLLOON_TOOL_SUBSET || '').toLowerCase() === 'on';
+        const intentText = subsetOn ? this.lastUserIntent : '';
+        const rendered = renderToolListWithParams(allowed, intentText, { subset: subsetOn, perBucket: 14 });
+        this.cachedToolDefinitions = `${header}\n${rendered.text}`;
         return this.cachedToolDefinitions;
     }
     async initSession() {
@@ -689,12 +1027,28 @@ export class PiAgentSession {
         }
     }
     createDefaultIdentity() {
-        return {
-            did: `did:pi:${this.peerId.substring(0, 16)}`,
-            name: `Agent-${this.peerId.substring(0, 8)}`,
-            publicKey: this.peerId,
-            createdAt: Date.now()
-        };
+        // 2026-10-01: 原先自造 `did:pi:<peerId>` —— **不是有效 DID** (仓里 server.ts 自己都把 did:pi:
+        //   当"待升级"占位; 用户实测 get_identity 报 did:pi:ch_1785668060213)。
+        //   改用仓里既有的真身份生成器 (agent-identity.loadOrCreateAgentIdentity, 同步, 产 did:key + 落盘密钥)。
+        const scope = this.actor.state.agentId || this.peerId || 'default';
+        try {
+            const real = loadOrCreateAgentIdentity(scope);
+            return {
+                did: real.did,
+                name: `Agent-${this.peerId.substring(0, 8)}`,
+                publicKey: real.publicKey || this.peerId,
+                createdAt: Date.now(),
+            };
+        }
+        catch {
+            // 真身份生成失败时**不编假 DID**: 如实留空, 由 /did 与 get_identity 报"未绑定"
+            return {
+                did: '',
+                name: `Agent-${this.peerId.substring(0, 8)}`,
+                publicKey: this.peerId,
+                createdAt: Date.now(),
+            };
+        }
     }
     checkMinimax() {
         try {
@@ -735,9 +1089,9 @@ export class PiAgentSession {
             const did = await resolveUserDid();
             const model = this.llmConfig?.model || this.model || '';
             return new TrajectoryRecorder({
-                agentId: this.currentAgentId || 'default',
+                agentId: this.actor.state.agentId || 'default',
                 input,
-                channelId: channelId || this.currentChannelId,
+                channelId: channelId || this.actor.state.channelId,
                 did: did || undefined,
                 model: typeof model === 'string' && model ? model : undefined,
             });
@@ -779,8 +1133,8 @@ export class PiAgentSession {
                 if (gate !== 'ready') {
                     const why = `初始化未就绪 (${gate}, 当前阶段 ${state.stage})${state.lastError ? ` — ${state.lastError.message}` : ''}`;
                     const hint = (state.actions && state.actions[0]) || '运行 `bolloon setup` 完成初始化';
-                    this.messageHistory.push({ role: 'user', content: input });
-                    this.messageHistory.push({ role: 'assistant', content: `[初始化未就绪] ${why}\n${hint}` });
+                    this.pushHistory({ role: 'user', content: input });
+                    this.pushHistory({ role: 'assistant', content: `[初始化未就绪] ${why}\n${hint}` });
                     console.warn(`[PiAgent] 拒绝执行: ${why}`);
                     return `[初始化未就绪] ${why}\n${hint}`;
                 }
@@ -788,13 +1142,13 @@ export class PiAgentSession {
             catch { /* 门禁自身异常 → 按"不能判定"处理会阻塞一切; 这里只在能读到状态时才拦 */ }
         }
         this.minimaxAvailable = this.checkMinimax();
-        this.currentChannelId = options?.channelId ?? this.currentChannelId;
+        this.actor.state.channelId = options?.channelId ?? this.actor.state.channelId;
         // 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({
+        this.pushHistory({
             role: 'user',
             content: input
         });
@@ -804,23 +1158,23 @@ export class PiAgentSession {
             //   于是把"什么都没跑"当成一次正常执行 (这正是"agent 跑了但没记录"的老毛病在 fallback 路径的翻版)。
             const response = await this.handleFallback(input);
             try {
-                let boundGoalId = this.currentGoalId;
+                let boundGoalId = this.actor.state.goalBinding;
                 if (!boundGoalId) {
                     const g = await createGoal({
                         objective: this.currentUserInput || input.slice(0, 200),
-                        channelId: this.currentChannelId || undefined,
-                        agentId: this.currentAgentId || undefined,
+                        channelId: this.actor.state.channelId || undefined,
+                        agentId: this.actor.state.agentId || undefined,
                         createdBy: this.runSurface,
                     });
                     boundGoalId = g.goalId;
                 }
-                this.currentGoalId = boundGoalId;
+                this.actor.state.goalBinding = boundGoalId;
                 const rec = await startRun({
                     surface: this.runSurface,
                     goal: this.currentUserInput || input.slice(0, 200),
                     goalId: boundGoalId,
-                    channelId: this.currentChannelId || undefined,
-                    agentId: this.currentAgentId || undefined,
+                    channelId: this.actor.state.channelId || undefined,
+                    agentId: this.actor.state.agentId || undefined,
                     modelConfig: await this.runModelSnapshot(),
                 });
                 this.lastRunId = rec.runId;
@@ -859,25 +1213,27 @@ export class PiAgentSession {
             catch (err) {
                 await recordDegradation({ kind: 'core', op: 'pi-sdk.fallbackRun', runId: this.lastRunId || '', message: String(err?.message || err).slice(0, 160) }).catch(() => { });
             }
-            this.messageHistory.push({ role: 'assistant', content: response });
+            this.pushHistory({ role: 'assistant', content: response });
             this.reportUsageToContextManager();
             this.finishTrajectory(trajRec, response);
             return response;
         }
         // P0 注入门
-        this.currentSignal = options?.signal ?? null;
-        this.currentOnStream = options?.onStream ?? null;
+        // K2: eventSink + abortSignal 已外置, 入口一次建好本轮 Context。
+        //   其余字段**不在这里抄一份** —— 抄写会新增对旧实例字段的读, 违反方向判据
+        //   「新层出现后旧写口调用点数只许不变或减少」。逐字段迁移时再各自搬进来。
+        this.runCtx = this.seedRunContext({ eventSink: options?.onStream ?? null, abortSignal: options?.signal ?? null });
         await this.computeJudgmentGate(input);
         // M2.2 (2026-06-17): intent 分类 — prompt() 路径也跑 (跟 promptStream 对齐)
         try {
             const { classifyIntent, intentHint } = await import('./intent-classifier.js');
-            this.currentIntent = classifyIntent(input);
-            this.currentIntentHint = intentHint(this.currentIntent);
+            this.runCtx.intent = classifyIntent(input);
+            this.currentIntentHint = intentHint(this.runCtx.intent);
             this.currentUserInput = input;
         }
         catch (err) {
             console.warn('[PiAgent] classifyIntent in prompt() failed:', err);
-            this.currentIntent = 'chitchat';
+            this.runCtx.intent = 'chitchat';
             this.currentIntentHint = '';
         }
         // P2: 解析当前 permission mode
@@ -902,14 +1258,113 @@ export class PiAgentSession {
                     recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) => console.warn('[PiAgent] recordJudgmentUsage failed:', err));
                 }
                 this.clearJudgmentGate();
-                this.currentSignal = null;
-                this.currentOnStream = null;
+                this.runCtx = createRunContext(); // K2: 用完即清 (换新 Context, 不继承残留);
                 this.reportUsageToContextManager();
             }
         }
         try {
             // 2026-06-16: runReActLoop 现在返回 { reply, aiFailed, aiFailureReason } — 这里只需 reply 字符串
-            const loopResult = await this.runReActLoop(this.currentOnStream ?? undefined, options?.signal);
+            const loopResult = await this.runReActLoop(this.runCtx.eventSink ?? undefined, options?.signal);
+            // 2026-10-01: **本回合改过 TS ⇒ 收尾自动类型检查** (一轮一次) —— 复用已有的 tsc_check 工具
+            if (decideTypecheck(this.tsTouchedThisTurn, this.typecheckRanThisTurn)) {
+                this.typecheckRanThisTurn = true;
+                try {
+                    const tscTool = this.tools.get('tsc_check');
+                    if (tscTool?.execute) {
+                        const r = await tscTool.execute({});
+                        const line = formatTypecheckResult(r?.success !== false && !/error TS\d+/.test(String(r?.output || '')), String(r?.output || ''));
+                        this.runCtx.eventSink?.({ type: 'status', content: `🔎 ${line}`, tool: 'system' });
+                    }
+                }
+                catch (e) {
+                    this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
+                }
+                this.tsTouchedThisTurn = [];
+            }
+            // 2026-10-01: **回合后自审 (纯旁路)** —— 沉淀可复用经验, 对应"结束后沉淀"那一段。
+            //   纪律: fire-and-forget (不阻塞主回合) · 只写 ~/.bolloon/experience/ (**不碰主对话/prompt 缓存**)
+            //        · 节流 (默认 10 分钟/agent) · 失败只记一行日志, 绝不影响本回合结果。
+            try {
+                const reviewNow = Date.now();
+                const turnSummary = `用户: ${String(this.currentUserInput || '').slice(0, 2000)}\n助手: ${String(loopResult?.reply || '').slice(0, 4000)}`;
+                // 任务签名: 用户这次要的东西 + 用了哪些工具 ⇒ 换任务立刻复盘(同一任务才节流) ✓
+                const taskSig = createHash('sha256')
+                    .update(`${String(this.currentUserInput || '').slice(0, 300)}|${this.totalToolCallsThisTurn || ''}`)
+                    .digest('hex').slice(0, 12);
+                if (shouldReviewTask(reviewNow, this.lastExperienceReviewAt, this.lastReviewedTaskSig, taskSig)) {
+                    this.lastExperienceReviewAt = reviewNow; // 先记账, 免得多路并发各起一次
+                    this.lastReviewedTaskSig = taskSig;
+                    // 2026-10-01 (用户: 「我没有看到执行完命令后 bolloon 知道选中更新 skills，是不是没有触发」):
+                    //   实测**确实没触发** ✓ —— 两个原因: ① 被调方又自己判了一次节流 ⇒ 换任务也被 throttled 掉 ✗;
+                    //   ② 反馈走 `console.warn`(TUI 里被吞 ✗) + `void … .catch(() => {})`(失败无声 ✗)
+                    //   ⇒ 你什么都看不到 ✓。现在: 传 force 尊重调用方的决定 ✓ · 复盘过程/结果/失败**都进对话流** ✓ ·
+                    //   同时落一份 `~/.bolloon/logs/experience-review.log` 供事后核 ✓。
+                    const reviewLog = (m) => {
+                        const line = `[${new Date().toISOString()}] ${m}`;
+                        try {
+                            const p = path.join(os.homedir(), '.bolloon', 'logs', 'experience-review.log');
+                            void fs.mkdir(path.dirname(p), { recursive: true })
+                                .then(() => fs.appendFile(p, line + '\n'))
+                                .catch(() => { });
+                        }
+                        catch { /* 落日志失败不影响主流程 */ }
+                        try {
+                            this.runCtx.eventSink?.({ type: 'status', content: `📚 复盘: ${m}`, tool: 'system' });
+                        }
+                        catch { /* 上屏失败不打断 */ }
+                    };
+                    reviewLog('开始(换了任务 ⇒ 立刻复盘)');
+                    void runExperienceReview({
+                        turnSummary,
+                        force: true,
+                        chat: async (prompt) => {
+                            const r = await getMinimax().chat(prompt);
+                            return typeof r === 'string' ? r : String(r?.content ?? r?.text ?? '');
+                        },
+                        log: reviewLog,
+                        // 2026-10-01: 写了经验之后再找"能沉淀进哪个已有技能"的候选 —— **只记候选, 不自动改技能** ✓
+                        //   (实测: 拿真实教训撞真实 1300 个技能, 最高分只有 2 且 top 命中是瞎的 ✗ ⇒ 不替人决定 ✓)
+                        onLesson: (lesson) => {
+                            try {
+                                // ⓐ 管理: 找"能沉淀进哪个已有技能"的候选(只记, 不自动改 ✗)
+                                const dirs = defaultSkillPaths(os.homedir(), process.cwd());
+                                const decision = decideLessonSink(lesson, skillsFromDirs(dirs));
+                                logLessonSuggestions(lesson, decision);
+                                // ⓐ' 用户要求「**都进去**」⇒ 每条教训都落进技能库: 强命中写那个技能 ✓, 否则写沉淀技能 `lessons-learned` ✓
+                                // 2026-10-01 **写来源隔离**: 复盘/自审产生的写, 打上 review 标记 ✓ ⇒
+                                //   它只许治理**自己造出来**的技能 ✓(用户在 skills 里点名要的归用户 ✓)
+                                runWithWriteOrigin('review', () => routeLessonToSkill(lesson, skillsFromDirs(dirs)));
+                                // 2026-10-01 (用户: 「复盘任务能否触发 loop?」): 教训**回流成下一轮的任务源** ✓ ——
+                                //   只"记下来"等于闭环断在这 ✗; 投进共享队列 ⇒ 空闲时排空 ⇒ 以**新一轮**浮现 ✓(绝不中途插队 ✓)。
+                                try {
+                                    pushNotice('review', `${lesson.title} —— ${String(lesson.body || '').replace(/\s+/g, ' ').slice(0, 120)}`);
+                                }
+                                catch { /* 回流失败不打断 */ }
+                                // ⓑ 接入**判断力系统**: 同一条教训也进 HumanJudgment(带 source/confidence/revisable ⇒ 可被后续演化取代 ✓)
+                                //    这样经验库与判断力库**同一份来源**, 判断力注入(gate)时就能用上 ✓
+                                import('../pi-ecosystem-judgment/human-value-store.js').then((m) => m.storeHumanJudgment({
+                                    decision: lesson.title,
+                                    decision_type: 'modify',
+                                    reasons: [lesson.body],
+                                    values_derived: [],
+                                    context: { domain: lesson.klass || 'general', complexity: 'simple', stakes: 'medium', time_pressure: 'low' },
+                                    outcome: { approved: true },
+                                    metadata: { source: 'trajectory', confidence: 0.7, revisable: true },
+                                })).catch(() => { });
+                            }
+                            catch { /* 这一段整体是锦上添花, 绝不外泄错误 */ }
+                        },
+                    }).then((r) => {
+                        // 结果**如实上屏** ✓: 审没审 / 写没写 / 为什么没写 —— 不再无声 ✓
+                        reviewLog(r?.reviewed
+                            ? (r?.applied ? `已沉淀经验 ✓${r?.file ? ` → ${path.basename(String(r.file))}` : ''}` : `审了但没写: ${r?.reason || '无'}`)
+                            : `没审: ${r?.reason || '无'}`);
+                    }).catch((e) => {
+                        reviewLog(`失败(已如实记录, 不外泄错误): ${String(e?.message || e).slice(0, 160)}`);
+                    });
+                }
+            }
+            catch { /* 挂点自身失败也不影响主流程 */ }
             this.finishTrajectory(trajRec, loopResult.reply, loopResult.aiFailed ? 'error' : 'ok');
             return loopResult.reply;
         }
@@ -921,8 +1376,7 @@ export class PiAgentSession {
                 recordJudgmentUsage(this.judgmentGateNegativeUsedIds, { userInput: input, polarity: 'negative' }).catch((err) => console.warn('[PiAgent] recordJudgmentUsage (negative) failed:', err));
             }
             this.clearJudgmentGate();
-            this.currentSignal = null;
-            this.currentOnStream = null;
+            this.runCtx = createRunContext(); // K2: 用完即清 (换新 Context, 不继承残留);
             this.reportUsageToContextManager();
         }
     }
@@ -930,7 +1384,7 @@ export class PiAgentSession {
         console.log(`[PiAgent.promptStream] ENTRY, channelId=${channelId}, input chars=${input.length}`);
         this.minimaxAvailable = this.checkMinimax();
         console.log(`[PiAgent.promptStream] minimaxAvailable=${this.minimaxAvailable}`);
-        this.currentChannelId = channelId ?? this.currentChannelId;
+        this.actor.state.channelId = channelId ?? this.actor.state.channelId;
         // 2026-08-08: 运行轨迹采集 (落盘 + OrbitDB, 失败静默) — 包裹 onStream 收集步骤事件
         const trajRec = await this.createTrajectoryRecorder(input, channelId);
         if (trajRec)
@@ -943,7 +1397,7 @@ export class PiAgentSession {
         const userText = markerMatch ? markerMatch[1].trim() : input;
         const contextHint = markerMatch ? input.replace(markerMatch[0], '').trim() : '';
         console.log(`[PiAgent.promptStream] marker matched=${!!markerMatch}, userText chars=${userText.length}, contextHint chars=${contextHint.length}`);
-        this.messageHistory.push({
+        this.pushHistory({
             role: 'user',
             content: userText
         });
@@ -953,7 +1407,7 @@ export class PiAgentSession {
         //   让 agent 能"回忆起"之前 session 的记忆 (自动获取之前 session), 而非只靠启动时批量压缩.
         try {
             const { recallMemory } = await import('./memory-recall.js');
-            const recalled = await recallMemory({ query: userText, agentId: this.currentAgentId || this.peerId || '' });
+            const recalled = await recallMemory({ query: userText, agentId: this.actor.state.agentId || this.peerId || '' });
             if (recalled) {
                 this.contextHintAddition = [this.contextHintAddition, recalled].filter(Boolean).join('\n\n');
             }
@@ -962,29 +1416,29 @@ export class PiAgentSession {
         onStream({ type: 'thinking', content: '🤔 开始思考...' });
         if (!this.minimaxAvailable) {
             const response = await this.handleFallback(userText);
-            this.messageHistory.push({ role: 'assistant', content: response });
+            this.pushHistory({ role: 'assistant', content: response });
             onStream({ type: 'done', content: '' });
             this.reportUsageToContextManager();
             this.finishTrajectory(trajRec, response);
             return response;
         }
-        // P0 注入门: 缓存 onStream + signal, computeJudgmentGate 用 currentOnStream 广播 phase
-        this.currentOnStream = onStream;
-        this.currentSignal = signal ?? null;
+        // P0 注入门: 缓存 onStream + signal, computeJudgmentGate 用 runCtx.eventSink 广播 phase
+        // K2: eventSink + abortSignal 一起建进本轮 Context (只搬已外置的字段, 不抄未迁移的)
+        this.runCtx = this.seedRunContext({ eventSink: onStream, abortSignal: signal ?? null });
         await this.computeJudgmentGate(userText);
         // M2.2 (2026-06-17): intent 分类 — 0 LLM 成本, 5 行 keyword 匹配
         try {
             const { classifyIntent, intentHint } = await import('./intent-classifier.js');
-            this.currentIntent = classifyIntent(userText);
-            this.currentIntentHint = intentHint(this.currentIntent);
+            this.runCtx.intent = classifyIntent(userText);
+            this.currentIntentHint = intentHint(this.runCtx.intent);
             this.currentUserInput = userText;
-            if (this.currentIntent !== 'chitchat') {
-                onStream({ type: 'phase', phase: 'intent_classified', detail: this.currentIntent, content: '' });
+            if (this.runCtx.intent !== 'chitchat') {
+                onStream({ type: 'phase', phase: 'intent_classified', detail: this.runCtx.intent, content: '' });
             }
         }
         catch (err) {
             console.warn('[PiAgent] classifyIntent failed (non-fatal):', err);
-            this.currentIntent = 'chitchat';
+            this.runCtx.intent = 'chitchat';
             this.currentIntentHint = '';
         }
         // P1.1: 异步跑 Auto-Compact (LLM 摘要, 仅在 budget 超限时触发, 失败静默)
@@ -1001,8 +1455,8 @@ export class PiAgentSession {
         let bootstrapAddition = '';
         try {
             const ss = await onSessionStart({
-                channelId: this.currentChannelId || undefined,
-                agentId: this.currentAgentId || undefined,
+                channelId: this.actor.state.channelId || undefined,
+                agentId: this.actor.state.agentId || undefined,
             });
             bootstrapAddition = ss.systemAddition || '';
         }
@@ -1011,10 +1465,10 @@ export class PiAgentSession {
         }
         // 2026-07-07 P1-B: 注入最近 5 条项目事件日志 (L2) — 让 LLM 知道项目状态/feature 变化
         // 失败静默, append 到 bootstrapAddition 末尾 (超 800 字截断)
-        if (this.currentChannelId) {
+        if (this.actor.state.channelId) {
             try {
                 const { getRecentEvents } = await import('../bootstrap/event-log.js');
-                const events = await getRecentEvents(this.currentChannelId, 5);
+                const events = await getRecentEvents(this.actor.state.channelId, 5);
                 if (events.length > 0) {
                     const eventBlock = [
                         '## 最近项目事件 (最近 5 条, 倒序)',
@@ -1029,7 +1483,7 @@ export class PiAgentSession {
             // 2026-07-07 P2-C: 注入项目当前状态 (L3) — 目标/约束/待办/已完成
             try {
                 const { readState, formatStateForPrompt } = await import('../bootstrap/project-state.js');
-                const state = await readState({ channelId: this.currentChannelId });
+                const state = await readState({ channelId: this.actor.state.channelId });
                 const stateText = formatStateForPrompt(state);
                 if (stateText) {
                     bootstrapAddition = (bootstrapAddition + '\n\n' + stateText).slice(-2500);
@@ -1041,7 +1495,7 @@ export class PiAgentSession {
             // 2026-07-07 P2-C: 向量检索 top-3 (L4) — 按当前 channelId + userText 找历史相关片段
             try {
                 const { searchIndex } = await import('../bootstrap/vector-index.js');
-                const indexName = `channel-${this.currentChannelId}`;
+                const indexName = `channel-${this.actor.state.channelId}`;
                 const results = await searchIndex({
                     indexName,
                     query: userText,
@@ -1102,13 +1556,12 @@ export class PiAgentSession {
                 monitorAfterReply(userText, pivotResult);
                 const stopStartTime = this.promptStartTime || Date.now();
                 onStop({
-                    channelId: this.currentChannelId || 'unknown',
+                    channelId: this.actor.state.channelId || 'unknown',
                     durationMs: Date.now() - stopStartTime,
                     usedJudgmentIds: [...this.judgmentGateUsedIds],
                 }).catch((err) => console.warn('[PiAgent] onStop failed:', err));
                 this.clearJudgmentGate();
-                this.currentOnStream = null;
-                this.currentSignal = null;
+                this.runCtx = createRunContext(); // K2: 用完即清 (换新 Context, 不继承残留);
                 this.bootstrapAddition = '';
                 this.contextHintAddition = '';
                 this.promptStartTime = 0;
@@ -1138,8 +1591,7 @@ export class PiAgentSession {
             }
             catch (err) {
                 // abort 失败: 视作"已中断", 抛错让上层用 partial 兜底
-                this.currentOnStream = null;
-                this.currentSignal = null;
+                this.runCtx = createRunContext(); // K2: 用完即清 (换新 Context, 不继承残留);
                 throw err;
             }
             attempt++;
@@ -1177,8 +1629,8 @@ export class PiAgentSession {
             // 因为 messageHistory.push({role:'user'}) 在 promptStream 顶部已经做过, 重跑 runReActLoop 不会重复 push,
             // 但 assistant 失败那条也别留 (留了会污染下一轮 LLM context).
             // 简化: 重试前 pop 一次 assistant (如果最后一条是 assistant)
-            if (this.messageHistory.length > 0 && this.messageHistory[this.messageHistory.length - 1].role === 'assistant') {
-                this.messageHistory.pop();
+            if (this.actor.state.messageHistory.length > 0 && this.actor.state.messageHistory[this.actor.state.messageHistory.length - 1].role === 'assistant') {
+                this.popHistory();
             }
         }
         onStream({ type: 'done', content: '' });
@@ -1196,15 +1648,14 @@ export class PiAgentSession {
         // Bootstrap Stop hook: fire-and-forget 写本次 session 摘要
         const stopStartTime = this.promptStartTime || Date.now();
         onStop({
-            channelId: this.currentChannelId || 'unknown',
+            channelId: this.actor.state.channelId || 'unknown',
             durationMs: Date.now() - stopStartTime,
             usedJudgmentIds: [...this.judgmentGateUsedIds],
         }).catch((err) => console.warn('[PiAgent] onStop failed:', err));
         // 用完即清, 避免污染下一轮
         this.clearJudgmentGate();
-        this.currentOnStream = null;
+        this.runCtx = createRunContext(); // K2: 用完即清 (换新 Context, 不继承残留);
         this.reportUsageToContextManager();
-        this.currentSignal = null;
         this.bootstrapAddition = '';
         this.promptStartTime = 0;
         // 2026-08-08: 轨迹收尾 — 落盘 + OrbitDB (失败静默, 不阻塞回复)
@@ -1212,7 +1663,7 @@ export class PiAgentSession {
         return result;
     }
     async promptWithPivotLoop(input, config, channelId) {
-        this.currentChannelId = channelId ?? this.currentChannelId;
+        this.actor.state.channelId = channelId ?? this.actor.state.channelId;
         if (!this.minimaxAvailable) {
             const response = await this.handleFallback(input);
             return {
@@ -1244,8 +1695,8 @@ export class PiAgentSession {
         // M2.2 (2026-06-17): intent 分类 — pivot loop 也要拿到 hint
         try {
             const { classifyIntent, intentHint } = await import('./intent-classifier.js');
-            this.currentIntent = classifyIntent(input);
-            this.currentIntentHint = intentHint(this.currentIntent);
+            this.runCtx.intent = classifyIntent(input);
+            this.currentIntentHint = intentHint(this.runCtx.intent);
             this.currentUserInput = input;
         }
         catch (err) {
@@ -1268,6 +1719,10 @@ ${this.getToolDefinitions()}
 
 ${PiAgentSession.TOOL_SELECTION_GUIDE}
 
+${PROACTIVE_WORK_DISCIPLINE}
+
+${await this.renderActivePlansSection()}
+
 工作模式:
 1. 理解用户自然语言请求
 2. 分析需要哪些工具来完成
@@ -1288,21 +1743,21 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
 - 工具调用前可以简短思考 (1-2 句话), 但**不要写长篇 thinking** (会撞 max_tokens)
 - 工具调用后必须等结果, 不要在同一个回复里继续输出
 - <final gen> 只在**真完成所有任务**时输出, 不要在工具调用前/中输出${this.judgmentGateAddition}${this.contextHintAddition}`;
-        // 2026-06-15: 把 currentOnStream 传给 loop, 让 step-timeline 在 pivot 循环里也能 emit step_start/done
+        // 2026-06-15: 把 runCtx.eventSink 传给 loop, 让 step-timeline 在 pivot 循环里也能 emit step_start/done
         //   之前 loop.execute() 不接 streamCallback, 导致 step-timeline 只能看到老 runReActLoop 路径
         //   promptWithPivotLoop 路径 0 step events — UI 显示 timeline 但永远是空
         // 2026-06-17: 透传 signal 让 abort 工作 — loop.execute() 当前不接 signal 参数,
         //   所以 abort 行为通过 this.currentSignal 共享给 loop 内部读 (后续 M3.2 接 task plan 时一起加)
         // 2026-07-06: pivot 内 token 累计到 ~70% 时回调 (workflow-pivot-loop.ts line 270+).
-        //   pivot 的 messageHistory 是 process-local, 不和 pi-sdk 的 this.messageHistory 同步.
+        //   pivot 的 messageHistory 是 process-local, 不和 pi-sdk 的 actor 的 messageHistory 同步.
         //   真正折叠需要把 pi-sdk 历史灌回 pivot 的 history 数组 — 侵入较大.
         //   当前 priority: 临时传空实现, 让 budget 公式放够 (workflow-pivot-loop.ts line 220)
         //   不再撞预算. 这条路径留作技术债.
         // 2026-07-17 Bug 1 修: 注入 messageHistory (hydrateMessageHistory 从 session JSON 回灌的) 到 system prompt
-        //   pivot loop execute() 内部自己维护 messageHistory, 跟 pi-sdk 的 this.messageHistory 隔离,
+        //   pivot loop execute() 内部自己维护 messageHistory, 跟 pi-sdk 的 actor 的 messageHistory 隔离,
         //   不注入的话 LLM 看不到历史对话, 每次都是新对话.
         const historyLines = [];
-        const historyToInject = this.messageHistory.slice(-20, -1);
+        const historyToInject = this.actor.state.messageHistory.slice(-20, -1);
         for (const m of historyToInject) {
             const roleLabel = m.role === 'user' ? '用户' : m.role === 'assistant' ? '你' : m.role === 'tool' ? '工具结果' : m.role;
             const text = (m.content || '').slice(0, 2000);
@@ -1315,9 +1770,9 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         const onCompact = async () => {
             // no-op (best-effort hook for future pi-sdk/pivot history sync)
         };
-        const result = await loop.execute(input, llm, systemPrompt + historyBlock, this.currentOnStream ?? undefined, this.currentSignal ?? undefined, onCompact);
+        const result = await loop.execute(input, llm, systemPrompt + historyBlock, this.runCtx.eventSink ?? undefined, this.runCtx.abortSignal ?? undefined, onCompact);
         if (result.response) {
-            this.messageHistory.push({ role: 'assistant', content: result.response });
+            this.pushHistory({ role: 'assistant', content: result.response });
         }
         // 回溯 + 清场
         if (this.judgmentGateUsedIds.length > 0) {
@@ -1333,7 +1788,9 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
      */
     _harness = null;
     /** M2 绑定 GoalStore 后填真值; 在此之前为空 (事件里 goalId 字段已就位) */
-    currentGoalId = '';
+    // **K5 步骤③/⑧**: 会话的 Goal 默认绑定本体在 `actor.state.goalBinding` (访问器已删, 直接读本体)。
+    //   leo 口径不变: 这只是默认值; 每次执行开始必须把最终绑定写进 RunContext/Run 记录,
+    //   运行中重绑必须走显式 Goal Binding 操作, 不许靠裸字段隐式生效。
     /** 2026-09-16 (M2): 本次执行是"从 checkpoint 恢复"的 runId (非空 = 恢复模式, 不再新建 run) */
     resumeRunId = '';
     resumePlan = null;
@@ -1356,7 +1813,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
     }
     /** CLI / Web 注入"当前目标" (有 goalId 就在该 Goal 下执行) */
     setGoalId(goalId) {
-        this.currentGoalId = String(goalId || '');
+        this.actor.state.goalBinding = String(goalId || '');
     }
     /** 核心状态迁移的兜底: 失败 → 记降级 + 交给循环顶部的持久化硬闸 (不吞错) */
     async safeSetRunStatus(runId, to) {
@@ -1375,13 +1832,13 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
      * 这是"错误恢复闭环"的运行时接线点 (此前 recordRecovery / repeatedFailureCount 只是数据结构)。
      */
     async wireToolFailure(tool, errorText, args) {
-        if (!this.currentRunId)
+        if (!this.actor.state.activeRun)
             return;
         const cls = classifyRunError(errorText);
         const digest = argsDigestOf(args);
         let repeats = 1;
         try {
-            const rec = await readRun(this.currentRunId);
+            const rec = await readRun(this.actor.state.activeRun);
             // recordStep 已经把**这次**失败记进去了, 所以"连续失败次数"直接就是当前值 (不再 +1)
             const seen = rec ? repeatedFailureCount(rec, tool, digest) : 0;
             repeats = Math.max(seen, 1);
@@ -1392,7 +1849,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 : cls === 'external_no_reply' ? 'pause'
                     : 'retry';
         try {
-            await recordRecovery(this.currentRunId, {
+            await recordRecovery(this.actor.state.activeRun, {
                 errorClass: cls,
                 message: `${tool}: ${errorText}`.slice(0, 200),
                 action,
@@ -1401,20 +1858,20 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             });
         }
         catch (err) {
-            await recordDegradation({ kind: 'core', op: 'pi-sdk.recordRecovery', runId: this.currentRunId, message: String(err?.message || err) }).catch(() => { });
+            await recordDegradation({ kind: 'core', op: 'pi-sdk.recordRecovery', runId: this.actor.state.activeRun, message: String(err?.message || err) }).catch(() => { });
         }
         // 外部无响应 → awaiting_external (不算失败; 等回话后回到 running)
         if (cls === 'external_no_reply') {
             this.awaitingExternal = true;
-            await this.safeSetRunStatus(this.currentRunId, 'awaiting_external');
+            await this.safeSetRunStatus(this.actor.state.activeRun, 'awaiting_external');
             // 2026-09-16 (2-C.4): 把"在等什么"写成持久化事实 (来源/关联/过期), 否则真实回包到了也不知道该唤醒谁。
             try {
-                if (this.currentGoalId) {
+                if (this.actor.state.goalBinding) {
                     const { bindExternalWait, newContinuationId, defaultWaitExpiry } = await import('./external-events.js');
                     const isDelegate = /delegate/i.test(String(tool || ''));
-                    await bindExternalWait(this.currentGoalId, {
-                        requestId: this.pendingExternalRequestId || `${this.currentRunId}:${Date.now().toString(36)}`,
-                        continuationId: newContinuationId(this.currentGoalId),
+                    await bindExternalWait(this.actor.state.goalBinding, {
+                        requestId: this.pendingExternalRequestId || `${this.actor.state.activeRun}:${Date.now().toString(36)}`,
+                        continuationId: newContinuationId(this.actor.state.goalBinding),
                         expectedSource: isDelegate ? 'delegate' : 'p2p',
                         expectedEvent: 'result',
                         createdAt: new Date().toISOString(),
@@ -1424,31 +1881,31 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 }
             }
             catch (e) {
-                await recordDegradation({ kind: 'core', op: 'pi-sdk.bindExternalWait', runId: this.currentRunId, message: String(e?.message || e) }).catch(() => { });
+                await recordDegradation({ kind: 'core', op: 'pi-sdk.bindExternalWait', runId: this.actor.state.activeRun, message: String(e?.message || e) }).catch(() => { });
             }
             return;
         }
         // 鉴权类: 不重试, 直接交人
         if (cls === 'auth') {
             this.breakerReason = `鉴权类错误不重试 (${tool}): ${errorText.slice(0, 120)}`;
-            await this.safeSetRunStatus(this.currentRunId, 'needs_human');
+            await this.safeSetRunStatus(this.actor.state.activeRun, 'needs_human');
             return;
         }
         // 重复失败熔断: 同一工具 + 同一组参数连续失败达 3 次
         if (repeats >= MAX_SAME_TOOL_FAILURES) {
             this.breakerReason = `同一工具 ${tool} 连续失败 ${repeats} 次 (${cls}) → 熔断, 不再重试`;
-            await this.safeSetRunStatus(this.currentRunId, 'needs_human');
+            await this.safeSetRunStatus(this.actor.state.activeRun, 'needs_human');
         }
     }
     getRunId() {
-        return this.currentRunId;
+        return this.actor.state.activeRun;
     }
     /**
      * 2026-09-16 (M2-B): **上一次**运行的 runId —— prompt 收尾时 `currentRunId` 会被清空,
      * 而 Supervisor / 控制面要在运行结束后才知道"刚才跑的是哪条 run" (否则会拿旧 run 做决策)。
      */
     getLastRunId() {
-        return this.lastRunId || this.currentRunId;
+        return this.lastRunId || this.actor.state.activeRun;
     }
     /**
      * 2026-09-16 (M2): 从 checkpoint 恢复一次运行 —— **不是**重发原 prompt。
@@ -1495,7 +1952,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         }
         this.resumeRunId = runId;
         this.resumePlan = prep.plan;
-        this.currentGoalId = prep.plan.goalId || this.currentGoalId;
+        this.actor.state.goalBinding = prep.plan.goalId || this.actor.state.goalBinding;
         try {
             const reply = await this.prompt(buildResumeInstruction(prep.plan), {});
             return { ok: true, reply, ...(modelDrift ? { modelDrift } : {}), ...(modelApplied ? { modelApplied } : {}) };
@@ -1514,8 +1971,8 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 // pre-tool-validator 4 步链 (modeGate/blacklist/shell-guard/schema), 经 human-value-pipeline 包装
                 preToolUse: async (o) => onPreToolUse({ tool: o.tool, args: o.args, permissionMode: o.permissionMode }),
                 // 事件写 Run: 观测级 (记账失败不改变已做出的决策)
-                events: (e) => { if (this.currentRunId)
-                    void recordHarnessEvent(this.currentRunId, e); },
+                events: (e) => { if (this.actor.state.activeRun)
+                    void recordHarnessEvent(this.actor.state.activeRun, e); },
             });
         }
         return this._harness;
@@ -1523,10 +1980,10 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
     /** 每个生命周期事件都带上的运行身份 (runId / goalId / agentId / channelId / surface) */
     harnessCtx() {
         return {
-            runId: this.currentRunId || undefined,
-            goalId: this.currentGoalId || undefined,
-            agentId: this.currentAgentId || undefined,
-            channelId: this.currentChannelId || undefined,
+            runId: this.actor.state.activeRun || undefined,
+            goalId: this.actor.state.goalBinding || undefined,
+            agentId: this.actor.state.agentId || undefined,
+            channelId: this.actor.state.channelId || undefined,
             surface: this.runSurface,
         };
     }
@@ -1552,6 +2009,9 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         const MAX_TOOL_CALLS_PER_LOOP = 25; // 单轮循环总工具调用上限 → 注入 hint
         let totalToolCallsThisLoop = 0;
         const lastNTools = []; // 最近 MAX_IDEMPOTENT_TOOL 次工具名, 检测重复
+        // 2026-10-01: 工具停滞观测状态 (分类 + 温和引导 + 重复结果引用) —— 见 agents/tool-loop-guard.ts
+        //   与上面的"同工具 5 次就提示"不同: 它按 (工具名 + 参数 + 结果) 签名判定, 并抓 A→B→A→B 的循环
+        const stallState = new LoopStallState();
         // 2026-08-10: unreported 循环逃生门 — LLM 反复不把工具结果写进回复时, 3 次后强制 final (不死板)
         const MAX_UNREPORTED_RETRIES = 3;
         let unreportedRetries = 0;
@@ -1590,26 +2050,26 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         this.awaitingExternal = false;
         if (this.resumeRunId) {
             // ── 恢复模式: 复用原来的 runId, 不新建 run (历史保留) ──
-            this.currentRunId = this.resumeRunId;
+            this.actor.state.activeRun = this.resumeRunId;
             this.lastRunId = this.resumeRunId;
             try {
-                await markRunRunning(this.currentRunId);
+                await markRunRunning(this.actor.state.activeRun);
             }
             catch (err) {
                 runPersistenceFailure = `恢复时状态迁移失败 (recovering → running): ${String(err?.message || err).slice(0, 180)}`;
             }
             const doneN = this.resumePlan?.completedSteps.length ?? 0;
             const guards = this.resumePlan?.replayGuards.length ?? 0;
-            onStream?.({ type: 'status', internal: true, content: `♻️ 从 checkpoint 恢复运行 ${this.currentRunId} (已完成 ${doneN} 步, 非幂等重放守卫 ${guards} 条)`, tool: 'harness' });
+            onStream?.({ type: 'status', internal: true, content: `♻️ 从 checkpoint 恢复运行 ${this.actor.state.activeRun} (已完成 ${doneN} 步, 非幂等重放守卫 ${guards} 条)`, tool: 'harness' });
         }
         else {
             // 2026-09-16 (M2): 目标绑定 —— 有 goalId 就在该 Goal 下执行; 没有就建 Goal 再建 Run。
             //   延续规则 (确定性, 不靠猜): 该 channel/agent 上已有 open/active Goal, 且它的上一次执行**没收尾**
             //   (interrupted/stalled/needs_human/paused/awaiting_external/recovering) → 继续该 Goal; 否则新建。
-            let boundGoalId = this.currentGoalId;
+            let boundGoalId = this.actor.state.goalBinding;
             if (!boundGoalId) {
                 try {
-                    const active = await findActiveGoal({ channelId: this.currentChannelId || undefined, agentId: this.currentAgentId || undefined });
+                    const active = await findActiveGoal({ channelId: this.actor.state.channelId || undefined, agentId: this.actor.state.agentId || undefined });
                     if (active?.currentRunId) {
                         const prev = await readRun(active.currentRunId);
                         const unfinished = prev && ['interrupted', 'stalled', 'needs_human', 'paused', 'awaiting_external', 'recovering'].includes(prev.status);
@@ -1624,8 +2084,8 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     try {
                         const g = await createGoal({
                             objective: this.currentUserInput || '(未记录目标)',
-                            channelId: this.currentChannelId || undefined,
-                            agentId: this.currentAgentId || undefined,
+                            channelId: this.actor.state.channelId || undefined,
+                            agentId: this.actor.state.agentId || undefined,
                             createdBy: this.runSurface,
                         });
                         boundGoalId = g.goalId;
@@ -1634,25 +2094,25 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         console.warn('[PiAgent] 创建 Goal 失败 (无目标也要有运行记录):', err?.message);
                     }
                 }
-                this.currentGoalId = boundGoalId;
+                this.actor.state.goalBinding = boundGoalId;
             }
             try {
                 const rec = await startRun({
                     surface: this.runSurface,
                     goal: this.currentUserInput || '(未记录目标)',
                     goalId: boundGoalId || undefined,
-                    channelId: this.currentChannelId || undefined,
-                    agentId: this.currentAgentId || undefined,
+                    channelId: this.actor.state.channelId || undefined,
+                    agentId: this.actor.state.agentId || undefined,
                     modelConfig: await this.runModelSnapshot(),
                 });
-                this.currentRunId = rec.runId;
+                this.actor.state.activeRun = rec.runId;
                 this.lastRunId = rec.runId;
-                this.currentGoalId = rec.goalId || this.currentGoalId;
-                if (this.currentGoalId) {
+                this.actor.state.goalBinding = rec.goalId || this.actor.state.goalBinding;
+                if (this.actor.state.goalBinding) {
                     // Run → Goal 反查链: runId → goalId → objective / success criteria
-                    await attachRun(this.currentGoalId, rec.runId).catch((err) => console.warn('[PiAgent] attachRun 失败:', err?.message));
+                    await attachRun(this.actor.state.goalBinding, rec.runId).catch((err) => console.warn('[PiAgent] attachRun 失败:', err?.message));
                 }
-                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' });
+                onStream?.({ type: 'status', internal: true, content: `🧷 运行已登记 (run=${rec.runId}${this.actor.state.goalBinding ? `, goal=${this.actor.state.goalBinding}` : ''}, 预算 ${rec.budget.maxSteps} 步 / ${Math.round(rec.budget.deadlineMs / 60000)} 分钟)`, tool: 'harness' });
             }
             catch (err) {
                 // 核心写失败: 不再 warn 后继续 —— 没有运行记录就不执行 (strict 模式默认如此)
@@ -1682,18 +2142,18 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 break;
             }
             // 2026-09-16: 预算闸门 (持久化 harness 的约束面) —— 到点必须**如实**终止, 不许静默算完成
-            if (this.currentRunId) {
+            if (this.actor.state.activeRun) {
                 try {
-                    const rec = await readRun(this.currentRunId);
+                    const rec = await readRun(this.actor.state.activeRun);
                     if (!rec)
-                        throw new Error(`运行记录读不到: ${this.currentRunId}`);
+                        throw new Error(`运行记录读不到: ${this.actor.state.activeRun}`);
                     // 2026-09-16 (M5): 外部控制面 (CLI /pause /abort, Web API) 改过状态 → 如实停在那儿。
                     //   不覆盖成 done/failed: 人按下暂停就是暂停, 人按下中止就是中止。
                     if (rec.status === 'paused' || rec.status === 'aborted') {
                         runExternallyPaused = rec.status === 'paused';
                         runExternallyAborted = rec.status === 'aborted';
                         runStopReason = `外部请求: ${rec.status}`;
-                        onStream?.({ type: 'error', content: `⏹️ 运行被外部${rec.status === 'paused' ? '暂停' : '中止'} (run=${this.currentRunId})`, tool: 'harness' });
+                        onStream?.({ type: 'error', content: `⏹️ 运行被外部${rec.status === 'paused' ? '暂停' : '中止'} (run=${this.actor.state.activeRun})`, tool: 'harness' });
                         finalResponse = finalResponse || `(运行已${rec.status === 'paused' ? '暂停' : '中止'})`;
                         break;
                     }
@@ -1716,7 +2176,18 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             }
             // 停止条件 1: max turns (fail-safe 10000, 正常任务永远跑不到)
             //   2026-07-01 (v0.2.4 子任务 1): 委托给 react-loop.decideMaxIterations 纯函数
-            const maxIterDecision = decideMaxIterations(iteration, this.MAX_REACT_ITERATIONS);
+            // 2026-10-01 (落实②: 可退还的迭代预算): 惩罚零碎调用, **奖励批处理** ——
+            //   程序化工具(execute_code, 一次能顶多次)调用后归还一次迭代 ⇒ 有效寿命被延长。
+            //   退出条件仍由 decideMaxIterations 决定(读**净**用量), 不做硬刹车。
+            if (iteration === 0 || !this.iterBudget)
+                this.iterBudget = new IterationBudget(this.MAX_REACT_ITERATIONS);
+            const iterBudget = this.iterBudget;
+            iterBudget.consume();
+            if (iterBudget.warn(0.8) && !this.iterBudgetWarned) {
+                this.iterBudgetWarned = true;
+                onStream?.({ type: 'status', internal: true, content: `⏳ 迭代预算已用 ${iterBudget.describe()} (批量工具会退还)` });
+            }
+            const maxIterDecision = decideMaxIterations(iterBudget.used, iterBudget.maxTotal);
             if (maxIterDecision.shouldExit) {
                 console.warn(`[PiAgent] 达到最大循环数 ${this.MAX_REACT_ITERATIONS}, 强制终止 (fail-safe)`);
                 onStream?.({ type: 'error', content: `⏹️ 达到最大循环数 (${this.MAX_REACT_ITERATIONS}, fail-safe)`, tool: 'loop' });
@@ -1734,14 +2205,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             if (totalToolCallsThisLoop >= MAX_TOOL_CALLS_PER_LOOP) {
                 console.warn(`[PiAgent] 单轮工具调用已达 ${MAX_TOOL_CALLS_PER_LOOP}, 注入 hint 让 LLM 总结`);
                 onStream?.({ type: 'error', content: `⏹️ 工具调用已达上限 (${MAX_TOOL_CALLS_PER_LOOP}), 请基于已有结果回答`, tool: 'loop' });
-                this.messageHistory.push({ role: 'system', content: `[注意] 你已连续调用 ${MAX_TOOL_CALLS_PER_LOOP} 次工具。请基于已有结果直接回答用户, 不要再次调用任何工具。在回答末尾加 <final gen> 标记结束。` });
+                this.pushHistory({ role: 'system', content: `[注意] 你已连续调用 ${MAX_TOOL_CALLS_PER_LOOP} 次工具。请基于已有结果直接回答用户, 不要再次调用任何工具。在回答末尾加 <final gen> 标记结束。` });
                 totalToolCallsThisLoop = 0; // 重置计数器, 只防连续死循环
             }
             if (lastNTools.length >= MAX_IDEMPOTENT_TOOL && new Set(lastNTools).size === 1) {
                 const repeatedTool = lastNTools[0];
                 console.warn(`[PiAgent] 同工具 ${repeatedTool} 连续成功调 ${MAX_IDEMPOTENT_TOOL} 次, 注入 hint 让 LLM 总结`);
                 onStream?.({ type: 'error', content: `⏹️ 工具 ${repeatedTool} 重复调用 ${MAX_IDEMPOTENT_TOOL} 次, 请基于已有结果回答`, tool: 'loop' });
-                this.messageHistory.push({ role: 'system', content: `[注意] 你已连续 ${MAX_IDEMPOTENT_TOOL} 次调用 ${repeatedTool}。请基于已有结果直接回答用户, 不要再次调用任何工具。在回答末尾加 <final gen> 标记结束。` });
+                this.pushHistory({ role: 'system', content: `[注意] 你已连续 ${MAX_IDEMPOTENT_TOOL} 次调用 ${repeatedTool}。请基于已有结果直接回答用户, 不要再次调用任何工具。在回答末尾加 <final gen> 标记结束。` });
                 lastNTools.length = 0; // 重置计数器
                 // 不 break — 让 LLM 在下一轮用已有信息回答
             }
@@ -1845,6 +2316,10 @@ ${toolDefs}
 
 ${PiAgentSession.TOOL_SELECTION_GUIDE}
 
+${PROACTIVE_WORK_DISCIPLINE}
+
+${await this.renderActivePlansSection()}
+
 工作模式:
 1. 理解用户自然语言请求
 2. 分析需要哪些工具来完成
@@ -1940,7 +2415,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     break;
                 }
                 // 把错误当成 tool 结果 push 进 history, 这样下一轮 LLM 看到错误能调整
-                this.messageHistory.push({
+                this.pushHistory({
                     role: 'system',
                     content: `[Loop 错误恢复 ${totalErrors}/${this.MAX_TOTAL_ERRORS}] ${aiFailureReason}\n\n请基于上轮工具结果继续完成任务, 不要重复调用同一失败操作. 如果工具已成功执行, 请基于 result.output 给用户总结; 如果工具失败, 请换其他方式或重试.`
                 });
@@ -2013,7 +2488,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             }
             if (toolCalls.length > 0) {
                 // 把原始 LLM 回复 push 进 history (仅一次)
-                this.messageHistory.push({
+                this.pushHistory({
                     role: 'assistant',
                     content: reply,
                     toolCalls: toolCalls.length > 1 ? toolCalls : [toolCalls[0]],
@@ -2043,12 +2518,12 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         consecutiveErrors++;
                         totalErrors++;
                         const errorResult = { success: false, error: `未知工具: ${toolCall.name}` };
-                        this.messageHistory.push({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
+                        this.pushHistory({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
                         this.logToHarness(toolCall.name, toolCall.args, errorResult);
                         // 2026-07-28: 注入 Reflection 帮助 LLM 理解错误
                         const obs = buildObservation(toolCall.name, toolCall.args, errorResult);
                         const ref = buildReflection(toolCall.name, errorResult.error, totalErrors, lastFailedToolCount);
-                        this.messageHistory.push({ role: 'system', content: formatObservationWithReflection(obs, ref) });
+                        this.pushHistory({ role: 'system', content: formatObservationWithReflection(obs, ref) });
                         if (onStream)
                             onStream({ type: 'status', content: `💡 Reflection: ${obs.summary}`, tool: 'system' });
                         console.warn(`[PiAgent] 未知工具: ${toolCall.name} (累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS})，跳过并继续`);
@@ -2082,7 +2557,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             consecutiveErrors++;
                             totalErrors++;
                             const denyResultMsg = { success: false, error: `拒绝: [${toolDecision.rejectedBy || 'deny-pipeline'}] ${toolDecision.reason}` };
-                            this.messageHistory.push({ role: 'tool', content: JSON.stringify(denyResultMsg), toolResult: denyResultMsg });
+                            this.pushHistory({ role: 'tool', content: JSON.stringify(denyResultMsg), toolResult: denyResultMsg });
                             this.logToHarness(toolCall.name, toolCall.args, denyResultMsg);
                             return;
                         }
@@ -2094,7 +2569,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                                 ? `Harness gate 拒绝 (${toolDecision.rejectedBy}): ${toolDecision.reason || '未通过安全校验'}`
                                 : `PreToolUse 拒绝: ${toolDecision.reason || '未通过安全校验'}`,
                         };
-                        this.messageHistory.push({ role: 'tool', content: JSON.stringify(deniedResult), toolResult: deniedResult });
+                        this.pushHistory({ role: 'tool', content: JSON.stringify(deniedResult), toolResult: deniedResult });
                         this.logToHarness(toolCall.name, toolCall.args, deniedResult);
                         if (onStream) {
                             const gateName = isGateDeny ? `Harness ${toolDecision.rejectedBy}` : (isHarnessError ? '核心约束层' : 'PreToolUse');
@@ -2123,13 +2598,13 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                                 ? `[注意] 连续 ${consecutiveErrors} 次工具调用因约束层失效被阻止. 请换其他工具或直接回答用户, 末尾加 <final gen>.`
                                 : `[注意] 连续 ${consecutiveErrors} 次工具调用被系统拒绝. 请换其他工具或直接回答用户, 末尾加 <final gen>.`;
                         if (lastFailedToolCount >= MAX_SAME_TOOL_FAILURES) {
-                            this.messageHistory.push({ role: 'system', content: systemMaxMsg });
+                            this.pushHistory({ role: 'system', content: systemMaxMsg });
                             lastFailedTool = '';
                             lastFailedToolCount = 0;
                             consecutiveErrors = 0;
                         }
                         else if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-                            this.messageHistory.push({ role: 'system', content: systemConsecMsg });
+                            this.pushHistory({ role: 'system', content: systemConsecMsg });
                             consecutiveErrors = 0;
                         }
                         return;
@@ -2155,7 +2630,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         }
                         let result = replaySkip
                             ? { success: true, output: `[恢复保护] ${toolCall.name} 在中断前已成功执行过, 本次不重复执行 (避免重复副作用)。当时结果: ${replaySkip}`, _replaySkipped: true }
-                            : await tool.execute(toolCall.args);
+                            : await (toolCall.__t0 = Date.now(), tool.execute(expandHomeArgs(toolCall.args)));
                         const toolDurationMs = Date.now() - toolStart;
                         if (replaySkip) {
                             console.log(`[PiAgent] 恢复重放守卫: 跳过已完成的非幂等工具 ${toolCall.name}`);
@@ -2163,18 +2638,18 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         }
                         console.log(`[PiAgent] 工具 ${toolCall.name} 执行完成: success=${result.success} (${toolDurationMs}ms)`);
                         // 2026-09-16 (M3): 失败接线 —— 分类 + recovery 留痕 + 熔断 / 外部等待
-                        if (!result.success && this.currentRunId && !replaySkip) {
+                        if (!result.success && this.actor.state.activeRun && !replaySkip) {
                             await this.wireToolFailure(toolCall.name, String(result.error || ''), toolCall.args);
                         }
-                        else if (result.success && this.currentRunId && this.awaitingExternal) {
+                        else if (result.success && this.actor.state.activeRun && this.awaitingExternal) {
                             // 外部回话了: awaiting_external → running (不是"恢复完成", 只是等待结束)
                             this.awaitingExternal = false;
-                            await this.safeSetRunStatus(this.currentRunId, 'running');
+                            await this.safeSetRunStatus(this.actor.state.activeRun, 'running');
                         }
                         // 2026-09-16: 持久化 run harness — 每步工具调用立即落盘 (崩在这里也能看到做到哪步)
-                        if (this.currentRunId) {
+                        if (this.actor.state.activeRun) {
                             try {
-                                await recordStep(this.currentRunId, {
+                                await recordStep(this.actor.state.activeRun, {
                                     tool: toolCall.name,
                                     ok: !!result.success,
                                     ms: toolDurationMs,
@@ -2205,7 +2680,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             ok: !!result.success,
                         });
                         if (after.routeHint?.systemAddition) {
-                            this.messageHistory.push({ role: 'system', content: `[Harness Router Hint: ${after.routeHint.reason}]\n${after.routeHint.systemAddition}` });
+                            this.pushHistory({ role: 'system', content: `[Harness Router Hint: ${after.routeHint.reason}]\n${after.routeHint.systemAddition}` });
                         }
                         if (after.outputBlocked) {
                             if (onStream) {
@@ -2214,7 +2689,39 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             console.warn(`[PiAgent] Harness output denied ${toolCall.name}: ${after.outputBlocked.reason}`);
                             result = { ...result, output: `[harness output gate: 输出含敏感内容, 已屏蔽. 原因: ${after.outputBlocked.reason}]`, _harnessDenied: true };
                         }
-                        this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result, toolCallId: toolCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}` });
+                        // 2026-10-01: 落库前做一次停滞观测 —— 命中的是"引导/引用", 不是"拒绝执行":
+                        //   完全相同的返回从第 2 次起折叠成引用 (省上下文); 连续 3 次同参数同结果或检测到循环 ⇒
+                        //   在结果尾部追加一条系统提示 (保留模型的选择权, 不硬停 —— 硬停那条已被用户否决)。
+                        try {
+                            const obs = observeToolCall(stallState, {
+                                toolName: toolCall.name,
+                                sameSignatureBefore: this.lastToolSig === argsFingerprint(toolCall.args),
+                                args: toolCall.args,
+                                resultText: String(result.output || (result.success ? '' : String(result.error || ''))),
+                                ok: !!result.success,
+                                seenResultBefore: stallState.hasSeenResult(String(result.output || '')),
+                            });
+                            if (obs.stub) {
+                                result = { ...result, output: obs.stub, _stubbed: true };
+                            }
+                            else if (obs.notice) {
+                                result = { ...result, output: `${String(result.output || '')}\n\n${obs.notice}` };
+                            }
+                            if (obs.action === 'warn') {
+                                console.warn(`[PiAgent] 工具停滞引导 (${obs.code}, 第 ${obs.count} 次): ${toolCall.name}`);
+                                onStream?.({ type: 'status', internal: true, content: `🩺 检测到重复调用 ${toolCall.name} (${obs.code}), 已提示模型换法`, tool: 'loop' });
+                            }
+                        }
+                        catch { /* 观测失败绝不影响主路径 */ }
+                        this.pushHistory({ role: 'tool', content: JSON.stringify(result), toolResult: result, toolCallId: toolCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}` });
+                        // 2026-10-01 (用户: 「为什么这么慢」): 量到的事实 —— 每次 LLM 往返平均 3338ms,
+                        //   而"一轮发多个工具"(toolCalls>1) 只占 12/63 ✗ ⇒ 回合时长 ≈ 往返次数 × 3.3 秒 ✓。
+                        //   本回合**第一次**且**只发一个**工具时, 附一句带代价的提醒(不是口号 ✓), 只提一次免得刷屏。
+                        if (toolCalls.length === 1 && this.successfulToolResults.length <= 1) { // 本回合头一次(免得每轮刷屏)
+                            const __batchHint = batchHint(toolCall.name, 1);
+                            if (__batchHint)
+                                this.pushHistory({ role: 'system', content: __batchHint.trim() });
+                        }
                         this.logToHarness(toolCall.name, toolCall.args, result);
                         // 2026-08-09: 记录到本轮行动日志 (循环进度 + final 前目标核查用)
                         //   去重: 同一工具同 args 连续成功只记一次 (防 LLM 重复 react 刷屏)
@@ -2243,10 +2750,48 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                                 onStream({ type: 'step_error', content: `${toolCall.name} 执行失败`, tool: toolCall.name, error: result.error });
                             }
                         }
+                        // 2026-10-01 (优化 #1/#3/#4): 工具结果的**进上下文闸** + **遥测** + **写操作读回自证**
+                        {
+                            const __ms = Date.now() - Number(toolCall.__t0 || Date.now());
+                            try {
+                                // #1 结果闸: 超上限 ⇒ 头尾 + 完整结果落文件(给路径) ⇒ 上下文不再被一条大输出长期占住
+                                const capped = capToolResult(String(result.output ?? ''), { tool: toolCall.name });
+                                if (capped.capped) {
+                                    result.output = capped.text;
+                                    console.warn(`[PiAgent] ${toolCall.name} 结果过长(${capped.originalChars})已截断` + (capped.spilledTo ? `, 完整内容: ${capped.spilledTo}` : ''));
+                                }
+                                // #4 写操作"读回自证": 写类工具成功后自动核一次(存在? 大小?) ⇒ "工具说成功≠任务成功"从规矩变成机制
+                                // 2026-10-01: 改了 TS 源码就记账 ⇒ 回合收尾自动跑类型检查 (把"靠自觉"变成机制)
+                                {
+                                    const tsFile = codeWriteTarget(toolCall.name, toolCall.args);
+                                    if (tsFile && !this.tsTouchedThisTurn.includes(tsFile))
+                                        this.tsTouchedThisTurn.push(tsFile);
+                                }
+                                const verified = verifyWriteOutcome(toolCall.name, toolCall.args, this.cwd);
+                                if (verified)
+                                    result.output = `${String(result.output ?? '')}\n${verified}`;
+                                // #3 遥测: 记一行(工具/指纹/耗时/成败/结果大小/是否与上一次同签名) ⇒ 重复率可算
+                                recordToolCall({
+                                    tool: toolCall.name,
+                                    sig: argsFingerprint(toolCall.args),
+                                    ms: __ms,
+                                    ok: true,
+                                    resultChars: String(result.output ?? '').length,
+                                    prevSig: this.lastToolSig ?? null,
+                                });
+                                this.lastToolSig = argsFingerprint(toolCall.args);
+                            }
+                            catch { /* 任何优化项失败都不影响工具结果本身 */ }
+                        }
                         if (result.success) {
                             consecutiveErrors = 0;
                             // 2026-07-29: Hermes 风格硬限制计数
                             totalToolCallsThisLoop++;
+                            // 2026-10-01: 批处理工具(一次顶多次) ⇒ **退还**这次迭代 (奖励批处理, 压零碎调用)
+                            if (this.iterBudget && isRefundableTool(toolCall.name)) {
+                                this.iterBudget.refund();
+                                console.warn(`[PiAgent] ${toolCall.name} 是批量工具 ⇒ 退还 1 次迭代 (现 ${this.iterBudget.describe()})`);
+                            }
                             lastNTools.push(toolCall.name);
                             if (lastNTools.length > MAX_IDEMPOTENT_TOOL)
                                 lastNTools.shift();
@@ -2267,6 +2812,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         }
                         else {
                             consecutiveErrors++;
+                            // 2026-10-01 (优化 #3): 失败也记一行(带错误类别) ⇒ "错工具率"从这类错误里看得出来
+                            try {
+                                const __cls = classifyError(String(result.error || '')).label || '未分类';
+                                recordToolCall({ tool: toolCall.name, sig: argsFingerprint(toolCall.args), ms: 0,
+                                    ok: false, resultChars: 0, prevSig: this.lastToolSig ?? null, errorClass: __cls });
+                                this.lastToolSig = argsFingerprint(toolCall.args);
+                            }
+                            catch { /* 遥测失败不影响 */ }
                             totalErrors++;
                             if (toolCall.name === lastFailedTool) {
                                 lastFailedToolCount++;
@@ -2279,18 +2832,18 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                             // 2026-07-28: 注入 Observation + Reflection 替代旧 hardcode 提示
                             const obs = buildObservation(toolCall.name, toolCall.args, { success: false, error: result.error });
                             const ref = buildReflection(toolCall.name, result.error, totalErrors, lastFailedToolCount);
-                            this.messageHistory.push({ role: 'system', content: formatObservationWithReflection(obs, ref) + SHELL_ESCAPE_HINT });
+                            this.pushHistory({ role: 'system', content: formatObservationWithReflection(obs, ref) + SHELL_ESCAPE_HINT });
                             if (onStream)
                                 onStream({ type: 'status', content: `💡 Reflection: ${obs.summary} → ${ref[0]?.action || '放弃'}`, tool: 'system' });
                             if (lastFailedToolCount >= MAX_SAME_TOOL_FAILURES) {
-                                this.messageHistory.push({ role: 'system', content: `[注意] 工具 ${toolCall.name} 在这个上下文中不可用 (连续 ${MAX_SAME_TOOL_FAILURES} 次失败: ${result.error}). 请不要再次调用它, 直接用你已知的信息回答用户, 并在回答开头标记 <final gen>.` });
+                                this.pushHistory({ role: 'system', content: `[注意] 工具 ${toolCall.name} 在这个上下文中不可用 (连续 ${MAX_SAME_TOOL_FAILURES} 次失败: ${result.error}). 请不要再次调用它, 直接用你已知的信息回答用户, 并在回答开头标记 <final gen>.` });
                                 lastFailedTool = '';
                                 lastFailedToolCount = 0;
                                 consecutiveErrors = 0;
                                 return;
                             }
                             if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-                                this.messageHistory.push({ role: 'system', content: `[注意] 前面的工具调用连续失败。请尝试其他工具或换一种方式完成用户请求, 或用 <final gen> 给出最终回答.` });
+                                this.pushHistory({ role: 'system', content: `[注意] 前面的工具调用连续失败。请尝试其他工具或换一种方式完成用户请求, 或用 <final gen> 给出最终回答.` });
                                 consecutiveErrors = 0;
                             }
                         }
@@ -2299,11 +2852,11 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         consecutiveErrors++;
                         totalErrors++;
                         const errorResult = { success: false, error: String(execError) };
-                        this.messageHistory.push({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
+                        this.pushHistory({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
                         this.logToHarness(toolCall.name, toolCall.args, errorResult);
                         const obs = buildObservation(toolCall.name, toolCall.args, errorResult);
                         const ref = buildReflection(toolCall.name, errorResult.error, totalErrors, lastFailedToolCount);
-                        this.messageHistory.push({ role: 'system', content: formatObservationWithReflection(obs, ref) + SHELL_ESCAPE_HINT });
+                        this.pushHistory({ role: 'system', content: formatObservationWithReflection(obs, ref) + SHELL_ESCAPE_HINT });
                         if (onStream)
                             onStream({ type: 'status', content: `💡 Reflection: ${obs.summary}`, tool: 'system' });
                         console.error(`[PiAgent] 工具执行异常 (累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS}): ${execError}`);
@@ -2314,7 +2867,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             }
             else {
                 // LLM 返回的不是 tool call 格式
-                this.messageHistory.push({
+                this.pushHistory({
                     role: 'assistant',
                     content: reply,
                     reasoningContent: response?.reasoningContent,
@@ -2343,7 +2896,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         unreportedRetries++;
                         const unreported = this.successfulToolResults.length;
                         console.log(`[PiAgent] LLM 想 final_gen 但还有 ${unreported} 个工具结果未汇报 (${unreportedRetries}/${MAX_UNREPORTED_RETRIES}), push hint 让其继续`);
-                        this.messageHistory.push({
+                        this.pushHistory({
                             role: 'system',
                             content: `[dive-into stop condition] 你之前已成功执行了 ${unreported} 个工具, 但当前回复里没把它们的结果告诉用户. 请基于已有的工具结果 (在 history 里) 写一个完整总结回复给用户, 用 <final gen> 结尾. 不要再调工具.`
                         });
@@ -2356,7 +2909,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         // 反复提示仍未汇报超过上限 → 清空积压强制 final, 不再死循环
                         console.log(`[PiAgent] unreported 循环超限 (${unreportedRetries} 次), 清空积压强制 final`);
                         this.successfulToolResults = [];
-                        this.messageHistory.push({
+                        this.pushHistory({
                             role: 'system',
                             content: `[dive-into stop condition] 已多次提示汇报工具结果仍未完成 (超过 ${MAX_UNREPORTED_RETRIES} 次). 现在直接基于你已知的信息写最终回复给用户, 用 <final gen> 结尾, 不要再调任何工具.`
                         });
@@ -2368,7 +2921,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     // 2026-07-29: 质量门 — 即使 LLM 声称完成, 质量太低也继续
                     if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {
                         console.log(`[PiAgent] final gen 质量 ${lastQualityScore.toFixed(2)} < ${this.QUALITY_THRESHOLD}, 注入 refine hint`);
-                        this.messageHistory.push({ role: 'system', content: `[质量检查] 你的回答质量评分为 ${(lastQualityScore * 10).toFixed(1)}/10, 低于 ${(this.QUALITY_THRESHOLD * 10).toFixed(1)}/10 阈值。请提供更完整、详细的回答, 包含工具调用获取到的具体信息, 末尾加 <final gen>。` });
+                        this.pushHistory({ role: 'system', content: `[质量检查] 你的回答质量评分为 ${(lastQualityScore * 10).toFixed(1)}/10, 低于 ${(this.QUALITY_THRESHOLD * 10).toFixed(1)}/10 阈值。请提供更完整、详细的回答, 包含工具调用获取到的具体信息, 末尾加 <final gen>。` });
                         refineAttempts++;
                         continue;
                     }
@@ -2383,13 +2936,13 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         userIntent: this.currentUserInput,
                         completedTools: Array.from(loopReviewCompletedTools),
                         actionLog: loopActionLog,
-                        runId: this.currentRunId || undefined,
-                        goalId: this.currentGoalId || undefined,
+                        runId: this.actor.state.activeRun || undefined,
+                        goalId: this.actor.state.goalBinding || undefined,
                     }, DEFAULT_MAX_REVIEWS);
                     if (reviewDecision.kind === 'continue-review') {
                         loopReviewCount++;
                         console.log(`[PiAgent] review ${loopReviewCount}/${DEFAULT_MAX_REVIEWS}: LLM 想 final 但先对齐需求深挖一次`);
-                        this.messageHistory.push({ role: 'system', content: reviewDecision.hint });
+                        this.pushHistory({ role: 'system', content: reviewDecision.hint });
                         if (onStream) {
                             onStream({ type: 'status', internal: true, content: `🔄 目标对齐 review ${loopReviewCount}/${DEFAULT_MAX_REVIEWS}: 深挖续跑`, tool: 'system' });
                         }
@@ -2442,16 +2995,16 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         if (onStream) {
             onStream({ type: 'status', internal: true, content: `✅ 处理完成，共 ${iteration - 1} 次循环`, tool: 'system' });
         }
-        this.messageHistory.push({ role: 'assistant', content: finalResponse });
+        this.pushHistory({ role: 'assistant', content: finalResponse });
         // React Harness: 循环结束
         // 2026-09-16 (Milestone 1-B): 会话收尾走唯一门面
         await this.piHarness().sessionEnd(this.harnessCtx());
         // 2026-09-16: 收尾落盘 — done / failed / aborted / needs_human 如实写回 (不留幽灵 running)
-        if (this.currentRunId && !runExternallyPaused && !runExternallyAborted) {
+        if (this.actor.state.activeRun && !runExternallyPaused && !runExternallyAborted) {
             try {
                 // 2026-09-16 (M4): 完成门 —— "模型说完成"不等于"系统确认完成"。
                 //   证据 = 成功步骤的事实摘要; 末尾还有失败步骤没被后续成功覆盖 → 不许 done。
-                const recBefore = await readRun(this.currentRunId).catch(() => null);
+                const recBefore = await readRun(this.actor.state.activeRun).catch(() => null);
                 const steps = recBefore?.steps || [];
                 const evidence = steps.filter((s) => s.ok).map((s) => `${s.tool}: ${(s.summary || '').slice(0, 120)}`).slice(-10);
                 const lastStep = steps[steps.length - 1];
@@ -2472,7 +3025,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                                 : (trailingFailure || noEvidence)
                                     ? 'failed'
                                     : 'done';
-                await finishRun(this.currentRunId, {
+                await finishRun(this.actor.state.activeRun, {
                     status,
                     summary: finalResponse ? String(finalResponse).slice(0, 400) : undefined,
                     error: errText
@@ -2485,7 +3038,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 // 终态也写不下去: 这是最坏情况 —— 除了留痕, 没有别的自愈手段, 所以必须显眼
                 const message = `收尾落盘失败 (状态无法写回, 记录会停在 running): ${String(err?.message || err).slice(0, 200)}`;
                 console.error('[PiAgent] run-store finishRun 失败 (核心持久化):', message);
-                await recordDegradation({ kind: 'core', op: 'pi-sdk.finishRun', runId: this.currentRunId, message }).catch(() => { });
+                await recordDegradation({ kind: 'core', op: 'pi-sdk.finishRun', runId: this.actor.state.activeRun, message }).catch(() => { });
                 onStream?.({ type: 'error', content: `⚠️ ${message}`, tool: 'harness' });
             }
             // ★ 2026-09-25 (M0 接线冻结, 规则 ③ + ④): Run 结束**必过收尾漏斗**。
@@ -2497,14 +3050,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             //
             // 现在: `closeRunOnce` (幂等) → 9 步收尾 → 产物落盘; 再由 Goal reducer 把"下一步是什么"
             // 落进 Goal (没有 Supervisor 宿主时 Runner 也要留下 continuation, 否则下一次还是从零开始)。
-            if (this.currentGoalId) {
+            if (this.actor.state.goalBinding) {
                 try {
                     const wiring = await import('./goal-flywheel-wiring.js');
                     const { reduceGoalState } = await import('./goal-state-reducer.js');
                     const nowIso = new Date().toISOString();
                     const closed = await wiring.closeRunOnce({
-                        goalId: this.currentGoalId,
-                        runId: this.currentRunId,
+                        goalId: this.actor.state.goalBinding,
+                        runId: this.actor.state.activeRun,
                         caller: 'runner',
                         now: nowIso,
                         finalReview: finalResponse ? String(finalResponse).slice(0, 2000) : '',
@@ -2515,7 +3068,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     else if (closed.outcome) {
                         const view = closed.outcome;
                         const applied = await reduceGoalState({
-                            goalId: this.currentGoalId,
+                            goalId: this.actor.state.goalBinding,
                             intent: 'closure_outcome',
                             now: nowIso,
                             by: 'runner',
@@ -2532,7 +3085,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         onStream?.({
                             type: 'status', internal: true,
                             content: `${line}${applied.gateRejected ? ` [完成门拒绝: ${applied.gateRejected}]` : ''} `
-                                + `(收尾 ${view.steps} 步 · memory ${view.memories} · skill 候选 ${view.candidates} · goal=${this.currentGoalId})`,
+                                + `(收尾 ${view.steps} 步 · memory ${view.memories} · skill 候选 ${view.candidates} · goal=${this.actor.state.goalBinding})`,
                             tool: 'harness',
                         });
                     }
@@ -2542,15 +3095,15 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     }
                 }
                 catch (err) {
-                    await recordDegradation({ kind: 'observational', op: 'pi-sdk.runClosure', runId: this.currentRunId, message: String(err?.message || err).slice(0, 160) }).catch(() => { });
+                    await recordDegradation({ kind: 'observational', op: 'pi-sdk.runClosure', runId: this.actor.state.activeRun, message: String(err?.message || err).slice(0, 160) }).catch(() => { });
                 }
             }
-            this.currentRunId = '';
+            this.actor.state.activeRun = '';
         }
-        else if (this.currentRunId) {
+        else if (this.actor.state.activeRun) {
             // 外部暂停/中止: 状态是人定的, 不覆盖 (paused 等 /resume; aborted 是终态)
             onStream?.({ type: 'status', content: `⏹️ 运行状态保持为 ${runExternallyPaused ? 'paused' : 'aborted'} (由外部控制面决定)`, tool: 'harness' });
-            this.currentRunId = '';
+            this.actor.state.activeRun = '';
         }
         // 2026-06-16: 暴露 aiFailed 标志 — promptStream 据此决定是否自动重试整个 loop
         return { reply: finalResponse, aiFailed, aiFailureReason: aiFailureReason || undefined };
@@ -2604,7 +3157,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         // 失败静默: 任何 stage 抛错 → 走老 slice(-10) 逻辑
         //
         // P1.2: 如果 maybeAutoCompact 算过 Context Collapse 投影, 用 this.projectedHistory (读时投影, 非破坏)
-        const source = this.projectedHistory ?? this.messageHistory;
+        const source = this.projectedHistory ?? this.actor.state.messageHistory;
         const recentMessages = this.compressHistorySync(source).slice(-10);
         return recentMessages.map(m => {
             if (m.role === 'user')
@@ -2631,7 +3184,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             // 2026-08-06: 来源优先用 projectedHistory (Context Collapse 投影, 非破坏) —
             //   与 buildContext 一致; 之前只让字符串路径用投影, messages 数组路径被跳过,
             //   导致 LLM 实际看到的还是未压缩的历史.
-            const source = this.projectedHistory ?? this.messageHistory;
+            const source = this.projectedHistory ?? this.actor.state.messageHistory;
             const WINDOW = 15;
             const out = [];
             // 2026-09-28 (前缀 KV 可命中): 带 CURRENT TURN 注入的条目要**原样回带**.
@@ -2710,11 +3263,11 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
     /**
      * 2026-09-28 (前缀 KV 可命中): 把 chat() 回带的当前轮写回自己的 messageHistory.
      * 逻辑在模块级 `writeBackCurrentTurnInto` (纯函数, 门可以直接驱它断言);
-     * 这里只负责接到 `this.messageHistory` 上, 并保证任何异常都静默 (写回失败不影响对话).
+     * 这里只负责接到 `actor 的 messageHistory` 上, 并保证任何异常都静默 (写回失败不影响对话).
      */
     writeBackCurrentTurn(wire) {
         try {
-            return writeBackCurrentTurnInto(this.messageHistory, wire);
+            return writeBackCurrentTurnInto(this.actor.state.messageHistory, wire);
         }
         catch (err) {
             console.warn('[PiAgent] writeBackCurrentTurn failed (silent):', err);
@@ -2728,7 +3281,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
     estimateHistoryTokens() {
         try {
             const { estimateTokens } = _piRequire('../context-compaction/index.js');
-            return estimateTokens(this.messageHistory);
+            return estimateTokens(this.actor.state.messageHistory);
         }
         catch {
             return 0;
@@ -2751,8 +3304,10 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
             console.warn(`[PiAgent] reactive compaction pre-check (${estimated} tokens > 80% threshold)`);
             onStream?.({ type: 'status', internal: true, content: '⚠️ reactive compaction 预检触发', tool: 'recovery' });
             try {
-                const compacted = this.compressHistorySync(this.messageHistory);
-                this.messageHistory = compacted;
+                // 同步压缩: 取快照与替换在**同一拍相邻两行** (中间没有 await) ⇒ 不存在"变换期间被追加"的窗口。
+                //   若哪天这里插入 await, 必须改成 `actor.rebaseHistory(…, snapshotLen)` (见 channel-actor.ts)。
+                const compacted = this.compressHistorySync(this.actor.state.messageHistory);
+                this.replaceHistory(compacted);
                 if (this.estimateHistoryTokens() > this.maxContextTokens() * 0.8) {
                     await this.maybeAutoCompact(onStream, signal);
                 }
@@ -2803,7 +3358,14 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 //   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
+                // 2026-10-01 (用户: 「思考的记录可以也显示出来吗」): 思考模型的思维链原先只被"存起来回带",
+                //   **不显示** ✗。这里把它往流里送一份 —— 显示与否由 CLI 侧决定(BOLLOON_SHOW_THINKING, 默认显示) ✓。
+                try {
+                    const rc = String(response?.reasoningContent || '').trim();
+                    if (rc)
+                        this.runCtx.eventSink?.({ type: 'reasoning', content: rc });
+                }
+                catch { /* 送不出去不影响主流程 */ } // 2026-06-30: 透传 toolCalls (OpenAI 协议 native) 给上层, 让 assistant message 能 emit 真 id
                 return { reply: response.reply || '', toolCalls: response.toolCalls, messages: response.messages };
             }
             catch (err) {
@@ -2841,8 +3403,8 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     if (Array.isArray(contextOrMessages)) {
                         contextOrMessages = this.buildContext();
                         // 也清除最近一轮的 toolCalls, 防止再触发
-                        if (this.messageHistory.length > 1) {
-                            const last = this.messageHistory[this.messageHistory.length - 1];
+                        if (this.actor.state.messageHistory.length > 1) {
+                            const last = this.actor.state.messageHistory[this.actor.state.messageHistory.length - 1];
                             if (last.role === 'assistant' && last.toolCalls) {
                                 delete last.toolCalls;
                             }
@@ -2905,7 +3467,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
      * onStream 广播: 跟 computeJudgmentGate 风格一致 (phase 事件供 UI timeline 显示)
      */
     async maybeAutoCompact(onStream, signal) {
-        if (this.messageHistory.length < 10)
+        if (this.actor.state.messageHistory.length < 10)
             return; // 历史太短, 不值得压
         onStream?.({ type: 'status', internal: true, content: '🗜️ 评估是否需要压缩上下文...', tool: 'compactor' });
         // 注入 LLM (用 getMinimax().chat, 与 judgment 注入门 / ReAct 循环同一来源)
@@ -2924,14 +3486,17 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         const maxTokens = Math.max(4000, Math.round(cfg.maxTokens * cfg.compressionThreshold));
         const beforeTokens = this.estimateHistoryTokens();
         const { compactPipeline, isContextCollapseEnabled } = await import('../context-compaction/index.js');
-        const result = await compactPipeline(this.messageHistory, {
+        // **K5 第 4 步**: 记下取快照时的长度 —— 压缩是 async, 从这一拍到 "落地" 之间是 await 窗口;
+        //   期间 append 进来的消息必须由 `actor.rebaseHistory(…, snapshotLen)` 接回去, 否则会被整块替换丢掉。
+        const snapshotLen = this.actor.state.messageHistory.length;
+        const result = await compactPipeline(this.actor.state.messageHistory, {
             maxTokens,
             llmChat,
             collapseLlmChat: llmChat, // P1.2: Context Collapse 投影也用同一 LLM
-            cacheScope: this.currentChannelId || 'default',
+            cacheScope: this.actor.state.channelId || 'default',
         });
-        if (result.compacted && result.history.length < this.messageHistory.length) {
-            const saved = this.messageHistory.length - result.history.length;
+        if (result.compacted && result.history.length < this.actor.state.messageHistory.length) {
+            const saved = this.actor.state.messageHistory.length - result.history.length;
             const stagesApplied = result.stages.filter((s) => s.applied).map((s) => s.stage).join(' → ');
             const afterTokens = this.estimateHistoryTokens();
             const savedTokens = Math.max(0, beforeTokens - afterTokens);
@@ -2949,7 +3514,17 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 // messageHistory 不变 (非破坏)
             }
             else {
-                this.messageHistory = result.history; // 真破坏性更新
+                // 真破坏性更新 —— **K5 第 4 步**: 绑定了 actor 就交它落地 (rebase: 保住变换期间的追加);
+                //   未绑定的会话走原路径 (行为不变)。
+                if (this.actor) {
+                    const { keptTail } = await this.actor.rebaseHistory(result.history, snapshotLen);
+                    if (keptTail > 0) {
+                        console.warn(`[PiAgent] 压缩落地: 保住变换期间新追加的 ${keptTail} 条消息 (快照后到达)`);
+                    }
+                }
+                else {
+                    this.replaceHistory(result.history);
+                }
                 this.projectedHistory = null;
             }
             // 2026-08-06: snapshot 记录 before/after + 摘要 (供恢复/调试/UI), 事件广播
@@ -2960,10 +3535,10 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     afterTokens,
                     summary: `压缩管道: ${summaryLine}; 节省 ${savedTokens} tokens / ${saved} 条消息`,
                     preservedMemory: [
-                        ...this.messageHistory.filter(m => m.role === 'user').slice(-3).map(m => (m.content || '').slice(0, 80)),
+                        ...this.actor.state.messageHistory.filter(m => m.role === 'user').slice(-3).map(m => (m.content || '').slice(0, 80)),
                     ],
-                    agentId: this.currentAgentId,
-                    channelId: this.currentChannelId,
+                    agentId: this.actor.state.agentId,
+                    channelId: this.actor.state.channelId,
                 });
                 cm.markCompressComplete(snap);
             }
@@ -3349,10 +3924,16 @@ ${this.extractOperationsFromRef(operationsRef)}
         return { ...this.identity };
     }
     updateIdentity(updates) {
-        this.identity = { ...this.identity, ...updates };
+        // 2026-10-01 **修切换频道后身份不换的根因**: 上一版是 `this.identity = { ...this.identity, ...updates }`
+        //   —— **换成新对象** ✗。而工具上下文是在 registerTools() 时按**对象引用**捕获的 (`identity: this.identity`),
+        //   并且切频道时 session 是**复用**的(pi-sdk-session-factory 的模块级单例, 只调 updateIdentity) ⇒
+        //   工具里的 ctx.identity 一直指向**旧对象** ⇒ `get_identity` 永远返回上一个频道的身份 ✗✗
+        //   (实测: xiaomi/智能体频道都答「233 的 DID + 小龙」, 因为 233 是进程启动时的频道)。
+        //   ⇒ 改成**原地改**: 所有持有者(工具上下文/会话/状态栏)都看到同一个对象的新值 ✓。
+        Object.assign(this.identity, updates);
     }
     setCurrentChannelId(channelId) {
-        this.currentChannelId = channelId;
+        this.actor.state.channelId = channelId;
     }
     getSessionState() {
         return this.sessionManager.getState();
@@ -3365,6 +3946,17 @@ ${this.extractOperationsFromRef(operationsRef)}
     }
     async setPersona(persona) {
         await this.sessionManager.savePersona(persona);
+        // 2026-10-01: **写透** —— 有身份文档的 agent 不套 persona.json, 只写 JSON 等于没改
+        //   (用户报"每次让智能体改都是同一个") ⇒ 同步落进它自己的身份文档 (标记区内)
+        if (this.actor.state.agentId) {
+            try {
+                const { applyPersonaToDocs } = await import('../bootstrap/persona-init.js');
+                const wrote = await applyPersonaToDocs(this.actor.state.agentId, persona);
+                if (wrote.length)
+                    console.warn(`[persona] 已把 ${this.actor.state.agentId} 的 persona 写进身份文档: ${wrote.join(' · ')}`);
+            }
+            catch { /* 非致命 */ }
+        }
         this.persona = persona;
         if (persona.name) {
             this.identity.name = persona.name;