@bolloon/bolloon-agent 0.5.5 → 0.6.0

package/dist/agents/pi-sdk.js

@@ -13,6 +13,8 @@ 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';
@@ -215,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();
@@ -378,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 步。
+     */
+    actor;
+    /**
+     * **K2 迁移中**: 一次 Run 的显式状态载体 (见 src/agents/run-context.ts)。
+     * 入口 (prompt / promptStream / promptWithPivotLoop) 用 createRunContext() 快照一次, 用完即清。
+     * **已外置**: `eventSink` (原 currentOnStream) · `abortSignal` (原 currentSignal)。
+     * 其余 6 个字段仍以本类实例字段为准, 逐格迁移。
      */
-    currentOnStream = null;
-    currentSignal = null;
+    runCtx = createRunContext();
     /** Bootstrap SessionStart 拼的 system prompt 片段 (用完即清) */
     bootstrapAddition = '';
     /** 2026-08-12 (Task3 认知卸载): 工具选择与认知卸载指南 — 注入 system prompt, 降低"模型不触发 write/edit/read"率. */
@@ -396,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 = '';
     /**
@@ -409,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';
@@ -426,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 { /* 静默 */ }
@@ -475,19 +592,23 @@ 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.currentAgentId) {
+            if (this.actor.state.agentId) {
                 const cur = this.identity || {};
                 const curDid = String(cur.did || '');
                 const badDid = !curDid || /^did:(local|pi):/i.test(curDid);
@@ -495,17 +616,17 @@ export class PiAgentSession {
                 // 2026-10-01 加固: **did 与本人密钥不符** 也算坏 —— 用户实测 get_identity 返回一个
                 //   数据里根本不存在的 did (按 peerId 当 scope 新造的), 而它非空、非假值 ⇒ 上一版判据漏过 ✗。
                 //   规矩: 只要 currentAgentId 有值, 身份的 did 就必须等于该 agent 自己的密钥 did。
-                const mine = loadOrCreateAgentIdentity(this.currentAgentId);
+                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.currentAgentId} 的 did ${curDid ? curDid.slice(0, 26) : '(空)'} ⇒ ${mine.did.slice(0, 26)} (以该 agent 自己的密钥为准)`);
+                        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.currentAgentId) || this.currentAgentId } : {}),
+                        ...(missingName ? { name: agentPersonaName(this.actor.state.agentId) || this.actor.state.agentId } : {}),
                     });
                 }
             }
@@ -515,7 +636,7 @@ export class PiAgentSession {
         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.currentAgentId);
+        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;
@@ -601,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} 的历史`);
@@ -608,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} 条历史`);
             }
         }
@@ -628,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,
@@ -645,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.
@@ -819,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,
@@ -894,7 +1030,7 @@ export class PiAgentSession {
         // 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.currentAgentId || this.peerId || 'default';
+        const scope = this.actor.state.agentId || this.peerId || 'default';
         try {
             const real = loadOrCreateAgentIdentity(scope);
             return {
@@ -953,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,
             });
@@ -997,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}`;
                 }
@@ -1006,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
         });
@@ -1022,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;
@@ -1077,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
@@ -1120,14 +1258,13 @@ 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;
@@ -1136,11 +1273,11 @@ export class PiAgentSession {
                     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.currentOnStream?.({ type: 'status', content: `🔎 ${line}`, tool: 'system' });
+                        this.runCtx.eventSink?.({ type: 'status', content: `🔎 ${line}`, tool: 'system' });
                     }
                 }
                 catch (e) {
-                    this.currentOnStream?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
+                    this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
                 }
                 this.tsTouchedThisTurn = [];
             }
@@ -1172,7 +1309,7 @@ export class PiAgentSession {
                         }
                         catch { /* 落日志失败不影响主流程 */ }
                         try {
-                            this.currentOnStream?.({ type: 'status', content: `📚 复盘: ${m}`, tool: 'system' });
+                            this.runCtx.eventSink?.({ type: 'status', content: `📚 复盘: ${m}`, tool: 'system' });
                         }
                         catch { /* 上屏失败不打断 */ }
                     };
@@ -1239,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();
         }
     }
@@ -1248,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)
@@ -1261,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
         });
@@ -1271,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');
             }
@@ -1280,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 超限时触发, 失败静默)
@@ -1319,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 || '';
         }
@@ -1329,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 条, 倒序)',
@@ -1347,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);
@@ -1359,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,
@@ -1420,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;
@@ -1456,8 +1591,7 @@ export class PiAgentSession {
             }
             catch (err) {
                 // abort 失败: 视作"已中断", 抛错让上层用 partial 兜底
-                this.currentOnStream = null;
-                this.currentSignal = null;
+                this.runCtx = createRunContext(); // K2: 用完即清 (换新 Context, 不继承残留);
                 throw err;
             }
             attempt++;
@@ -1495,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: '' });
@@ -1514,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 (失败静默, 不阻塞回复)
@@ -1530,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 {
@@ -1562,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) {
@@ -1610,21 +1743,21 @@ ${await this.renderActivePlansSection()}
 - 工具调用前可以简短思考 (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);
@@ -1637,9 +1770,9 @@ ${await this.renderActivePlansSection()}
         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) {
@@ -1655,7 +1788,9 @@ ${await this.renderActivePlansSection()}
      */
     _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;
@@ -1678,7 +1813,7 @@ ${await this.renderActivePlansSection()}
     }
     /** CLI / Web 注入"当前目标" (有 goalId 就在该 Goal 下执行) */
     setGoalId(goalId) {
-        this.currentGoalId = String(goalId || '');
+        this.actor.state.goalBinding = String(goalId || '');
     }
     /** 核心状态迁移的兜底: 失败 → 记降级 + 交给循环顶部的持久化硬闸 (不吞错) */
     async safeSetRunStatus(runId, to) {
@@ -1697,13 +1832,13 @@ ${await this.renderActivePlansSection()}
      * 这是"错误恢复闭环"的运行时接线点 (此前 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);
@@ -1714,7 +1849,7 @@ ${await this.renderActivePlansSection()}
                 : 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,
@@ -1723,20 +1858,20 @@ ${await this.renderActivePlansSection()}
             });
         }
         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(),
@@ -1746,31 +1881,31 @@ ${await this.renderActivePlansSection()}
                 }
             }
             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。
@@ -1817,7 +1952,7 @@ ${await this.renderActivePlansSection()}
         }
         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 } : {}) };
@@ -1836,8 +1971,8 @@ ${await this.renderActivePlansSection()}
                 // 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;
@@ -1845,10 +1980,10 @@ ${await this.renderActivePlansSection()}
     /** 每个生命周期事件都带上的运行身份 (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,
         };
     }
@@ -1915,26 +2050,26 @@ ${await this.renderActivePlansSection()}
         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);
@@ -1949,8 +2084,8 @@ ${await this.renderActivePlansSection()}
                     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;
@@ -1959,25 +2094,25 @@ ${await this.renderActivePlansSection()}
                         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 模式默认如此)
@@ -2007,18 +2142,18 @@ ${await this.renderActivePlansSection()}
                 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;
                     }
@@ -2070,14 +2205,14 @@ ${await this.renderActivePlansSection()}
             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 在下一轮用已有信息回答
             }
@@ -2280,7 +2415,7 @@ ${await this.renderActivePlansSection()}
                     break;
                 }
                 // 把错误当成 tool 结果 push 进 history, 这样下一轮 LLM 看到错误能调整
-                this.messageHistory.push({
+                this.pushHistory({
                     role: 'system',
                     content: `[Loop 错误恢复 ${totalErrors}/${this.MAX_TOTAL_ERRORS}] ${aiFailureReason}\n\n请基于上轮工具结果继续完成任务, 不要重复调用同一失败操作. 如果工具已成功执行, 请基于 result.output 给用户总结; 如果工具失败, 请换其他方式或重试.`
                 });
@@ -2353,7 +2488,7 @@ ${await this.renderActivePlansSection()}
             }
             if (toolCalls.length > 0) {
                 // 把原始 LLM 回复 push 进 history (仅一次)
-                this.messageHistory.push({
+                this.pushHistory({
                     role: 'assistant',
                     content: reply,
                     toolCalls: toolCalls.length > 1 ? toolCalls : [toolCalls[0]],
@@ -2383,12 +2518,12 @@ ${await this.renderActivePlansSection()}
                         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})，跳过并继续`);
@@ -2422,7 +2557,7 @@ ${await this.renderActivePlansSection()}
                             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;
                         }
@@ -2434,7 +2569,7 @@ ${await this.renderActivePlansSection()}
                                 ? `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');
@@ -2463,13 +2598,13 @@ ${await this.renderActivePlansSection()}
                                 ? `[注意] 连续 ${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;
@@ -2503,18 +2638,18 @@ ${await this.renderActivePlansSection()}
                         }
                         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,
@@ -2545,7 +2680,7 @@ ${await this.renderActivePlansSection()}
                             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) {
@@ -2578,14 +2713,14 @@ ${await this.renderActivePlansSection()}
                             }
                         }
                         catch { /* 观测失败绝不影响主路径 */ }
-                        this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result, toolCallId: toolCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}` });
+                        this.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.messageHistory.push({ role: 'system', content: __batchHint.trim() });
+                                this.pushHistory({ role: 'system', content: __batchHint.trim() });
                         }
                         this.logToHarness(toolCall.name, toolCall.args, result);
                         // 2026-08-09: 记录到本轮行动日志 (循环进度 + final 前目标核查用)
@@ -2697,18 +2832,18 @@ ${await this.renderActivePlansSection()}
                             // 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;
                             }
                         }
@@ -2717,11 +2852,11 @@ ${await this.renderActivePlansSection()}
                         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}`);
@@ -2732,7 +2867,7 @@ ${await this.renderActivePlansSection()}
             }
             else {
                 // LLM 返回的不是 tool call 格式
-                this.messageHistory.push({
+                this.pushHistory({
                     role: 'assistant',
                     content: reply,
                     reasoningContent: response?.reasoningContent,
@@ -2761,7 +2896,7 @@ ${await this.renderActivePlansSection()}
                         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> 结尾. 不要再调工具.`
                         });
@@ -2774,7 +2909,7 @@ ${await this.renderActivePlansSection()}
                         // 反复提示仍未汇报超过上限 → 清空积压强制 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> 结尾, 不要再调任何工具.`
                         });
@@ -2786,7 +2921,7 @@ ${await this.renderActivePlansSection()}
                     // 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;
                     }
@@ -2801,13 +2936,13 @@ ${await this.renderActivePlansSection()}
                         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' });
                         }
@@ -2860,16 +2995,16 @@ ${await this.renderActivePlansSection()}
         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];
@@ -2890,7 +3025,7 @@ ${await this.renderActivePlansSection()}
                                 : (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
@@ -2903,7 +3038,7 @@ ${await this.renderActivePlansSection()}
                 // 终态也写不下去: 这是最坏情况 —— 除了留痕, 没有别的自愈手段, 所以必须显眼
                 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 结束**必过收尾漏斗**。
@@ -2915,14 +3050,14 @@ ${await this.renderActivePlansSection()}
             //
             // 现在: `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) : '',
@@ -2933,7 +3068,7 @@ ${await this.renderActivePlansSection()}
                     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',
@@ -2950,7 +3085,7 @@ ${await this.renderActivePlansSection()}
                         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',
                         });
                     }
@@ -2960,15 +3095,15 @@ ${await this.renderActivePlansSection()}
                     }
                 }
                 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 };
@@ -3022,7 +3157,7 @@ ${await this.renderActivePlansSection()}
         // 失败静默: 任何 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')
@@ -3049,7 +3184,7 @@ ${await this.renderActivePlansSection()}
             // 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 注入的条目要**原样回带**.
@@ -3128,11 +3263,11 @@ ${await this.renderActivePlansSection()}
     /**
      * 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);
@@ -3146,7 +3281,7 @@ ${await this.renderActivePlansSection()}
     estimateHistoryTokens() {
         try {
             const { estimateTokens } = _piRequire('../context-compaction/index.js');
-            return estimateTokens(this.messageHistory);
+            return estimateTokens(this.actor.state.messageHistory);
         }
         catch {
             return 0;
@@ -3169,8 +3304,10 @@ ${await this.renderActivePlansSection()}
             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);
                 }
@@ -3226,7 +3363,7 @@ ${await this.renderActivePlansSection()}
                 try {
                     const rc = String(response?.reasoningContent || '').trim();
                     if (rc)
-                        this.currentOnStream?.({ type: 'reasoning', content: 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 };
@@ -3266,8 +3403,8 @@ ${await this.renderActivePlansSection()}
                     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;
                             }
@@ -3330,7 +3467,7 @@ ${await this.renderActivePlansSection()}
      * 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 循环同一来源)
@@ -3349,14 +3486,17 @@ ${await this.renderActivePlansSection()}
         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);
@@ -3374,7 +3514,17 @@ ${await this.renderActivePlansSection()}
                 // 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), 事件广播
@@ -3385,10 +3535,10 @@ ${await this.renderActivePlansSection()}
                     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);
             }
@@ -3783,7 +3933,7 @@ ${this.extractOperationsFromRef(operationsRef)}
         Object.assign(this.identity, updates);
     }
     setCurrentChannelId(channelId) {
-        this.currentChannelId = channelId;
+        this.actor.state.channelId = channelId;
     }
     getSessionState() {
         return this.sessionManager.getState();
@@ -3798,12 +3948,12 @@ ${this.extractOperationsFromRef(operationsRef)}
         await this.sessionManager.savePersona(persona);
         // 2026-10-01: **写透** —— 有身份文档的 agent 不套 persona.json, 只写 JSON 等于没改
         //   (用户报"每次让智能体改都是同一个") ⇒ 同步落进它自己的身份文档 (标记区内)
-        if (this.currentAgentId) {
+        if (this.actor.state.agentId) {
             try {
                 const { applyPersonaToDocs } = await import('../bootstrap/persona-init.js');
-                const wrote = await applyPersonaToDocs(this.currentAgentId, persona);
+                const wrote = await applyPersonaToDocs(this.actor.state.agentId, persona);
                 if (wrote.length)
-                    console.warn(`[persona] 已把 ${this.currentAgentId} 的 persona 写进身份文档: ${wrote.join(' · ')}`);
+                    console.warn(`[persona] 已把 ${this.actor.state.agentId} 的 persona 写进身份文档: ${wrote.join(' · ')}`);
             }
             catch { /* 非致命 */ }
         }