@bolloon/bolloon-agent 0.5.5 → 0.6.1

package/dist/agents/pi-sdk.js

@@ -13,16 +13,23 @@ import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { expandHomeArgs } from './tool-path-args.js';
+import { createRunContext } from './run-context.js';
+import { createPrivateActor } from '../kernel/channel-actor.js';
+// K10 ①: 运行生命周期写入经内核端口 (与 kernel/control.ts 的控制面分开 —— 一个回答"谁命令我停",
+//   一个回答"我这一轮发生了什么"; 失败语义也不同: 控制面被拒 → 409, 事实写不进 → 响亮失败)
+import { submitRunLifecycle, assertLifecycleOk } from '../kernel/run-lifecycle.js';
+// K10 ④: 通信发送入口经内核端口 (上层不再直接对某条传输说话; 换传输只改这一处注入)
+import { submitTransport, transportPeersSync } from '../kernel/transport.js';
+// K10 ①: run 状态迁移经内核**控制面**端口 (它本来就管"谁命令这条 run 改状态": 带 origin 审计 + 拒绝归一化)
+import { submitRunControl } from '../kernel/control.js';
+// K10 ②: 回合的模型经**内核运行时**只读取租约 (传输仍是 Pi 客户端 ⇒ 行为不变; 取不到如实回落)
+import { ModelRuntime, snapshotFromSelection } from '../kernel/model-runtime.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 ⇒
@@ -44,12 +51,11 @@ import { ConstraintLayer } from './constraint-layer.js';
 import { WorkflowEngine } from './workflow-engine.js';
 import { DeepThinkingEngine, AgentCoordinator } from '@bolloon/constraint-runtime';
 import { WorkflowPivotLoop, createDefaultPivotConfig } from './workflow-pivot-loop.js';
+import { nativeAdapterFromEnv } from '../llm/native-adapter.js'; // K9: 第二个 (非 Pi) 推理适配器
 import { initDocumentReceiver } from './p2p-document-tools.js';
-import { startRun, recordStep, finishRun, readRun, budgetVerdict, recordDegradation, recordHarnessEvent, recordRecovery, setRunStatus, prepareResume, markRunRunning, buildResumeInstruction, argsDigestOf, repeatedFailureCount, classifyError as classifyRunError } from './run-store.js';
-import { createGoal, attachRun, findActiveGoal } from './goal-store.js';
+import { startRun, recordStep, finishRun, readRun, recordDegradation, recordHarnessEvent, recordRecovery, setRunStatus, prepareResume, buildResumeInstruction, argsDigestOf, repeatedFailureCount, classifyError as classifyRunError } from './run-store.js';
+import { createGoal, attachRun } from './goal-store.js';
 import { captureRunModelConfig } from '../llm/model-selection.js';
-// 2026-09-26: 工具名出网净化 (pi-ai.ts 唯一边界) + 回程派发还原 (原名 ↔ API 名)
-import { resolveApiToolName, expandKnownToolNames } from '../llm/tool-name.js';
 // 2026-09-28 (前缀 KV 可命中): CURRENT TURN 注入标记 —— "当前轮是否已注入"的唯一判据
 import { CURRENT_TURN_MARKER } from '../llm/pi-ai.js';
 import { PiAgentHarness } from './pi-harness.js';
@@ -78,18 +84,14 @@ import { getInjectionMaxChars } from '../bootstrap/exhaust-scrubber.js';
 import { monitorAfterReply } from '../pi-ecosystem-judgment/monitor-gate.js';
 // Bootstrap 生命周期 hook (SessionStart / Stop / PreToolUse)
 import { onSessionStart, onStop, onPreToolUse } from '../pi-ecosystem-judgment/human-value-pipeline.js';
-import { onPostToolUse } from '../bootstrap/lifecycle-hooks.js';
 import { budgetReduce, snip, microcompact } from '../context-compaction/index.js';
 // React Harness: 8-gate + 4-guard (防越权 / 防 prompt 注入)
 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, classifyError } from './error-classifier.js';
+import { parseToolCall as parseToolCallImpl, isFinalResponse as isFinalResponseImpl, extractFinalAnswer as extractFinalAnswerImpl } from './parse-tool-call.js';
 import { sessionStore as defaultSessionStore } from './session-store.js';
 import { ToolRegistry } from './tool-registry.js';
-import { decideMaxIterations, decideContextOverflow, shouldCompactBeforeIteration } from './react-loop.js';
-import { DEFAULT_MAX_REVIEWS } from './loop-review.js';
 // PiSessionManager 已抽到 ./pi-sdk-session-manager.ts (2026-07-06)
 // Tool / ToolResult / Message / StreamCallback / StreamEvent / HeartbeatConfig / AgentSession / TOOL_DEFINITIONS
 //   已抽到 ./pi-sdk-types.ts (2026-07-06)
@@ -147,32 +149,14 @@ export function writeBackCurrentTurnInto(history, wire) {
         return 0; // 写回失败绝不影响对话本身
     }
 }
-import { LoopStallState, observeToolCall, batchHint } from './tool-loop-guard.js';
 /**
- * 写操作"读回自证" (2026-10-01 优化 #4): 写类工具成功后**自动**核一次, 把事实拼进结果。
- * 为什么: 过程纪律写了"读回一次", 但**没人执行** ✗ ⇒ 现在由机制执行: "工具说成功 ≠ 任务成功"。
- * 只做**便宜**的核对(存在性/大小); 失败静默(核对不该把工具搞失败)。
+ * 写操作「读回自证」的实现已拆到 `./write-verify.js` (K10 ⑦):
+ *   - 要接进 `pi-sdk-tools.ts` 的写类工具 ⇒ 留在这里会形成循环 import;
+ *   - 原实现在函数体里用 `require('node:fs')`, 而产物是 ESM ⇒ 它此前**一次都没成功过**
+ *     (只会被 catch 吞成 `[未核对] … require is not defined`)。
+ * 这里保留**同名转出**, 老的 import 点不受影响。
  */
-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)} —— 别急着说"已完成", 先确认路径/权限`;
-    }
-}
+export { verifyWriteOutcome, withWriteVerified, WRITE_TOOLS } from './write-verify.js';
 /**
  * 过程纪律 (2026-10-01, 用户: 「智能体回复方式没有主动性 … 在过程里面更加主动考虑」)。
  *
@@ -215,7 +199,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();
@@ -310,7 +377,7 @@ export class PiAgentSession {
     harnessEnabled = false;
     /** 8-gate + 4-guard 集中调度 (防越权 / 防 prompt 注入) */
     reactHarness = new ReactHarness();
-    usePivotLoop = false;
+    usePivotLoop = true; // K4-B (2026-10-02): 默认切到 pivot —— 所有入口只跑**一套** loop (老 ReAct loop 待删)
     pivotLoopConfig;
     /** P2: 当前会话的 permission mode (每次 promptStream 入口解析) */
     currentPermissionMode = 'default';
@@ -378,11 +445,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"率. */
@@ -396,12 +481,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 +499,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 +525,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 +574,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 +598,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,9 +618,9 @@ 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.usePivotLoop = config.usePivotLoop ?? true; // K4-B: 默认 true (K4-B 之前是 false ⇒ CLI 走老 loop, 与 web 分叉)
         this.pivotLoopConfig = config.pivotLoopConfig;
         this.initSession();
         initDocumentReceiver();
@@ -601,6 +704,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 +723,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 +743,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 +763,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 +937,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 +1012,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 +1071,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 +1115,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,48 +1124,64 @@ 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
         });
-        if (!this.minimaxAvailable) {
+        // K9 (2026-10-02): 同 `promptWithPivotLoop` —— **回合入口的可用性判据必须问当前适配器**。
+        //   这类 `!minimaxAvailable` 闸一共 6 处: 1223(prompt)/1466(promptStream)/1714(pivot, 已修)
+        //   是**回合入口** ⇒ 全部改用 `inferenceAvailable()`; 其余三处是 Pi 自己的文档类功能
+        //   (`suggestRename`/`summarizeDocument`/`improveDocument`), 不在 `LLMInterface` 面内 ⇒ 如实保留。
+        if (!this.inferenceAvailable()) {
             // 2026-09-16 (2-C.2): fallback **也必须留下 Run 事实**。
             //   旧行为: 直接返回兜底文案, 连 Run 都不建 —— 上层 (独立宿主/Supervisor) 只看到"执行完成但没有 Run",
             //   于是把"什么都没跑"当成一次正常执行 (这正是"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;
-                const rec = await startRun({
-                    surface: this.runSurface,
-                    goal: this.currentUserInput || input.slice(0, 200),
-                    goalId: boundGoalId,
-                    channelId: this.currentChannelId || undefined,
-                    agentId: this.currentAgentId || undefined,
-                    modelConfig: await this.runModelSnapshot(),
-                });
+                this.actor.state.goalBinding = boundGoalId;
+                // K10 ①: 三处写入均经内核端口; 写不进就 assertLifecycleOk 抛 (run-store strict: 写不进 = 这次运行在事实层面不存在)
+                const startOut = await submitRunLifecycle({
+                    op: 'start-run',
+                    origin: 'pi-session',
+                    payload: {
+                        surface: this.runSurface,
+                        goal: this.currentUserInput || input.slice(0, 200),
+                        goalId: boundGoalId,
+                        channelId: this.actor.state.channelId || undefined,
+                        agentId: this.actor.state.agentId || undefined,
+                        modelConfig: await this.runModelSnapshot(),
+                    },
+                }, { startRun: startRun });
+                assertLifecycleOk(startOut);
+                const rec = startOut.result;
                 this.lastRunId = rec.runId;
                 await attachRun(boundGoalId, rec.runId).catch(() => null);
-                await recordStep(rec.runId, { tool: 'llm', ok: false, error: 'LLM 不可用 (provider 未初始化/无 apiKey) → 走了 fallback' });
-                await finishRun(rec.runId, {
-                    status: 'needs_human',
-                    error: 'LLM 不可用: provider 未初始化或无 apiKey (fallback 不是执行结果, 需要配置或人工处理)',
-                });
+                const stepOut = await submitRunLifecycle({
+                    op: 'record-step',
+                    origin: 'pi-session',
+                    runId: rec.runId,
+                    payload: { tool: 'llm', ok: false, error: 'LLM 不可用 (provider 未初始化/无 apiKey) → 走了 fallback' },
+                }, { recordStep: recordStep });
+                assertLifecycleOk(stepOut);
+                // 收尾漏斗门的登记项按**单行**匹配 (seams.ts:564 `ls.find(...)`) ⇒ 这次调用刻意写成一行, 好让登记项能钉住它
+                const finOut = await submitRunLifecycle({ op: 'finish-run', origin: 'pi-session', runId: rec.runId, payload: { status: 'needs_human', error: 'LLM 不可用: provider 未初始化或无 apiKey (fallback 不是执行结果, 需要配置或人工处理)' } }, { finishRun: finishRun });
+                assertLifecycleOk(finOut);
                 // ★ M0: "工具/权限不可用"也是一条终止路径 → 同样进收尾漏斗 (规则 ④)。
                 const wiring = await import('./goal-flywheel-wiring.js');
                 const closed = await wiring.closeRunOnce({
@@ -1077,25 +1211,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
@@ -1107,43 +1243,22 @@ export class PiAgentSession {
             console.warn('[PiAgent] resolvePermissionMode failed (non-fatal):', err);
             this.currentPermissionMode = 'default';
         }
-        // M3.1 (2026-06-17): 跟 promptStream 一样, usePivotLoop 时走 pivotLoop 路径
-        //   之前 prompt() 永远跑老 runReActLoop, CLI/web 行为不一致
-        if (this.usePivotLoop) {
-            try {
-                const lr = await this.promptWithPivotLoop(input, undefined, options?.channelId);
-                this.finishTrajectory(trajRec, lr.response || '');
-                return lr.response || '';
-            }
-            finally {
-                if (this.judgmentGateUsedIds.length > 0) {
-                    recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) => console.warn('[PiAgent] recordJudgmentUsage failed:', err));
-                }
-                this.clearJudgmentGate();
-                this.currentSignal = null;
-                this.currentOnStream = null;
-                this.reportUsageToContextManager();
-            }
-        }
+        // K4-B (2026-10-02): **这条路已经只有一条** —— 原先这里有个 `if (this.usePivotLoop) { ... return ... }`
+        //   的提前返回分支, 它的 finally 只是**子集** (只记正极性用法), 而且**少跑了**:
+        //   回合后复盘 `runExperienceReview` · `monitorAfterReply`/`onStop` · `finishTrajectory(reply, ok|error)`
+        //   · 负极性用法记账 · `bootstrapAddition`/`promptStartTime` 清理。现在统一走下面那条完整收尾。
         try {
-            // 2026-06-16: runReActLoop 现在返回 { reply, aiFailed, aiFailureReason } — 这里只需 reply 字符串
-            const loopResult = await this.runReActLoop(this.currentOnStream ?? 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.currentOnStream?.({ type: 'status', content: `🔎 ${line}`, tool: 'system' });
-                    }
-                }
-                catch (e) {
-                    this.currentOnStream?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
-                }
-                this.tsTouchedThisTurn = [];
-            }
+            // K4-B (2026-10-02): **合并两套 loop ⇒ 只剩 pivot 这一套** (老 `runReActLoop` 已删除)。
+            //   这里保留一个与原签名同形的 `loopResult`, 让下面那段**完整收尾**(自检 → 复盘 → 轨迹 → 记账)
+            //   原样继续工作, 不搬家。
+            const lr = await this.promptWithPivotLoop(input, undefined, options?.channelId);
+            const loopResult = {
+                reply: lr.response || '',
+                aiFailed: !lr.success,
+                aiFailureReason: String(lr.exitReason || ''),
+            };
+            // K4-B (2026-10-02): 收尾自检抽成方法, 两条 loop 路径都调 (原先只在老 loop 之后 ⇒ 生产 pivot 路径从没跑过)
+            await this.runTurnEndTypecheck();
             // 2026-10-01: **回合后自审 (纯旁路)** —— 沉淀可复用经验, 对应"结束后沉淀"那一段。
             //   纪律: fire-and-forget (不阻塞主回合) · 只写 ~/.bolloon/experience/ (**不碰主对话/prompt 缓存**)
             //        · 节流 (默认 10 分钟/agent) · 失败只记一行日志, 绝不影响本回合结果。
@@ -1172,7 +1287,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,16 +1354,15 @@ 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();
         }
     }
     async promptStream(input, onStream, signal, channelId) {
         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;
+        console.log(`[PiAgent.promptStream] minimaxAvailable=${this.minimaxAvailable} nativeAdapter=${process.env.BOLLOON_NATIVE_ADAPTER === '1'} usable=${this.inferenceAvailable()}`);
+        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 +1375,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,38 +1385,40 @@ 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');
             }
         }
         catch { /* 记忆召回失败静默 (增强层) */ }
         onStream({ type: 'thinking', content: '🤔 开始思考...' });
-        if (!this.minimaxAvailable) {
+        // K9: 流式入口同样问**当前适配器** (web/手机端就走这条路 —— 只修 pivot 那道闸时,
+        //   CLI 通了、web 仍然静默空回复, 现象是"适配器被选中但这条路一次没跑")。
+        if (!this.inferenceAvailable()) {
             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 +1435,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 +1445,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 +1463,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 +1475,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,
@@ -1388,53 +1504,11 @@ export class PiAgentSession {
             this.currentPermissionMode = 'default';
         }
         this.promptStartTime = Date.now();
-        // M3.1 (2026-06-17): 走 WorkflowPivotLoop (usePivotLoop: true)
-        //   pivot loop 自带 quality scoring / 30 iter cap / complexity analysis — 比老 runReActLoop 鲁棒
-        if (this.usePivotLoop) {
-            let pivotResult = '';
-            try {
-                const lr = await this.promptWithPivotLoop(userText, undefined, channelId);
-                pivotResult = lr.response || '';
-                onStream({ type: 'done', content: '' });
-            }
-            catch (err) {
-                if (signal?.aborted || err?.name === 'AbortError') {
-                    console.log(`[chat] pivot aborted channel=${channelId}`);
-                }
-                else {
-                    console.error(`[chat] pivot 失败 channel=${channelId}:`, err);
-                    pivotResult = `[错误: pivot loop 失败] ${String(err?.message || err).slice(0, 300)}`;
-                    try {
-                        onStream({ type: 'error', content: pivotResult, tool: 'system' });
-                    }
-                    catch { }
-                }
-            }
-            finally {
-                if (this.judgmentGateUsedIds.length > 0) {
-                    try {
-                        onStream({ type: 'used_judgments', usedIds: this.judgmentGateUsedIds, content: '' });
-                    }
-                    catch { }
-                }
-                monitorAfterReply(userText, pivotResult);
-                const stopStartTime = this.promptStartTime || Date.now();
-                onStop({
-                    channelId: this.currentChannelId || '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.bootstrapAddition = '';
-                this.contextHintAddition = '';
-                this.promptStartTime = 0;
-                this.reportUsageToContextManager();
-            }
-            this.finishTrajectory(trajRec, pivotResult);
-            return pivotResult;
-        }
+        // K4-B (2026-10-02): **流式路径也只剩一条** —— 原先这里有个 pivot 提前 return 分支,
+        //   它自己的 finally 是**子集** (且少了 `contextHintAddition` 清理)。现在统一走下面的
+        //   "外层重试 + 完整收尾", 而重试体里跑的是 pivot (老 `runReActLoop` 已删除)。
+        //   重试语义**刻意保留**: 临时网络抖动/配额瞬时超限可自愈, 且状态文案被
+        //   `reply-hygiene.test.ts` 与 `web-loop-status-bar.spec.ts` 两个用例锁着。
         // 2026-06-16: loop 自动重试 — runReActLoop 内部遇到 [AI 服务调用失败] sentinel 时,
         //   会设 aiFailed=true 并提前 break. 这里在外层重跑整个 loop (不是单次 LLM 调用),
         //   临时网络抖动 / 配额瞬时超限可自愈. 最多 3 次, 指数退避 1s/2s/4s.
@@ -1445,19 +1519,20 @@ export class PiAgentSession {
         let lastAiFailureReason = '';
         while (attempt <= MAX_LOOP_RETRIES) {
             try {
-                const loopResult = await this.runReActLoop(onStream, signal);
-                result = loopResult.reply;
+                const lr = await this.promptWithPivotLoop(userText, undefined, channelId);
+                result = lr.response || '';
+                // K4-B: 收尾自检在**这条**路径上也要跑 (原先只有 pivot 分支跑, 而 pivot 分支已被合并掉)
+                await this.runTurnEndTypecheck();
                 // 持久化失败不重试 (写不进去就是写不进去): 直接按本次结果收尾
                 if (this.runPersistenceBlocked)
                     break;
-                if (!loopResult.aiFailed)
+                if (lr.success)
                     break; // 正常完成, 退出 retry 循环
-                lastAiFailureReason = loopResult.aiFailureReason || 'AI 调用失败';
+                lastAiFailureReason = String(lr.exitReason || 'AI 调用失败');
             }
             catch (err) {
                 // abort 失败: 视作"已中断", 抛错让上层用 partial 兜底
-                this.currentOnStream = null;
-                this.currentSignal = null;
+                this.runCtx = createRunContext(); // K2: 用完即清 (换新 Context, 不继承残留);
                 throw err;
             }
             attempt++;
@@ -1495,8 +1570,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,24 +1589,130 @@ 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.contextHintAddition = ''; // K4-B: 与被合并掉的那条分支对齐 (它清了这条, 老尾段漏了)
         this.promptStartTime = 0;
         // 2026-08-08: 轨迹收尾 — 落盘 + OrbitDB (失败静默, 不阻塞回复)
         this.finishTrajectory(trajRec, result);
         return result;
     }
+    /**
+     * K9 (2026-10-02): 推理适配器的**唯一选择点** —— "用哪个适配器"只在这里决定一次。
+     *
+     *   `BOLLOON_NATIVE_ADAPTER=1` ⇒ 用**非 Pi** 的 native 适配器 (`src/llm/native-adapter.ts`,
+     *     源码里不 import 任何 Pi 模块, 只用 fetch 直连 OpenAI 兼容端点);
+     *   否则 ⇒ Pi 侧模型 (原行为, 默认不变)。
+     *
+     * 关键: 上层 (pivot loop / Harness 门 / Run / Channel) **一行都不用改** ——
+     * 这正是 K10 撤换判据里「**出现第二个推理适配器能过同一套门**」要证的东西。
+     */
+    /** K9: 当前适配器是否可用 (native 开关打开且拿到 key ⇒ 用它自己的判据, 不再借 Pi 的) */
+    inferenceAvailable() {
+        if (process.env.BOLLOON_NATIVE_ADAPTER === '1' && nativeAdapterFromEnv())
+            return true;
+        return this.minimaxAvailable;
+    }
+    // ── K10 ②: 内核模型运行时的接缝 ────────────────────────────────────────────
+    /** 进程内的内核运行时 (懒建)。传输由 `openPiConnection` 注入 ⇒ 真传输仍是 Pi 的客户端 */
+    runtimeSingleton;
+    kernelModelRuntime() {
+        if (!this.runtimeSingleton) {
+            this.runtimeSingleton = new ModelRuntime({ openConnection: async (snapshot) => this.openPiConnection(snapshot) }, 30_000, 4);
+        }
+        return this.runtimeSingleton;
+    }
+    /** 端口实现: "开一条连接" = 拿 Pi 的 LLM 客户端 (进程级单例, 由 installRuntime 装配) */
+    async openPiConnection(snapshot) {
+        const client = getMinimax();
+        return {
+            id: `${snapshot.provider}:${snapshot.model}`,
+            call: async (req) => {
+                try {
+                    const raw = await client.chat(req.context, req.systemPrompt, req.signal, req.tools, req.purpose, req.source);
+                    return { ok: true, provider: snapshot.provider, raw };
+                }
+                catch (err) {
+                    return { ok: false, provider: snapshot.provider, error: String(err?.message ?? err).slice(0, 300) };
+                }
+            },
+            // Pi 客户端是**进程级单例** ⇒ 不随连接关闭 (连接池负责复用/计数)
+            close: async () => { },
+        };
+    }
+    /**
+     * K10 ②: 用内核运行时取一个**租约**并适配成 `LLMInterface`。
+     *   拿不到有效快照 / acquire 失败 ⇒ 返回 null ⇒ 调用方**如实记**并回落 Pi 直连 (不假装走了内核)。
+     */
+    async kernelLeaseAdapter() {
+        let snapshot = null;
+        try {
+            const eff = await captureRunModelConfig();
+            snapshot = snapshotFromSelection({ provider: eff.provider, model: eff.model, baseUrl: eff.baseUrl });
+        }
+        catch {
+            return null;
+        }
+        if (!snapshot)
+            return null;
+        // ⚠️ 踩过的坑 (2026-10-02): 一开始在**适配器创建时**取一个租约、每次 chat 后 `lease.release()`
+        //   ⇒ 第二次 chat 撞上「租约已归还」(model-runtime.ts:278 的守卫) ⇒ 适配器抛错 ⇒ 回合在第 2 轮就死
+        //   (实测: k7-tsc-tool-e2e 允许路/拒绝路判红, 而强制 Pi 直连全绿)。
+        //   正确姿势: **每次调用现取租约** (连接由池复用, 取租约几乎零成本), 用完立刻归还。
+        const runtime = this.kernelModelRuntime();
+        return {
+            chat: async (context, systemPrompt, signal, tools, purpose, source) => {
+                let lease;
+                try {
+                    lease = await runtime.acquire(snapshot);
+                }
+                catch (err) {
+                    throw new Error(`[kernel-model-runtime] acquire 失败: ${String(err?.message ?? err).slice(0, 160)}`);
+                }
+                try {
+                    const res = await lease.call({ context, systemPrompt, signal, tools, purpose, source }, { signal });
+                    if (!res.ok)
+                        throw new Error(res.error || '内核模型调用失败');
+                    return res.raw;
+                }
+                finally {
+                    lease.release(); // 归还租约 (连接由池管理, 不关)
+                }
+            },
+        };
+    }
+    async inferenceAdapter() {
+        if (process.env.BOLLOON_NATIVE_ADAPTER === '1') {
+            const a = nativeAdapterFromEnv();
+            if (a) {
+                console.log(`[PiAgent] 推理适配器 = ${a.providerId} (非 Pi: fetch 直连, 不 import Pi)`);
+                return a;
+            }
+            console.warn('[PiAgent] BOLLOON_NATIVE_ADAPTER=1 但没拿到 key ⇒ 回落 Pi 适配器 (不假装切换成功)');
+        }
+        // K10 ②: 先向**内核运行时**取租约 (只读 `acquire(snapshot)`) —— 超时/取消/退避/熔断/回退/记账由内核负责;
+        //   传输仍是 Pi 客户端 (端口注入) ⇒ 行为不变。取不到就**如实记**并回落 Pi 直连 (不假装走了内核)。
+        const leased = await this.kernelLeaseAdapter();
+        if (leased) {
+            console.log('[PiAgent] 推理适配器 = kernel-model-runtime (只读 acquire 租约)');
+            return leased;
+        }
+        console.warn('[PiAgent] 内核租约不可用 ⇒ 回落 Pi 直连 (如实记, 不假装走了内核)');
+        return getMinimax();
+    }
     async promptWithPivotLoop(input, config, channelId) {
-        this.currentChannelId = channelId ?? this.currentChannelId;
-        if (!this.minimaxAvailable) {
+        this.actor.state.channelId = channelId ?? this.actor.state.channelId;
+        // K9 (2026-10-02): **可用性判据必须问"当前适配器"**, 不能无条件问 Pi ——
+        //   原先这里是 `if (!this.minimaxAvailable)`, 于是"换成第二个(非 Pi)适配器"仍然被 **Pi 的可用性**卡死
+        //   (实跑现象: 适配器被选中、但 loop 一次都没跑、回复为空)。这类"隐式仍依赖 Pi"的点正是 K10 要清的。
+        if (!this.inferenceAvailable()) {
             const response = await this.handleFallback(input);
             return {
                 success: false,
@@ -1551,8 +1732,100 @@ export class PiAgentSession {
                 }
             };
         }
-        const llm = getMinimax();
-        const loopConfig = config || this.pivotLoopConfig || createDefaultPivotConfig();
+        const llm = await this.inferenceAdapter(); // K10 ②: 可能要向内核运行时取租约 (异步)
+        // K4-B (2026-10-02): **每次模型调用也要过门面** —— `beforeModelCall`/`afterModelCall` 原先**只**由老
+        //   `runReActLoop` 调用; 老 loop 删除后全仓零调用者, 而 pivot (生产: web/CLI 现在都走它) **从来没调过**
+        //   ⇒ 模型调用的前后留痕一直是断的。这里把门面包在 `llm` **外面** ⇒ pivot 内部一行不用改。
+        //   ⚠️ 踩过的坑 (2026-10-02, 当场复现): 一开始把 `llm` 换成**纯函数**包一层 ⇒ 第 1 轮就空回复。
+        //     原因: pivot 调的是 **`llm.chat(...)`** (对象方法), 不是 `llm(...)` ⇒ 换掉对象等于把 `.chat` 抹了。
+        //     正确做法: 以**原型继承**造一个代理对象, 只覆写 `chat`, 其余成员照旧从原型上取。
+        const llmWithHarness = Object.create(llm);
+        llmWithHarness.chat = async (...args) => {
+            try {
+                this.piHarness().beforeModelCall(this.harnessCtx());
+            }
+            catch { /* 门面异常不改变模型调用本身 */ }
+            const __modelT0 = Date.now();
+            try {
+                return await llm.chat(...args);
+            }
+            finally {
+                try {
+                    this.piHarness().afterModelCall(this.harnessCtx(), { ms: Date.now() - __modelT0 });
+                }
+                catch { /* 同上 */ }
+            }
+        };
+        const baseConfig = config || this.pivotLoopConfig || createDefaultPivotConfig();
+        // 2026-10-02 (K7 第二步 b): pivot loop 的工具执行**必须与主路径同一个门**。
+        //   接线前: pivot loop 在 workflow-pivot-loop.ts:613 直调 tool.execute —— 那条路径上
+        //   没有任何 harness 调用 (K7 台账里的**真旁路** ①); 主路径则在 runReActLoop 内先过
+        //   `beforeToolCall` (顺序: deny → pre-tool-validator(4 步链) → react-harness(8-gate))。
+        //   这里把同一个判定包成端口注入 ⇒ 两处执行共用一扇门。
+        //   **fail-closed**: 门面抛错 ⇒ 拒绝执行 (绝不回落成直调; 旧实现有过两条 fail-open 路径)。
+        const loopConfig = {
+            ...baseConfig,
+            guardedExecute: async (tool, args) => {
+                let decision;
+                try {
+                    decision = await this.piHarness().beforeToolCall({
+                        tool: tool.name,
+                        args,
+                        ctx: this.harnessCtx(),
+                        permissionMode: this.currentPermissionMode,
+                    });
+                }
+                catch (err) {
+                    return {
+                        success: false,
+                        error: `拒绝: [harness-error] Harness 门面异常: ${String(err?.message || err).slice(0, 150)}`,
+                    };
+                }
+                if (!decision.allow) {
+                    return {
+                        success: false,
+                        error: `拒绝: [${decision.rejectedBy || decision.source || 'unknown'}] ${decision.reason}`,
+                    };
+                }
+                // K4-B (2026-10-02): **改过 TS 就记账** —— 这笔账原先只记在**老 loop 的工具分发**里,
+                //   pivot 路径没有 ⇒ 默认切 pivot 后 pivot 里编辑了 TS 却不记账 ⇒ 收尾自检永远不触发
+                //   (与"自检只挂在老 loop"同族的缺陷: 同一件事只在一套 loop 里实现)。
+                //   补在 pivot 的**唯一执行点**上 ⇒ 两条 loop 口径一致。
+                {
+                    const tsFile = codeWriteTarget(tool.name, args);
+                    if (tsFile && !this.tsTouchedThisTurn.includes(tsFile))
+                        this.tsTouchedThisTurn.push(tsFile);
+                }
+                const execResult = await tool.execute(args);
+                // K4-B (2026-10-02): **工具执行后的门面阶段必须跟上** —— `afterToolCall` (输出门:
+                //   敏感信息拦截 / router hint) 原先**只**在老 `runReActLoop` 的工具分发里调用;
+                //   老 loop 删除后生产里**一个调用者都没有** ⇒ 输出门形同停用 (安全回归)。补在 pivot 的唯一执行点上。
+                //   门面内部对"gate 自己失败"的策略是**放行但留痕** (输出已产生, 拦不住源头) ⇒ 这里同样不改写结论。
+                try {
+                    const after = await this.piHarness().afterToolCall({
+                        tool: tool.name,
+                        output: String(execResult?.output ?? ''),
+                        ctx: this.harnessCtx(),
+                        ok: execResult?.success !== false,
+                    });
+                    if (after?.outputBlocked) {
+                        // API 契约: "输出被 gate 拦下 ⇒ 调用方要把 result.output 换掉"
+                        const blocked = `[输出已被门拦下: ${after.outputBlocked.reason}] (原始输出未交付)`;
+                        if (execResult && typeof execResult === 'object')
+                            execResult.output = blocked;
+                    }
+                    if (after?.routeHint?.systemAddition) {
+                        // 差量如实记: 老 loop 把它拼进**下一轮的 system prompt**; pivot 没有对应的注入端口,
+                        //   这里改拼进**工具结果文本** —— 模型同样能在下一步看到 (送达渠道不同, 效果等价)。
+                        const hint = `\n[路由提示] ${after.routeHint.systemAddition}`;
+                        if (execResult && typeof execResult === 'object')
+                            execResult.output = String(execResult.output ?? '') + hint;
+                    }
+                }
+                catch { /* 后置阶段失败不改变已做出的执行 (门面内部已按策略留痕) */ }
+                return execResult;
+            },
+        };
         const loop = new WorkflowPivotLoop(loopConfig);
         for (const tool of this.tools.values()) {
             loop.registerTool(tool);
@@ -1562,8 +1835,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 +1883,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 +1910,37 @@ ${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);
+        // K4-B (2026-10-02): **run 生命周期也要过门面** —— `sessionStart`/`sessionEnd` 原先只由老
+        //   `runReActLoop` 调用 (删除后全仓零调用者), 而 pivot (生产) 从来没调过 ⇒ 这里恢复。
+        await this.piHarness().sessionStart(this.harnessCtx());
+        let result;
+        try {
+            result = await loop.execute(input, llmWithHarness, systemPrompt + historyBlock, this.runCtx.eventSink ?? undefined, this.runCtx.abortSignal ?? undefined, onCompact);
+        }
+        finally {
+            try {
+                await this.piHarness().sessionEnd(this.harnessCtx());
+            }
+            catch { /* 收尾留痕失败不改变本次结论 */ }
+        }
+        // K4-B (2026-10-02): `reviewFinal` (收尾目标对齐审查) 原先同样只在老 loop 里调 ⇒ 恢复**调用与留痕**。
+        //   ⚠️ 如实记边界: pivot 的收尾仍由它自己的质量判定决定, 这里**不**按 review 的返回改流程
+        //   (老 loop 会据它自动续跑一轮); 且这里给的是 pivot 手上**真有的**数据 (工具调用计数),
+        //   `completedTools`/`actionLog` 的逐条清单 pivot 侧目前没有 ⇒ 传空并留 TODO, **不编数据**。
+        try {
+            const reviewDecision = this.piHarness().reviewFinal({
+                reviewsDone: 0,
+                userIntent: this.currentUserInput,
+                completedTools: [],
+                actionLog: [],
+                runId: this.actor.state.activeRun || undefined,
+                goalId: this.actor.state.goalBinding || undefined,
+            });
+            console.log(`[PiAgent] reviewFinal (K4-B 恢复调用, 判定不参与流程): ${JSON.stringify(reviewDecision).slice(0, 160)}`);
+        }
+        catch { /* 审查异常不改变本次结论 (门面内部对"审查失效"自有留痕策略) */ }
         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 +1956,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,32 +1981,47 @@ ${await this.renderActivePlansSection()}
     }
     /** CLI / Web 注入"当前目标" (有 goalId 就在该 Goal 下执行) */
     setGoalId(goalId) {
-        this.currentGoalId = String(goalId || '');
+        this.actor.state.goalBinding = String(goalId || '');
     }
-    /** 核心状态迁移的兜底: 失败 → 记降级 + 交给循环顶部的持久化硬闸 (不吞错) */
+    /**
+     * K10 ①: 控制面的**注入面** —— 写原语来自 run-store, 但调用一律经 `submitRunControl`
+     *   (与 `transportPorts()` 同一个模式: 换实现只改这一处, 上层不直接对 store 说话)。
+     */
+    runControlPorts() {
+        return {
+            setRunStatus: setRunStatus,
+            recordRecovery: recordRecovery,
+        };
+    }
+    /**
+     * 核心状态迁移的兜底: 失败 → 记降级 + 交给循环顶部的持久化硬闸 (不吞错)。
+     * K10 ①: 迁移动作经内核控制面; **口径不变** ——
+     *   `{ok:false}` 且原因是"端口拒绝"(状态迁移不合法) ⇒ 只返回 false (那不是持久化故障);
+     *   未注入 / 抛错 ⇒ 才算持久化失败, 记降级 (与旧实现同款)。
+     */
     async safeSetRunStatus(runId, to) {
-        try {
-            const r = await setRunStatus(runId, to);
-            return !!r.ok;
-        }
-        catch (err) {
-            this.persistenceFailure = `状态迁移失败 (${to}): ${String(err?.message || err).slice(0, 180)}`;
+        const out = await submitRunControl({ kind: 'set-run-status', origin: 'pi-session', runId, payload: { status: to } }, this.runControlPorts());
+        if (out.ok)
+            return true;
+        const detail = String(out.detail || '未知原因');
+        if (!detail.startsWith('端口拒绝')) {
+            this.persistenceFailure = `状态迁移失败 (${to}): ${detail.slice(0, 180)}`;
             await recordDegradation({ kind: 'core', op: 'pi-sdk.setRunStatus', runId, message: this.persistenceFailure }).catch(() => { });
-            return false;
         }
+        return false;
     }
     /**
      * 2026-09-16 (M3): 工具失败接线 —— 分类 → recovery 留痕 → 熔断 / 外部等待。
      * 这是"错误恢复闭环"的运行时接线点 (此前 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 +2032,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 +2041,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 +2064,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 +2135,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 } : {}) };
@@ -1827,6 +2145,27 @@ ${await this.renderActivePlansSection()}
             this.resumePlan = null;
         }
     }
+    /**
+     * 2026-10-02 (K7): 把**本会话的 Harness 判定**包成 skill 门, 供 `BollharnessIntegration.setSkillGuard` 注入。
+     * - 只返回**判定**, 不执行 skill ⇒ "允许后执行"留在 SkillAdapter 的**唯一**执行点 (恰一次)。
+     * - 身份 (runId/goalId/agentId/channelId/surface) 由 `harnessCtx()` 带齐。
+     * - 不在这里 catch: 门面抛错由 adapter 侧 **fail-closed** 处理 (拒执行, 绝不回落 registry)。
+     */
+    createSkillGuard() {
+        return async (name, params) => {
+            const decision = await this.piHarness().beforeToolCall({
+                tool: `skill:${name}`,
+                args: params,
+                ctx: this.harnessCtx(),
+                permissionMode: this.currentPermissionMode,
+            });
+            return {
+                allow: decision.allow,
+                reason: decision.reason,
+                rejectedBy: decision.rejectedBy || decision.source,
+            };
+        };
+    }
     piHarness() {
         if (!this._harness) {
             this._harness = new PiAgentHarness({
@@ -1836,8 +2175,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,1134 +2184,69 @@ ${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,
         };
     }
-    async runReActLoop(onStream, signal) {
-        const llm = getMinimax();
-        let iteration = 0;
-        let finalResponse = '';
-        let lastQualityScore = 0;
-        let refineAttempts = 0;
-        let consecutiveErrors = 0;
-        // 2026-06-16 新增: 累计错误数 (跨工具, 兜底防 LLM 轮换工具名死循环)
-        let totalErrors = 0;
-        let lastFailedTool = ''; // 跟踪最近一次失败的 tool name
-        let lastFailedToolCount = 0; // 最近失败工具的连续失败次数
-        // 2026-06-16: AI sentinel 标志 — runReActLoop 返回 aiFailed=true,
-        //   promptStream 据此自动重跑整个 loop 最多 N 次 (不是单次 LLM 重试)
-        let aiFailed = false;
-        let aiFailureReason = '';
-        const MAX_CONSECUTIVE_ERRORS = 3;
-        // 同一工具连续失败 3 次, 强制让 LLM 给出最终答案 (模块级常量 MAX_SAME_TOOL_FAILURES 也用它做熔断)
-        // 2026-07-29: Hermes 风格硬限制 — 防死循环 (不再靠 soft hint)
-        const MAX_IDEMPOTENT_TOOL = 5; // 同工具成功调 5 次 → 注入 hint 强制 final gen
-        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;
-        // 2026-08-10: 工具失败时的终端逃生引导 (shell_exec 白名单命令可诊断环境/推进任务)
-        const SHELL_ESCAPE_HINT = ' [逃生] 若工具无法响应/报错, 可用 shell_exec 跑终端命令诊断 (白名单: ls/cat/head/tail/pwd/git status/npm run test 等), 或调整参数换一种方式完成; 不要重复调用同一失败工具.';
-        // 2026-08-08: final 前 review 续跑 — 目标对齐 + 需求深挖 (见 loop-review.ts)
-        //   不潦草收尾: LLM 想 <final gen> 时先跑 1-2 次 review, 达成用户需求才放行.
-        //   上限=2 次 (用户要求"运行一两次"), 结束后按用户需求为准.
-        let loopReviewCount = 0;
-        const loopReviewCompletedTools = new Set();
-        // 2026-08-09: 本轮行动日志 — 每轮工具执行都记录 (args + 结果摘要),
-        //   final 前 review 用逐条核查目标; 也注入 system prompt 让 LLM 看到连续进度
-        //   (防"每轮都像重启" — 之前 LLM 看不到自己已完成什么, 容易重复 react)
-        const loopActionLog = [];
-        // 发送循环开始的事件
-        if (onStream) {
-            onStream({ type: 'status', internal: true, content: '🔄 开始 ReAct 循环...', tool: 'system' });
-        }
-        // React Harness: 循环开始 (重置 turn 计数 + 触发 harness sessionStart)
-        // 失败静默 (fail-open), 不阻塞主循环
-        // 2026-09-16 (Milestone 1-B): 会话开启走唯一门面 (react-harness 8-gate 复位 + hooks onLoopStart)
-        await this.piHarness().sessionStart(this.harnessCtx());
-        // 2026-09-16: 持久化 run harness — 本次运行立即落盘 (~/.bolloon/runs/<id>.json)。
-        //   之后每步工具调用都追加一条, 所以刷新页面/进程重载/崩溃都能看到"做到哪一步"。
-        let runStopReason = '';
-        // 2026-09-16 (Milestone 1): 持久化硬约束 —— 核心 run 状态写不进去时, 运行必须停。
-        //   理由: "agent 实际跑了但没记录" 比 "agent 没跑" 更危险 (UI 显示旧状态/重启后无从知晓/结果可能被错标 done)。
-        let runPersistenceFailure = '';
-        /** 2026-09-16 (M3): 熔断/需要人处置 → 收尾落 needs_human (不是 done, 也不是普通 failed) */
-        let runNeedsHuman = '';
-        /** 2026-09-16 (M5): 外部 (CLI/Web) 把 run 改成 paused/aborted → 如实停, 不再覆盖它的状态 */
-        let runExternallyPaused = false;
-        let runExternallyAborted = false;
-        this.runPersistenceBlocked = false;
-        this.breakerReason = '';
-        this.awaitingExternal = false;
-        if (this.resumeRunId) {
-            // ── 恢复模式: 复用原来的 runId, 不新建 run (历史保留) ──
-            this.currentRunId = this.resumeRunId;
-            this.lastRunId = this.resumeRunId;
+    /**
+     * 回合收尾的**受门类型自检** (K7 → K4-B 抽成方法)。
+     *
+     * 为什么必须抽出来: 它原先**只写在老 `runReActLoop` 之后** —— 而生产里 web 走的是 pivot 路径
+     * (`usePivotLoop: true`, `promptWithPivotLoop` 提前 return) ⇒ 这条"系统自检过门"在**生产根本没触发过**。
+     * 抽成方法后两条 loop 路径都调它 (一次一轮, 由 `typecheckRanThisTurn` 保证)。
+     */
+    async runTurnEndTypecheck() {
+        // 2026-10-01: **本回合改过 TS ⇒ 收尾自动类型检查** (一轮一次) —— 复用已有的 tsc_check 工具
+        if (decideTypecheck(this.tsTouchedThisTurn, this.typecheckRanThisTurn)) {
+            this.typecheckRanThisTurn = true;
             try {
-                await markRunRunning(this.currentRunId);
-            }
-            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' });
-        }
-        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;
-            if (!boundGoalId) {
-                try {
-                    const active = await findActiveGoal({ channelId: this.currentChannelId || undefined, agentId: this.currentAgentId || undefined });
-                    if (active?.currentRunId) {
-                        const prev = await readRun(active.currentRunId);
-                        const unfinished = prev && ['interrupted', 'stalled', 'needs_human', 'paused', 'awaiting_external', 'recovering'].includes(prev.status);
-                        if (unfinished)
-                            boundGoalId = active.goalId;
-                    }
-                }
-                catch (err) {
-                    console.warn('[PiAgent] 查找进行中 Goal 失败 (按新建处理):', err?.message);
-                }
-                if (!boundGoalId) {
+                const tscTool = this.tools.get('tsc_check');
+                if (tscTool?.execute) {
+                    // 2026-10-02 (K7): **系统自检也过门** —— 统一成"任何工具执行都走同一扇 Harness 门"。
+                    //   这里不是模型发起的工具调用 (args 恒空, 是本回合改过 TS 后的收尾自检), 所以**更**不能例外:
+                    //   例外一旦靠"没人知道它绕过"活着, 门就不再是唯一的执行咽喉。
+                    //   语义: 被拒或门抛错 ⇒ **不执行** (fail-closed), 且**可见**地报出来 (拒绝不许静默)。
+                    let tscAllowed = true;
+                    let tscWhy = '';
                     try {
-                        const g = await createGoal({
-                            objective: this.currentUserInput || '(未记录目标)',
-                            channelId: this.currentChannelId || undefined,
-                            agentId: this.currentAgentId || undefined,
-                            createdBy: this.runSurface,
-                        });
-                        boundGoalId = g.goalId;
-                    }
-                    catch (err) {
-                        console.warn('[PiAgent] 创建 Goal 失败 (无目标也要有运行记录):', err?.message);
-                    }
-                }
-                this.currentGoalId = boundGoalId;
-            }
-            try {
-                const rec = await startRun({
-                    surface: this.runSurface,
-                    goal: this.currentUserInput || '(未记录目标)',
-                    goalId: boundGoalId || undefined,
-                    channelId: this.currentChannelId || undefined,
-                    agentId: this.currentAgentId || undefined,
-                    modelConfig: await this.runModelSnapshot(),
-                });
-                this.currentRunId = rec.runId;
-                this.lastRunId = rec.runId;
-                this.currentGoalId = rec.goalId || this.currentGoalId;
-                if (this.currentGoalId) {
-                    // Run → Goal 反查链: runId → goalId → objective / success criteria
-                    await attachRun(this.currentGoalId, 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' });
-            }
-            catch (err) {
-                // 核心写失败: 不再 warn 后继续 —— 没有运行记录就不执行 (strict 模式默认如此)
-                runPersistenceFailure = `无法创建运行记录: ${String(err?.message || err).slice(0, 200)}`;
-                this.runPersistenceBlocked = true;
-                console.error('[PiAgent] run-store startRun 失败 (核心持久化) → 拒绝无记录执行:', runPersistenceFailure);
-                onStream?.({ type: 'error', content: `⛔ ${runPersistenceFailure} — 已停止 (不在没有记录的情况下执行)`, tool: 'harness' });
-            }
-        }
-        while (iteration < this.MAX_REACT_ITERATIONS) {
-            iteration++;
-            // 2026-09-16 (Milestone 1): 持久化失败硬闸 —— 到这一层说明记录已经不可信, 继续跑就是"无约束执行"
-            if (runPersistenceFailure || this.persistenceFailure) {
-                runPersistenceFailure = runPersistenceFailure || this.persistenceFailure;
-                this.runPersistenceBlocked = true;
-                aiFailed = true;
-                aiFailureReason = aiFailureReason || runPersistenceFailure;
-                finalResponse = finalResponse || `❌ 运行已停止: ${runPersistenceFailure}\n\n(运行记录无法写入/校验, 按协议停在 needs_human, 不假装完成)`;
-                break;
-            }
-            // 2026-09-16 (M3): 熔断硬闸 —— 同一工具连续失败达上限后, 不许再"自动重试成功"式地把运行放活
-            if (this.breakerReason) {
-                runNeedsHuman = this.breakerReason;
-                aiFailed = true;
-                aiFailureReason = aiFailureReason || this.breakerReason;
-                finalResponse = finalResponse || `❌ 已熔断: ${this.breakerReason}\n\n(重复失败不再重试, 按协议停在 needs_human 交人处置)`;
-                break;
-            }
-            // 2026-09-16: 预算闸门 (持久化 harness 的约束面) —— 到点必须**如实**终止, 不许静默算完成
-            if (this.currentRunId) {
-                try {
-                    const rec = await readRun(this.currentRunId);
-                    if (!rec)
-                        throw new Error(`运行记录读不到: ${this.currentRunId}`);
-                    // 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' });
-                        finalResponse = finalResponse || `(运行已${rec.status === 'paused' ? '暂停' : '中止'})`;
-                        break;
-                    }
-                    const verdict = budgetVerdict(rec);
-                    if (verdict.exceeded) {
-                        runStopReason = verdict.reason || '运行预算用尽';
-                        onStream?.({ type: 'error', content: `⛔ 运行预算用尽: ${runStopReason} (已如实终止, 不假装完成)`, tool: 'harness' });
-                        finalResponse = finalResponse || `(运行预算用尽: ${runStopReason})`;
-                        break;
-                    }
-                }
-                catch (err) {
-                    // 预算闸门读不到状态 = 约束失效, 不能"当作没超预算"继续跑
-                    runPersistenceFailure = `预算闸门无法校验运行状态: ${String(err?.message || err).slice(0, 200)}`;
-                    this.runPersistenceBlocked = true;
-                    console.error('[PiAgent] run-store 预算检查失败 (核心持久化):', runPersistenceFailure);
-                    onStream?.({ type: 'error', content: `⛔ ${runPersistenceFailure} — 已停止`, tool: 'harness' });
-                    break;
-                }
-            }
-            // 停止条件 1: max turns (fail-safe 10000, 正常任务永远跑不到)
-            //   2026-07-01 (v0.2.4 子任务 1): 委托给 react-loop.decideMaxIterations 纯函数
-            // 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' });
-                finalResponse = finalResponse || maxIterDecision.finalAnswer;
-                break;
-            }
-            // 停止条件 2: signal.aborted (显式 abort / 用户中断)
-            if (signal?.aborted) {
-                console.warn('[PiAgent] runReActLoop aborted by signal');
-                onStream?.({ type: 'error', content: '⏹️ 用户中断', tool: 'loop' });
-                finalResponse = finalResponse || '(用户中断)';
-                break;
-            }
-            // 2026-07-29: Hermes 风格硬限制 (idempotent tool / total call cap)
-            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> 标记结束。` });
-                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> 标记结束。` });
-                lastNTools.length = 0; // 重置计数器
-                // 不 break — 让 LLM 在下一轮用已有信息回答
-            }
-            // 2026-06-16 新增: 累计错误兜底 — 跨工具, 防 LLM 轮换工具名绕过 MAX_SAME_TOOL_FAILURES
-            if (totalErrors >= this.MAX_TOTAL_ERRORS) {
-                console.warn(`[PiAgent] 累计错误 ${totalErrors} >= ${this.MAX_TOTAL_ERRORS}, 强制终止 (防死循环)`);
-                onStream?.({ type: 'error', content: `⛔ 累计 ${totalErrors} 次错误, 强制终止 (防止 LLM 死循环)`, tool: 'loop' });
-                // 2026-06-19: 即使 LLM 一直失败, 也汇总之前成功执行的 tool result 给用户
-                if (this.successfulToolResults.length > 0) {
-                    finalResponse = `✅ 之前步骤成功执行了 ${this.successfulToolResults.length} 个工具 (但 LLM 后续 ${totalErrors} 次调用失败):\n` +
-                        this.successfulToolResults.map((r, i) => `  ${i + 1}. ${r.tool}: ${r.outputPreview}`).join('\n') +
-                        `\n\n⚠️ (LLM 连续失败, 可能是上游限流/网络问题, 工具已成功执行但 LLM 没能继续总结)`;
-                }
-                else {
-                    finalResponse = finalResponse || `(本轮 ReAct 循环累计 ${totalErrors} 次错误, 强制结束。请换个思路或简化任务重试。)`;
-                }
-                break;
-            }
-            // 2026-06-16 新增: loop 内自动压缩 — token 超 80% 阈值时跑一次
-            // compact 失败走 C 路径: 不强行 break, 让现有 60K 阈值兜底 (后面有检查)
-            //   2026-07-01 (v0.2.4 子任务 1): 触发判定走 shouldCompactBeforeIteration 纯函数
-            const compactThreshold = this.maxContextTokens() * this.LOOP_COMPACT_RATIO;
-            const estimatedTokensBefore = this.estimateHistoryTokens();
-            // 2026-08-06: 每轮上报 usage 到 ContextManager (CLI/Web 状态栏数据源, warning 事件触发点)
-            getContextManager().updateUsage(estimatedTokensBefore);
-            if (shouldCompactBeforeIteration(estimatedTokensBefore, compactThreshold)) {
-                const tokensBeforeCompact = estimatedTokensBefore;
-                console.log(`[PiAgent] loop 入口 token ${tokensBeforeCompact} > ${compactThreshold}, 触发自动压缩`);
-                onStream?.({ type: 'status', internal: true, content: `🗜️ loop 自动压缩 (token ${tokensBeforeCompact} > ${compactThreshold})`, tool: 'compactor' });
-                try {
-                    await this.maybeAutoCompact(onStream, signal);
-                }
-                catch (compactErr) {
-                    // C 路径: compact 失败不 break, 让 token 阈值检查兜底
-                    console.warn(`[PiAgent] loop 内 maybeAutoCompact 失败 (non-fatal, 继续走 token 阈值):`, compactErr);
-                }
-            }
-            // 停止条件 3: context overflow (compact 后还超, 强制终止)
-            //   2026-07-01 (v0.2.4 子任务 1): 委托给 react-loop.decideContextOverflow 纯函数
-            const estimatedTokens = this.estimateHistoryTokens();
-            const overflowDecision = decideContextOverflow(estimatedTokens, this.maxContextTokens());
-            if (overflowDecision.shouldExit) {
-                console.warn(`[PiAgent] context overflow (${estimatedTokens} tokens > ${this.maxContextTokens()})`);
-                onStream?.({ type: 'error', content: `⏹️ 上下文溢出 (${estimatedTokens} tokens, 阈值 ${this.maxContextTokens()})`, tool: 'loop' });
-                finalResponse = finalResponse || overflowDecision.finalAnswer;
-                break;
-            }
-            // 调试日志：显示每次循环开始
-            console.log(`[PiAgent] 循环 ${iteration}/${this.MAX_REACT_ITERATIONS} 开始`);
-            if (onStream) {
-                onStream({ type: 'status', internal: true, content: `🔄 循环 ${iteration}/${this.MAX_REACT_ITERATIONS}`, tool: 'loop' });
-            }
-            const context = this.buildContext();
-            // M3.5 (2026-06-17): 也构造 messages 数组版本, 让 LLM 看到结构化 tool 角色
-            //   buildContext() 把 history 序列化成字符串 — LLM 看不到 tool 调用的真实结果
-            //   新版用 messages 数组直接喂给 LLM, 保留 role 语义 (user/assistant/tool/system)
-            const messages = this.buildMessages();
-            const toolDefs = this.getToolDefinitions();
-            // 动态构建 refine 上下文
-            let refineContext = '';
-            if (refineAttempts > 0 && lastQualityScore < this.QUALITY_THRESHOLD) {
-                refineContext = `\n【改进提示】上轮结果质量分 ${(lastQualityScore * 10).toFixed(1)}/10，请改进回答。`;
-            }
-            // 连续错误时的额外提示
-            if (consecutiveErrors > 0) {
-                refineContext += `\n【错误提示】上轮发生 ${consecutiveErrors} 次错误，请重新分析问题或换一种方式处理。`;
-            }
-            // M2.4: persona section 缓存 — persona 在 loadPersona() 时一次设定, 此后不变
-            if (!this.cachedPersonaSection && this.persona) {
-                this.cachedPersonaSection = `
-角色描述: ${this.persona.description || '无'}
-性格特点: ${this.persona.personality || '无'}
-问候语: ${this.persona.greeting || '无'}
-`;
-            }
-            const personaSection = this.cachedPersonaSection;
-            // 2026-08-09: 循环进度段 — 让 LLM 看到本轮已完成的动作 (连续进度, 不重启)
-            //   Hermes 式 Agent Runtime: 循环是状态机, LLM 每次看到的是"第 N 步 + 已完成 X"
-            //   (之前每轮都是全新上下文, LLM 不知道做过什么 → 重复 react / 衔接差)
-            let loopProgressSection = '';
-            if (loopActionLog.length > 0) {
-                const actionLines = loopActionLog
-                    .map((a, i) => {
-                    const args = a.argsPreview ? `(${a.argsPreview.slice(0, 60)})` : '';
-                    const res = a.success ? '✓' : '✗';
-                    return `  ${i + 1}. ${res} ${a.tool}${args}`;
-                })
-                    .join('\n');
-                loopProgressSection = `\n【本轮循环进度】你已完成以下 ${loopActionLog.length} 个动作, 这是连续执行的同一轮任务:\n${actionLines}\n请基于已有结果继续推进, 不要重复执行上面已成功的动作. 全部完成后用 <final gen> 结束.\n`;
-            }
-            // 2026-09-28 (前缀 KV 可命中): `refineContext` / `loopProgressSection` 是**每轮都在变**的段
-            //   (质量分 / 连续错误数 / 本轮已完成动作). 留在 system 里 = 每轮把 IMMUTABLE PREFIX 打碎 =
-            //   服务端前缀 KV 永远 miss. 移到 CURRENT TURN 区 (注入到最后一条 user 前部) —— 文本一字未改, 只换位置.
-            const currentTurnContext = `${refineContext}${loopProgressSection}`;
-            const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
-当前工作目录: ${this.cwd}
-当前身份: ${this.identity.name} (${this.identity.did})
-${this.currentIntentHint}
-
-${toolDefs}
-
-${PiAgentSession.TOOL_SELECTION_GUIDE}
-
-${PROACTIVE_WORK_DISCIPLINE}
-
-${await this.renderActivePlansSection()}
-
-工作模式:
-1. 理解用户自然语言请求
-2. 分析需要哪些工具来完成
-3. 按顺序调用工具并观察结果
-4. 根据观察结果决定下一步
-5. 最终给出完整回答
-
-重要:
-- 每次只调用一个工具
-- 仔细分析工具返回结果
-- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
-- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}${this.contextHintAddition}`;
-            // 3 个恢复机制 (Claude Code 论文 9-step pipeline 内部):
-            //   1. max output token 升级 (最多 3 次, 每次 maxOutputTokens 翻倍)
-            //   2. reactive compaction (prompt 估算超阈值, 跑压缩)
-            //   3. prompt-too-long (LLM 报错 4xxx token 错误, 跑 reactive compaction 再试 1 次)
-            // 失败静默: 全部重试失败 → 空 reply (上层用 no tool_use 终止)
-            // Bug 5: pass tool IDs for native OpenAI tool calling — 2026-07-29: 过滤拒绝工具
-            const toolIds = Array.from(this.tools.keys()).filter(n => !this._deniedToolNames.has(n));
-            // 2026-07-29: 从 this.tools Map 生成 OpenAI 原生 tools 格式 (含参数 schema)
-            const openaiFormattedTools = [];
-            for (const [name, tool] of this.tools) {
-                if (this._deniedToolNames.has(name))
-                    continue;
-                const params = tool.parameters || {};
-                const properties = {};
-                const required = [];
-                for (const [pName, pDesc] of Object.entries(params)) {
-                    properties[pName] = { type: 'string', description: String(pDesc) };
-                    if (String(pDesc).includes('必填'))
-                        required.push(pName);
-                }
-                openaiFormattedTools.push({
-                    type: 'function',
-                    function: {
-                        name,
-                        description: tool.description || name,
-                        parameters: { type: 'object', properties, required },
-                    },
-                });
-            }
-            // 2026-09-16 (Milestone 1-B): 模型调用前后走唯一门面 (扩展点 + 计数留痕; 默认不加新 hook 事件, 避免改变现有触发次数)
-            this.piHarness().beforeModelCall(this.harnessCtx());
-            const _modelCallT0 = Date.now();
-            const response = await this.callLlmWithRecovery(llm, messages, systemPrompt, signal, onStream, openaiFormattedTools, currentTurnContext);
-            // 2026-09-28 (前缀 KV 可命中): 把注入了 CURRENT TURN 的当前轮**原样写回自己的 messageHistory** ——
-            //   buildMessages() 每轮重建全新对象, 不写回的话下一轮那条 user 就退回注入前, 前缀从那里分叉.
-            //   用 chat() 回带的 wire (真正发出去的那一份), 而不是把 messages 再拼一遍.
-            this.writeBackCurrentTurn(response.messages);
-            this.piHarness().afterModelCall(this.harnessCtx(), { ms: Date.now() - _modelCallT0 });
-            const reply = (response.reply || '').trim();
-            // 2026-06-30: OpenAI 协议 native tool_calls (LLM 真产了 tool_call 时, minimax/M3 会返回 id)
-            const nativeToolCalls = response.toolCalls;
-            // 2026-06-19 架构 fix: 不再因 [AI 服务调用失败] break
-            //   旧逻辑: sentinel → aiFailed=true → break → 外层 retry 整个 loop (重置 history)
-            //   新逻辑: 把错误当 tool_result push 进 history → 下一轮 LLM 看到错误能反思重试
-            //   这是 dive-into 文档的"fail-open error recovery" — 错误进入 context, 不让 LLM 重复犯同样错
-            // 2026-07-06: 对不可恢复的 API 错误直接终止, 不再无限重试
-            if (reply.startsWith('[AI 服务调用失败]')) {
-                console.log(`[PiAgent] 收到 AI 错误 sentinel`);
-                console.log(`[sentinel DEBUG] 完整 reply: ${reply}`);
-                console.log(`[sentinel DEBUG] 上一轮 messages 数量: ${Array.isArray(messages) ? messages.length : 'N/A'}, systemPrompt 长度: ${systemPrompt.length}`);
-                aiFailureReason = reply.length > 200 ? reply.substring(0, 200) : reply;
-                totalErrors++;
-                consecutiveErrors++;
-                // 2026-07-06: 检测不可恢复的 API 错误 — 这些错误 LLM 无法通过反思修复, 重试无意义
-                const isFatalApiError = reply.includes('chat content is empty') ||
-                    reply.includes('invalid params') ||
-                    reply.includes('401') ||
-                    reply.includes('403') ||
-                    reply.includes('quota') ||
-                    reply.includes('rate limit') ||
-                    reply.includes('API key') ||
-                    reply.includes('authentication') ||
-                    reply.includes('unauthorized');
-                if (isFatalApiError) {
-                    console.log(`[PiAgent] 检测到不可恢复的 API 错误, 终止 loop: ${aiFailureReason}`);
-                    if (onStream) {
-                        onStream({ type: 'error', content: `⛔ API 错误无法恢复: ${aiFailureReason}`, tool: 'system' });
-                    }
-                    finalResponse = `❌ AI 服务调用失败: ${aiFailureReason}\n\n这是一个底层 API 错误, 不是任务本身的问题。请检查 API 配置或稍后重试。`;
-                    aiFailed = true;
-                    break;
-                }
-                // 连续错误过多也终止, 防止 LLM 陷入死循环
-                if (consecutiveErrors >= 3) {
-                    console.log(`[PiAgent] 连续 ${consecutiveErrors} 次 AI 错误, 终止 loop`);
-                    if (onStream) {
-                        onStream({ type: 'error', content: `⛔ 连续 ${consecutiveErrors} 次 AI 错误, 终止循环`, tool: 'system' });
-                    }
-                    finalResponse = `❌ AI 连续调用失败 ${consecutiveErrors} 次, 已终止。\n\n失败原因: ${aiFailureReason}\n\n请检查 API 配置或简化任务后重试。`;
-                    aiFailed = true;
-                    break;
-                }
-                // 把错误当成 tool 结果 push 进 history, 这样下一轮 LLM 看到错误能调整
-                this.messageHistory.push({
-                    role: 'system',
-                    content: `[Loop 错误恢复 ${totalErrors}/${this.MAX_TOTAL_ERRORS}] ${aiFailureReason}\n\n请基于上轮工具结果继续完成任务, 不要重复调用同一失败操作. 如果工具已成功执行, 请基于 result.output 给用户总结; 如果工具失败, 请换其他方式或重试.`
-                });
-                if (onStream) {
-                    onStream({ type: 'status', content: `⚠️ AI 调用失败 ${totalErrors}/${this.MAX_TOTAL_ERRORS}, 已 push 错误到 history 让 LLM 反思`, tool: 'system' });
-                }
-                // 退避 2s 后继续 — 临时上游限流避开, 不让 loop 终止
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                // 关键: 不设 aiFailed=true, 让外层不重试整个 loop (重置 history), 继续内层循环
-                continue;
-            }
-            console.log(`[PiAgent] LLM 回复长度: ${reply.length}, 内容预览: "${reply.substring(0, 80)}..."`);
-            console.log(`[PiAgent] LLM 完整回复:\n${reply}`);
-            // 通知前端：收到 LLM 回复 (2026-08-09: 不再截断 100 字符 — 前端流式渲染完整内容,
-            //   配合 Hermes 式回复框: 加载中显示完整文本, 完成后封闭底框)
-            if (onStream) {
-                onStream({ type: 'token', content: reply });
-            }
-            // 2026-06-19 架构 fix: parseToolCall 优先于 isFinalResponse
-            //   之前: 思考块里的 "<final gen>" 触发 isFinalResponse 提前 break, 工具从未真正执行
-            //   现在: 先尝试解析 tool_call, 有就执行; 没有才检查是不是真正的 final gen
-            // Bug 5 (2026-07-17): 优先用 LLM 的 native tool_calls (response.toolCalls), 再回退到文本解析
-            //   deepseek-v4-flash 用 OpenAI 协议 tools 时, 会真返回结构化 tool_calls 数组
-            //   之前 nativeToolCalls 被读了不用, 只查 reply 文本, 导致 LLM 明明选了工具但代码找不到
-            // 2026-07-28: 修复多工具调用 — 收集 ALL tool calls, 顺序执行后一次性返回
-            let toolCalls = [];
-            // 路径 A: native OpenAI 协议 tool_calls (可能多个)
-            if (nativeToolCalls && nativeToolCalls.length > 0) {
-                for (const nc of nativeToolCalls) {
-                    try {
-                        const args = typeof nc.function?.arguments === 'string'
-                            ? JSON.parse(nc.function.arguments)
-                            : (nc.function?.arguments || {});
-                        toolCalls.push({
-                            name: nc.function?.name,
-                            args,
-                            id: nc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-                        });
-                    }
-                    catch (err) {
-                        console.warn(`[PiAgent] 解析 native tool_call 失败: ${err.message?.slice(0, 100)}`);
-                    }
-                }
-            }
-            // 路径 B: 文本解析 (parseAllToolCalls 收集全部)
-            if (toolCalls.length === 0) {
-                // 2026-09-26: 已知名集合 = 注册表原名 + 它们的 API 名 (净化后的).
-                //   出网时工具面给的是 API 名 (见 pi-ai.ts 的唯一净化边界), LLM 在文本里
-                //   回吐的也可能是 API 名 —— 只用原名集合过滤会把这类调用整个丢掉.
-                const knownTools = expandKnownToolNames(this.tools.keys());
-                toolCalls = parseAllToolCalls(reply, { tools: knownTools });
-            }
-            // 回退路径 C: 原生 parseToolCall (单个)
-            if (toolCalls.length === 0) {
-                const single = this.parseToolCall(reply);
-                if (single)
-                    toolCalls.push(single);
-            }
-            // 2026-09-26: **回程派发的唯一还原点** —— LLM 回吐的是 API 名 (净化过的), 这里
-            //   还原成注册表真名再交给 this.tools.get(); 原名 (LLM 照 system prompt 抄的) 原样穿透.
-            for (const tc of toolCalls) {
-                if (typeof tc.name === 'string' && tc.name)
-                    tc.name = resolveApiToolName(tc.name);
-            }
-            // 给每个 toolCall 分配稳定 id
-            for (const tc of toolCalls) {
-                if (!tc.id) {
-                    tc.id = `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-                }
-            }
-            if (toolCalls.length > 0) {
-                // 把原始 LLM 回复 push 进 history (仅一次)
-                this.messageHistory.push({
-                    role: 'assistant',
-                    content: reply,
-                    toolCalls: toolCalls.length > 1 ? toolCalls : [toolCalls[0]],
-                    // 2026-09-15: 思考模式思维链原样存回 (下一轮带 tools 的请求必须回带, 否则 deepseek 400)
-                    reasoningContent: response?.reasoningContent,
-                });
-                // 2026-08-09: 并发执行本轮所有工具 (Hermes 式 Agent Runtime: 一轮内多工具并行,
-                //   一轮没跑完之前不中断 — 工具执行不检查 abort, 全部完成才 continue 下一轮)
-                //   旧实现顺序 for 循环, 一个工具等一个, 慢; 且多工具时 LLM 要等全部串完才能看到结果.
-                await Promise.all(toolCalls.map(async (toolCall, ti) => {
-                    const isMulti = toolCalls.length > 1;
-                    // 通知前端
-                    if (onStream) {
-                        onStream({ type: 'tool', content: `🔧 调用工具 (${ti + 1}/${toolCalls.length}): ${toolCall.name}`, tool: toolCall.name });
-                        if (toolCall.args && Object.keys(toolCall.args).length > 0) {
-                            onStream({ type: 'status', internal: true, content: `📋 参数: ${JSON.stringify(toolCall.args)}`, tool: toolCall.name });
-                        }
-                        onStream({
-                            type: 'step_start',
-                            content: `调用 ${toolCall.name}${isMulti ? ` (${ti + 1}/${toolCalls.length})` : ''}`,
-                            tool: toolCall.name,
-                            args: toolCall.args || {},
-                        });
-                    }
-                    const tool = this.tools.get(toolCall.name);
-                    if (!tool) {
-                        consecutiveErrors++;
-                        totalErrors++;
-                        const errorResult = { success: false, error: `未知工具: ${toolCall.name}` };
-                        this.messageHistory.push({ 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) });
-                        if (onStream)
-                            onStream({ type: 'status', content: `💡 Reflection: ${obs.summary}`, tool: 'system' });
-                        console.warn(`[PiAgent] 未知工具: ${toolCall.name} (累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS})，跳过并继续`);
-                        return;
-                    }
-                    // 2026-09-16 (Milestone 1-B): 工具调用前的**唯一**约束入口。
-                    //   顺序由 PiAgentHarness 决定: deny-pipeline → pre-tool-validator(4 步链) → react-harness(8-gate)。
-                    //   旧实现是这三处在不同位置各自调用 (且有两条路径 fail-open); 现在 pi-sdk 不再散调任何 gate。
-                    let toolDecision;
-                    try {
-                        toolDecision = await this.piHarness().beforeToolCall({
-                            tool: toolCall.name,
-                            args: toolCall.args || {},
+                        const d = await this.piHarness().beforeToolCall({
+                            tool: 'tsc_check',
+                            args: {},
                             ctx: this.harnessCtx(),
                             permissionMode: this.currentPermissionMode,
                         });
+                        tscAllowed = d.allow;
+                        tscWhy = d.reason || d.rejectedBy || '';
                     }
-                    catch (err) {
-                        // 门面自身抛错 = 核心约束失效 → fail-closed (不执行工具, 也不静默放行)
-                        toolDecision = {
-                            allow: false,
-                            source: 'harness-error',
-                            kind: 'core_constraint',
-                            reason: `Harness 门面异常: ${String(err?.message || err).slice(0, 150)}`,
-                        };
-                    }
-                    if (!toolDecision.allow) {
-                        const src = toolDecision.source || 'unknown';
-                        if (src === 'deny-pipeline') {
-                            // 旧 deny-pipeline 分支: 不计连续失败计数, 文案 "拒绝: [source] reason"
-                            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.logToHarness(toolCall.name, toolCall.args, denyResultMsg);
-                            return;
-                        }
-                        const isGateDeny = src === 'react-harness';
-                        const isHarnessError = src === 'harness-error';
-                        const deniedResult = {
-                            success: false,
-                            error: isGateDeny
-                                ? `Harness gate 拒绝 (${toolDecision.rejectedBy}): ${toolDecision.reason || '未通过安全校验'}`
-                                : `PreToolUse 拒绝: ${toolDecision.reason || '未通过安全校验'}`,
-                        };
-                        this.messageHistory.push({ 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');
-                            onStream({ type: 'error', content: `🛡️ ${gateName} 拒绝 ${toolCall.name}: ${toolDecision.reason || '安全校验失败'}`, tool: toolCall.name });
-                            onStream({ type: 'step_error', content: `${gateName} 拒绝 ${toolCall.name}`, tool: toolCall.name, error: toolDecision.reason || '安全校验失败' });
-                        }
-                        console.warn(`[PiAgent] 工具被拒 ${toolCall.name} (${src}${toolDecision.rejectedBy ? ':' + toolDecision.rejectedBy : ''}): ${toolDecision.reason}`);
-                        consecutiveErrors++;
-                        totalErrors++;
-                        if (toolCall.name === lastFailedTool) {
-                            lastFailedToolCount++;
-                        }
-                        else {
-                            lastFailedTool = toolCall.name;
-                            lastFailedToolCount = 1;
-                        }
-                        // 达到同一工具连续失败上限 / 连续错误上限时的引导语 (按拒绝来源保持原有文案)
-                        const systemMaxMsg = isGateDeny
-                            ? `[注意] 工具 ${toolCall.name} 被 Harness 拒绝 (连续 ${MAX_SAME_TOOL_FAILURES} 次). 请不要再次尝试, 末尾加 <final gen>.`
-                            : isHarnessError
-                                ? `[注意] 工具 ${toolCall.name} 的约束校验层失效, 已按 fail-closed 阻止 (连续 ${MAX_SAME_TOOL_FAILURES} 次). 请换其他工具或直接回答用户, 末尾加 <final gen>.`
-                                : `[注意] 工具 ${toolCall.name} 被系统拒绝 (连续 ${MAX_SAME_TOOL_FAILURES} 次). 请不要再次尝试, 直接用已有信息回答用户, 末尾加 <final gen>.`;
-                        const systemConsecMsg = isGateDeny
-                            ? `[注意] 连续 ${consecutiveErrors} 次工具调用被 Harness 拒绝. 请换其他工具或直接回答.`
-                            : isHarnessError
-                                ? `[注意] 连续 ${consecutiveErrors} 次工具调用因约束层失效被阻止. 请换其他工具或直接回答用户, 末尾加 <final gen>.`
-                                : `[注意] 连续 ${consecutiveErrors} 次工具调用被系统拒绝. 请换其他工具或直接回答用户, 末尾加 <final gen>.`;
-                        if (lastFailedToolCount >= MAX_SAME_TOOL_FAILURES) {
-                            this.messageHistory.push({ role: 'system', content: systemMaxMsg });
-                            lastFailedTool = '';
-                            lastFailedToolCount = 0;
-                            consecutiveErrors = 0;
-                        }
-                        else if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-                            this.messageHistory.push({ role: 'system', content: systemConsecMsg });
-                            consecutiveErrors = 0;
-                        }
-                        return;
-                    }
-                    if (toolDecision.systemAddition) {
-                        this.contextHintAddition += '\n' + toolDecision.systemAddition;
-                    }
-                    try {
-                        const toolStart = Date.now();
-                        // 2026-09-16 (M2): 恢复重放守卫 —— 中断前**已成功执行过的非幂等动作**恢复后不再重做,
-                        //   直接复用当时的结果 (避免重复副作用: 重复写文件/重复提交/重复付款)。
-                        //   (M2-B: 守卫也覆盖"上一个 Run 已做过的非幂等动作" —— 跨 Run 续跑同样不许重做)
-                        let replaySkip = null;
-                        const guards = [
-                            ...(this.resumePlan?.replayGuards || []),
-                            ...(this.continuationGuards || []),
-                        ];
-                        if (guards.length) {
-                            const d = argsDigestOf(toolCall.args);
-                            const hit = guards.find((g) => g.tool === toolCall.name && (!g.argsDigest || !d || g.argsDigest === d));
-                            if (hit)
-                                replaySkip = hit.summary;
-                        }
-                        let result = replaySkip
-                            ? { success: true, output: `[恢复保护] ${toolCall.name} 在中断前已成功执行过, 本次不重复执行 (避免重复副作用)。当时结果: ${replaySkip}`, _replaySkipped: true }
-                            : await (toolCall.__t0 = Date.now(), tool.execute(expandHomeArgs(toolCall.args)));
-                        const toolDurationMs = Date.now() - toolStart;
-                        if (replaySkip) {
-                            console.log(`[PiAgent] 恢复重放守卫: 跳过已完成的非幂等工具 ${toolCall.name}`);
-                            onStream?.({ type: 'status', internal: true, content: `🛡️ 恢复保护: ${toolCall.name} 此前已成功执行, 本次不重复执行`, tool: toolCall.name });
-                        }
-                        console.log(`[PiAgent] 工具 ${toolCall.name} 执行完成: success=${result.success} (${toolDurationMs}ms)`);
-                        // 2026-09-16 (M3): 失败接线 —— 分类 + recovery 留痕 + 熔断 / 外部等待
-                        if (!result.success && this.currentRunId && !replaySkip) {
-                            await this.wireToolFailure(toolCall.name, String(result.error || ''), toolCall.args);
-                        }
-                        else if (result.success && this.currentRunId && this.awaitingExternal) {
-                            // 外部回话了: awaiting_external → running (不是"恢复完成", 只是等待结束)
-                            this.awaitingExternal = false;
-                            await this.safeSetRunStatus(this.currentRunId, 'running');
-                        }
-                        // 2026-09-16: 持久化 run harness — 每步工具调用立即落盘 (崩在这里也能看到做到哪步)
-                        if (this.currentRunId) {
-                            try {
-                                await recordStep(this.currentRunId, {
-                                    tool: toolCall.name,
-                                    ok: !!result.success,
-                                    ms: toolDurationMs,
-                                    args: toolCall.args,
-                                    summary: String(result.output || '').slice(0, 200),
-                                    error: result.error ? String(result.error) : undefined,
-                                });
-                            }
-                            catch (err) {
-                                // 核心写失败 → 本轮工具批跑完即停 (循环顶部硬闸), 不再 warn 后继续
-                                runPersistenceFailure = `工具步骤写盘失败 (${toolCall.name}): ${String(err?.message || err).slice(0, 200)}`;
-                                this.runPersistenceBlocked = true;
-                                console.error('[PiAgent] run-store recordStep 失败 (核心持久化):', runPersistenceFailure);
-                                onStream?.({ type: 'error', content: `⛔ ${runPersistenceFailure} — 本轮结束后停止`, tool: 'harness' });
-                            }
-                        }
-                        try {
-                            await onPostToolUse({ tool: toolCall.name, args: toolCall.args || {}, result: { success: result.success, output: result.output?.substring(0, 500), error: result.error }, durationMs: toolDurationMs });
-                        }
-                        catch (postErr) {
-                            console.warn('[PiAgent] onPostToolUse failed (non-fatal):', postErr);
-                        }
-                        // 2026-09-16 (Milestone 1-B): 工具调用后的唯一入口 (router hint + 输出 gate 一起判定)
-                        const after = await this.piHarness().afterToolCall({
-                            tool: toolCall.name,
-                            output: String(result.output || ''),
-                            ctx: this.harnessCtx(),
-                            ok: !!result.success,
-                        });
-                        if (after.routeHint?.systemAddition) {
-                            this.messageHistory.push({ role: 'system', content: `[Harness Router Hint: ${after.routeHint.reason}]\n${after.routeHint.systemAddition}` });
-                        }
-                        if (after.outputBlocked) {
-                            if (onStream) {
-                                onStream({ type: 'error', content: `🛡️ Harness output 拒绝 ${toolCall.name}: ${after.outputBlocked.reason}`, tool: toolCall.name });
-                            }
-                            console.warn(`[PiAgent] Harness output denied ${toolCall.name}: ${after.outputBlocked.reason}`);
-                            result = { ...result, output: `[harness output gate: 输出含敏感内容, 已屏蔽. 原因: ${after.outputBlocked.reason}]`, _harnessDenied: true };
-                        }
-                        // 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.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 (用户: 「为什么这么慢」): 量到的事实 —— 每次 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.logToHarness(toolCall.name, toolCall.args, result);
-                        // 2026-08-09: 记录到本轮行动日志 (循环进度 + final 前目标核查用)
-                        //   去重: 同一工具同 args 连续成功只记一次 (防 LLM 重复 react 刷屏)
-                        const argsPreview = JSON.stringify(toolCall.args || {}).slice(0, 120);
-                        const isDup = loopActionLog.some((a) => a.tool === toolCall.name && a.argsPreview === argsPreview && a.success === !!result.success);
-                        if (!isDup) {
-                            loopActionLog.push({
-                                tool: toolCall.name,
-                                argsPreview,
-                                resultPreview: result.success
-                                    ? String(result.output || '(无输出)').slice(0, 200)
-                                    : String(result.error || 'failed').slice(0, 200),
-                                success: !!result.success,
-                            });
-                        }
-                        if (onStream) {
-                            if (result.success) {
-                                onStream({ type: 'status', internal: true, content: `✅ ${toolCall.name} 执行成功`, tool: toolCall.name });
-                                if (result.output) {
-                                    onStream({ type: 'tool', content: `📤 结果: ${result.output.substring(0, 200)}${result.output.length > 200 ? '...' : ''}`, tool: toolCall.name });
-                                }
-                                onStream({ type: 'step_done', content: `${toolCall.name} 执行成功`, tool: toolCall.name, success: true, output: result.output });
-                            }
-                            else {
-                                onStream({ type: 'error', content: `❌ ${toolCall.name} 执行失败: ${result.error}`, tool: toolCall.name });
-                                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();
-                            if (result.output) {
-                                this.successfulToolResults.push({ tool: toolCall.name, outputPreview: result.output.substring(0, 200) + (result.output.length > 200 ? '...' : '') });
-                            }
-                            else {
-                                this.successfulToolResults.push({ tool: toolCall.name, outputPreview: '(无输出)' });
-                            }
-                            loopReviewCompletedTools.add(toolCall.name);
-                            lastQualityScore = this.estimateToolResultQuality(result);
-                            if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {
-                                refineAttempts++;
-                            }
-                            if (onStream) {
-                                onStream({ type: 'status', internal: true, content: `🔄 工具执行完成，继续循环...`, tool: 'loop' });
-                            }
-                        }
-                        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++;
-                            }
-                            else {
-                                lastFailedTool = toolCall.name;
-                                lastFailedToolCount = 1;
-                            }
-                            console.warn(`[PiAgent] 工具 ${toolCall.name} 执行失败 (${lastFailedToolCount}/${MAX_SAME_TOOL_FAILURES}, 累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS}): ${result.error}`);
-                            // 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 });
-                            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>.` });
-                                lastFailedTool = '';
-                                lastFailedToolCount = 0;
-                                consecutiveErrors = 0;
-                                return;
-                            }
-                            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-                                this.messageHistory.push({ role: 'system', content: `[注意] 前面的工具调用连续失败。请尝试其他工具或换一种方式完成用户请求, 或用 <final gen> 给出最终回答.` });
-                                consecutiveErrors = 0;
-                            }
-                        }
-                    }
-                    catch (execError) {
-                        consecutiveErrors++;
-                        totalErrors++;
-                        const errorResult = { success: false, error: String(execError) };
-                        this.messageHistory.push({ 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 });
-                        if (onStream)
-                            onStream({ type: 'status', content: `💡 Reflection: ${obs.summary}`, tool: 'system' });
-                        console.error(`[PiAgent] 工具执行异常 (累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS}): ${execError}`);
-                    }
-                })); // end Promise.all(toolCalls.map(async ...))
-                // 所有工具执行完毕后, continue while 循环, 让 LLM 看到结果
-                continue;
-            }
-            else {
-                // LLM 返回的不是 tool call 格式
-                this.messageHistory.push({
-                    role: 'assistant',
-                    content: reply,
-                    reasoningContent: response?.reasoningContent,
-                });
-                // 通知前端收到非工具调用回复 (2026-08-09: 完整内容, 不再截断 150)
-                if (onStream) {
-                    onStream({ type: 'token', content: reply });
-                }
-                // 2026-06-19 架构 fix: 只有 strip <think> 后才检查 isFinalResponse
-                //   (parseToolCall 已先尝试, 既然没解析出 tool_call, 现在检查 final gen 是否真的在最终回答区)
-                if (this.isFinalResponse(reply)) {
-                    // 2026-06-19 dive-into 风格修复: 如果还有 successful tool results 没汇报,
-                    //   LLM 不能提前 final_gen — harness 自动注入"请汇报剩余工具结果" hint 再 continue
-                    //   这是 dive-into 文档"step 9 stop condition check" 的具体化:
-                    //   stop condition = (有工具结果未汇报) ? continue : break
-                    // 检查回复是否包含工具结果内容（避免无限循环）
-                    const hasToolResultContent = this.successfulToolResults.some(r => reply.includes(r.tool) || reply.includes(r.outputPreview.substring(0, 50)));
-                    // 如果回复包含工具结果内容，清除 successfulToolResults
-                    if (hasToolResultContent) {
-                        console.log(`[PiAgent] 回复包含工具结果内容, 清除 successfulToolResults (${this.successfulToolResults.length} 个)`);
-                        this.successfulToolResults = [];
-                    }
-                    // 2026-08-10: 逃生门 — decideUnreported: 未达上限 → 再提示一次; 超限 → 清空积压强制 final (防死循环)
-                    const unreportedDecision = decideUnreported(this.successfulToolResults.length, unreportedRetries, MAX_UNREPORTED_RETRIES);
-                    if (unreportedDecision === 'retry' && iteration < this.MAX_REACT_ITERATIONS) {
-                        unreportedRetries++;
-                        const unreported = this.successfulToolResults.length;
-                        console.log(`[PiAgent] LLM 想 final_gen 但还有 ${unreported} 个工具结果未汇报 (${unreportedRetries}/${MAX_UNREPORTED_RETRIES}), push hint 让其继续`);
-                        this.messageHistory.push({
-                            role: 'system',
-                            content: `[dive-into stop condition] 你之前已成功执行了 ${unreported} 个工具, 但当前回复里没把它们的结果告诉用户. 请基于已有的工具结果 (在 history 里) 写一个完整总结回复给用户, 用 <final gen> 结尾. 不要再调工具.`
-                        });
-                        if (onStream) {
-                            onStream({ type: 'status', internal: true, content: `🔄 还有 ${unreported} 个工具结果未汇报, 让 LLM 继续总结 (${unreportedRetries}/${MAX_UNREPORTED_RETRIES})`, tool: 'system' });
-                        }
-                        continue;
-                    }
-                    else if (unreportedDecision === 'force-final') {
-                        // 反复提示仍未汇报超过上限 → 清空积压强制 final, 不再死循环
-                        console.log(`[PiAgent] unreported 循环超限 (${unreportedRetries} 次), 清空积压强制 final`);
-                        this.successfulToolResults = [];
-                        this.messageHistory.push({
-                            role: 'system',
-                            content: `[dive-into stop condition] 已多次提示汇报工具结果仍未完成 (超过 ${MAX_UNREPORTED_RETRIES} 次). 现在直接基于你已知的信息写最终回复给用户, 用 <final gen> 结尾, 不要再调任何工具.`
-                        });
-                        if (onStream) {
-                            onStream({ type: 'status', internal: true, content: `🔄 工具结果汇报超限, 强制收尾`, tool: 'system' });
-                        }
+                    catch (gateErr) {
+                        tscAllowed = false;
+                        tscWhy = `harness-error: ${String(gateErr?.message || gateErr)}`;
                     }
-                    lastQualityScore = this.estimateResponseQuality(reply);
-                    // 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>。` });
-                        refineAttempts++;
-                        continue;
-                    }
-                    // 2026-08-08: final 前目标对齐 review — 不潦草收尾 (见 loop-review.ts)
-                    //   LLM 想 <final gen> 时, 先跑 1-2 次「目标对齐 + 需求深挖」review;
-                    //   达成用户需求才放行真正结束. 达上限或无需深挖则以用户需求为准结束.
-                    // 2026-09-16 (Milestone 1-B): 目标审查走唯一门面 (loop-review 是 Harness 的一个环节)
-                    const reviewDecision = this.piHarness().reviewFinal({
-                        reviewsDone: loopReviewCount,
-                        // 2026-08-10: 传用户原始输入 (不是派生 intentHint) — LLM 对照原文自查完成度,
-                        //   未完成 → 自动继续调工具 (自动触发后续步骤)
-                        userIntent: this.currentUserInput,
-                        completedTools: Array.from(loopReviewCompletedTools),
-                        actionLog: loopActionLog,
-                        runId: this.currentRunId || undefined,
-                        goalId: this.currentGoalId || 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 });
-                        if (onStream) {
-                            onStream({ type: 'status', internal: true, content: `🔄 目标对齐 review ${loopReviewCount}/${DEFAULT_MAX_REVIEWS}: 深挖续跑`, tool: 'system' });
-                        }
-                        continue; // 让 LLM 看到 hint, 深挖或确认完成后再次 final
-                    }
-                    finalResponse = this.extractFinalAnswer(reply);
-                    break;
-                }
-                // 检查是否需要继续循环处理
-                // 更严格的判断：只有当回复明确表示需要更多信息时才继续
-                const containsToolCallIntent = reply.includes('调用工具') || reply.includes('tool(') ||
-                    reply.includes('使用工具') || reply.includes('需要获取') || reply.includes('需要查看') ||
-                    // 兼容 LLM 用对象字面量输出 tool call (上轮没解析成功时, 至少要继续)
-                    reply.includes('tool =>') || reply.includes('[TOOL_CALL]') ||
-                    // 2026-06-15 修: 兼容 LLM 用 XML 标签输出 tool call (<shell_exec>...</shell_exec>)
-                    //   这时 parseToolCall 失败, 至少要让 loop 继续
-                    /<\w+>[\s\S]*?<\/\w+>/.test(reply);
-                const hasError = ['不存在', '找不到', '无法找到', 'not found', 'does not exist',
-                    '错误', 'error', '失败', 'failed'].some(k => reply.includes(k));
-                const isTooShort = reply.length < 50 && reply.length > 0;
-                const hasQuestion = reply.includes('?') && (reply.includes('怎么') || reply.includes('如何') || reply.includes('什么'));
-                const needsMoreWork = hasError || containsToolCallIntent || isTooShort || hasQuestion;
-                if (needsMoreWork && iteration < this.MAX_REACT_ITERATIONS) {
-                    console.log(`[PiAgent] 继续循环处理 (${iteration}/${this.MAX_REACT_ITERATIONS}): needsMoreWork=${needsMoreWork}, hasError=${hasError}, containsToolCallIntent=${containsToolCallIntent}`);
-                    if (onStream) {
-                        onStream({ type: 'status', internal: true, content: `🔄 继续处理，循环 ${iteration}...`, tool: 'loop' });
-                    }
-                    continue;
-                }
-                // 否则把这个当作可能的最终回答
-                finalResponse = reply;
-                if (onStream) {
-                    onStream({ type: 'status', internal: true, content: `📝 提取最终回答，长度 ${reply.length}`, tool: 'system' });
-                }
-                break;
-            }
-        }
-        if (!finalResponse) {
-            // 走到这里通常是 LLM 一直在调同一个不存在的工具, 没输出 <final gen>
-            // 把已知的失败信息也带回去, 让用户知道发生了什么
-            const reason = lastFailedTool
-                ? `(工具 ${lastFailedTool} 连续 ${MAX_SAME_TOOL_FAILURES} 次失败, 已放弃)`
-                : `(共 ${iteration - 1} 轮无最终输出)`;
-            finalResponse = `抱歉，任务未能完成 ${reason}。请换个方式提问，或明确告诉 agent 不要调用工具。`;
-            if (onStream) {
-                onStream({ type: 'error', content: `⚠️ 任务未完成: ${reason}`, tool: 'system' });
-            }
-        }
-        // 通知前端循环完成
-        if (onStream) {
-            onStream({ type: 'status', internal: true, content: `✅ 处理完成，共 ${iteration - 1} 次循环`, tool: 'system' });
-        }
-        this.messageHistory.push({ 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) {
-            try {
-                // 2026-09-16 (M4): 完成门 —— "模型说完成"不等于"系统确认完成"。
-                //   证据 = 成功步骤的事实摘要; 末尾还有失败步骤没被后续成功覆盖 → 不许 done。
-                const recBefore = await readRun(this.currentRunId).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];
-                const trailingFailure = !!lastStep && !lastStep.ok;
-                /** 有工具步骤却一条成功证据都没有 → 不算完成 (证据门槛, 不是文案) */
-                const noEvidence = steps.length > 0 && evidence.length === 0;
-                const errText = runPersistenceFailure || this.breakerReason || runNeedsHuman || runStopReason || aiFailureReason || '';
-                const cls = errText ? classifyRunError(errText) : 'unknown';
-                // 持久化失败 / 熔断 / 鉴权 → needs_human; 预算/中止 → aborted; 末尾仍失败或无证据 → failed (不许 done)
-                const status = runPersistenceFailure
-                    ? 'needs_human'
-                    : (this.breakerReason || runNeedsHuman)
-                        ? 'needs_human'
-                        : runStopReason
-                            ? 'aborted'
-                            : aiFailed
-                                ? (cls === 'auth' ? 'needs_human' : 'failed')
-                                : (trailingFailure || noEvidence)
-                                    ? 'failed'
-                                    : 'done';
-                await finishRun(this.currentRunId, {
-                    status,
-                    summary: finalResponse ? String(finalResponse).slice(0, 400) : undefined,
-                    error: errText
-                        || (trailingFailure ? `末尾步骤失败 (${lastStep.tool}): ${(lastStep.error || '').slice(0, 150)}` : undefined)
-                        || (noEvidence ? '有工具步骤但没有任何成功证据: 不许判 done' : undefined),
-                    evidence,
-                });
-            }
-            catch (err) {
-                // 终态也写不下去: 这是最坏情况 —— 除了留痕, 没有别的自愈手段, 所以必须显眼
-                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(() => { });
-                onStream?.({ type: 'error', content: `⚠️ ${message}`, tool: 'harness' });
-            }
-            // ★ 2026-09-25 (M0 接线冻结, 规则 ③ + ④): Run 结束**必过收尾漏斗**。
-            //
-            // 旧写法在这里另起了一套 Goal 侧收尾 (读证据 → `evaluateGoalCompletion` →
-            // `completeGoalIfEligible` / `setUnresolved`): 它**不收尾** —— 不写 Memory、不生成 Skill 候选、
-            // 不写权威 continuation、不留决策记录。于是同一条 Run 在 Supervisor 那里还会再收一次 (或反过来
-            // 这条路径根本不收), 全仓就有了两套"这一轮跑完意味着什么"。那一套已删除。
-            //
-            // 现在: `closeRunOnce` (幂等) → 9 步收尾 → 产物落盘; 再由 Goal reducer 把"下一步是什么"
-            // 落进 Goal (没有 Supervisor 宿主时 Runner 也要留下 continuation, 否则下一次还是从零开始)。
-            if (this.currentGoalId) {
-                try {
-                    const 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,
-                        caller: 'runner',
-                        now: nowIso,
-                        finalReview: finalResponse ? String(finalResponse).slice(0, 2000) : '',
-                    });
-                    if (wiring.isRefusal(closed)) {
-                        onStream?.({ type: 'status', content: `⚠️ 收尾被拒 (不当作收过): ${closed.reason}`, tool: 'harness' });
-                    }
-                    else if (closed.outcome) {
-                        const view = closed.outcome;
-                        const applied = await reduceGoalState({
-                            goalId: this.currentGoalId,
-                            intent: 'closure_outcome',
-                            now: nowIso,
-                            by: 'runner',
-                            outcome: {
-                                goalStatus: wiring.goalStatusFromDecision(view.decision),
-                                continuation: wiring.toGoalStoreContinuation(view.continuation),
-                                reason: view.decision.reason,
-                            },
-                            runId: view.runId,
-                        });
-                        const line = view.decision.decision === 'complete'
-                            ? `🎯 目标已达成 (仍要过完成门): ${view.decision.reason}`
-                            : `🎯 目标仍在进行 (未判完成): ${view.decision.reason}`;
-                        onStream?.({
-                            type: 'status', internal: true,
-                            content: `${line}${applied.gateRejected ? ` [完成门拒绝: ${applied.gateRejected}]` : ''} `
-                                + `(收尾 ${view.steps} 步 · memory ${view.memories} · skill 候选 ${view.candidates} · goal=${this.currentGoalId})`,
-                            tool: 'harness',
-                        });
+                    if (!tscAllowed) {
+                        this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查被门拒绝, 未执行: ${tscWhy.slice(0, 120)}`, tool: 'system' });
                     }
                     else {
-                        // 幂等: 别处 (或上一次) 已经收过尾 —— 事实读不回来就如实说, 不重收也不假装
-                        onStream?.({ type: 'status', content: `🎯 ${closed.reason}`, tool: 'harness' });
+                        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 (err) {
-                    await recordDegradation({ kind: 'observational', op: 'pi-sdk.runClosure', runId: this.currentRunId, message: String(err?.message || err).slice(0, 160) }).catch(() => { });
-                }
             }
-            this.currentRunId = '';
-        }
-        else if (this.currentRunId) {
-            // 外部暂停/中止: 状态是人定的, 不覆盖 (paused 等 /resume; aborted 是终态)
-            onStream?.({ type: 'status', content: `⏹️ 运行状态保持为 ${runExternallyPaused ? 'paused' : 'aborted'} (由外部控制面决定)`, tool: 'harness' });
-            this.currentRunId = '';
+            catch (e) {
+                this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
+            }
+            this.tsTouchedThisTurn = [];
         }
-        // 2026-06-16: 暴露 aiFailed 标志 — promptStream 据此决定是否自动重试整个 loop
-        return { reply: finalResponse, aiFailed, aiFailureReason: aiFailureReason || undefined };
     }
+    // 2026-10-02 K4-B: 老 `runReActLoop` **已删除** (原 1123 行) —— 它曾经是"第二条 loop"
+    //   并行存在的根源 (与 `WorkflowPivotLoop` 各跑一套, 行为按入口分叉: web=pivot / CLI=老 loop)。
+    //   删除依据 (五条件): ① 唯一替代路径 = pivot (默认已切, 三处入口全走它) ② 全仓无引用 (只剩注释/测试名)
+    //   ③ 真跑覆盖 = CLI 非流式带工具改文件 ✓ · Web 流式改 TS + 自检 ✓ · 同通道并发 3 条 ✓ ④ 全量回归 ✓
+    //   ⑤ 可回滚提交点 = 本提交。
+    //   它独有的记账 (TS 触达) 已上移到 pivot 的唯一执行点 `guardedExecute`, 口径归一。
     async deepThink(prompt) {
         const result = await this.thinkingEngine.think(prompt);
         let response = `深度思考完成（${result.depth}层）:\n\n`;
@@ -3022,7 +2296,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 +2323,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 +2402,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 +2420,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 +2443,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 +2502,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 +2542,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 +2606,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 +2625,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 +2653,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 +2674,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);
             }
@@ -3754,21 +3043,46 @@ ${this.extractOperationsFromRef(operationsRef)}
     getOperationLogs() {
         return this.constraintLayer.getLogs();
     }
+    /**
+     * K10 ④: 通信端口的**注入面** —— 传输实现仍在本仓网络层 (`src/network/**`), 内核只认形状。
+     *   换传输 (hyperswarm → iroh → …) 时只改这一处; 上层一律走 `submitTransport`。
+     */
+    transportPorts() {
+        return {
+            send: (peerId, kind, payload) => p2pNetwork.sendMessage(peerId, kind, payload),
+            broadcast: (kind, payload) => p2pNetwork.broadcast(kind, payload),
+            peers: () => p2pNetwork.getPeers(),
+            peersSync: () => p2pNetwork.getPeers(),
+        };
+    }
     listPeers() {
-        const peers = p2pNetwork.getPeers();
+        // K10 ④ 后半: 同步读也经端口 (`transportPeersSync`); 端口未注入 ⇒ 明确说"读不到", 不假装"没有对端"
+        const peers = transportPeersSync(this.transportPorts());
+        if (peers === null)
+            return '（通信端口未注入: 读不到对端列表 —— 不是"没有对端", 是没接上）';
         if (peers.length === 0) {
             return '当前无连接的对等节点';
         }
         return `已连接节点 (${peers.length}):\n${peers.map(p => `  - ${p}`).join('\n')}`;
     }
     getPeers() {
+        const peers = transportPeersSync(this.transportPorts());
+        if (peers !== null)
+            return peers;
+        // 端口未注入时**回落到传输直读**并留痕: 同步读路径没有"拒绝"的余地, 静默返回空列表会被误读成"没有对端"
+        console.warn('[kernel-transport] peersSync 端口未注入 ⇒ 回落直读传输 (K10 ④ 未接线的调用点)');
         return p2pNetwork.getPeers();
     }
     async sendMessage(peerId, message) {
-        await p2pNetwork.sendMessage(peerId, 'message', message);
+        // K10 ④: 经内核通信端口。发送有副作用 ⇒ 未注入/被拒**一律响亮** (静默丢消息比报错更糟)
+        const out = await submitTransport({ op: 'send', origin: 'pi-session', peerId, kind: 'message', payload: message }, this.transportPorts());
+        if (!out.ok)
+            throw new Error(`[kernel-transport] send 未发出: ${out.detail ?? '未知原因'}`);
     }
     async broadcast(message) {
-        await p2pNetwork.broadcast('message', message);
+        const out = await submitTransport({ op: 'broadcast', origin: 'pi-session', kind: 'message', payload: message }, this.transportPorts());
+        if (!out.ok)
+            throw new Error(`[kernel-transport] broadcast 未发出: ${out.detail ?? '未知原因'}`);
     }
     getIdentity() {
         return { ...this.identity };
@@ -3783,7 +3097,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 +3112,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 { /* 非致命 */ }
         }
@@ -3865,13 +3179,58 @@ ${this.extractOperationsFromRef(operationsRef)}
             this.socialHeartbeat = null;
         }
     }
+    /**
+     * **受门包装**的 skill 面 (2026-10-02 · leo 口径 (b): 原裸出口已收口)。
+     *
+     * 为什么不能返回裸 registry: 拿到裸 registry 就有**三条**绕过 Harness 的路径 ——
+     *   ① `registry.execute(n, p)` ② `registry.get(n).execute(p)` ③ `registry.list()[i].execute(p)`
+     *   (后两条藏在返回的 `Skill` 对象里, 只看方法名看不出来)。
+     * 现在三条**都**经本会话唯一受门口: `executeSkill` ⇒ `createSkillGuard()` ⇒ `piHarness().beforeToolCall()`,
+     * 执行落在 registry 的唯一调用点 (**恰一次**), 被拒 ⇒ **零执行** 且返回 `拒绝: [rejectedBy] reason`。
+     *
+     * ⚠️ **行为变更 (可能属破坏性)**: 旧用法 `.execute('x', p)` 在**被拒时不再执行**, 改为返回拒绝串
+     * (与 `executeSkill` 同形)。方法名/签名不变 ⇒ **源码级兼容**; 但"被拒即不执行"是新约定。
+     *
+     * **管不到的一条 (如实记)**: 调用方**自己**在 `register(skill)` 时传入的那个 skill 对象仍有裸 `execute`
+     * —— 那是调用方的对象, 不属本出口能管的面。收口管的是**本出口给出的任何引用**。
+     */
     getSkillRegistry() {
-        return this.skillRegistry;
+        // 任何被交出去的 Skill 引用, 其 execute 都换成受门版本 (堵 ②③ 两条隐藏路径)
+        const guarded = (sk) => ({
+            name: sk.name,
+            description: sk.description,
+            execute: (params) => this.executeSkill(sk.name, params),
+        });
+        return {
+            register: (sk) => this.skillRegistry.register(sk),
+            unregister: (name) => this.skillRegistry.unregister(name),
+            has: (name) => this.skillRegistry.has(name),
+            get: (name) => { const sk = this.skillRegistry.get(name); return sk ? guarded(sk) : undefined; },
+            list: () => this.skillRegistry.list().map(guarded),
+            execute: (name, params) => this.executeSkill(name, params),
+        };
     }
     registerSkill(skill) {
         this.skillRegistry.register(skill);
     }
+    /**
+     * 2026-10-02 (K7) **唯一 skill 执行口**:
+     *   判定一律经 Harness (`createSkillGuard()` ⇒ `piHarness().beforeToolCall`, 身份带 runId/goalId/agentId/channelId);
+     *   执行落在本会话 registry 的**唯一**调用点 (**恰一次**)。
+     *   **fail-closed**: 门抛错 ⇒ 返回 `拒绝: [harness-error] …`, **绝不回落**直调 registry。
+     *   公开签名不变 (仍返回 string) ⇒ 不破坏已发布契约 (leo 的方案 a: 保留 API, 内部降为经门转发)。
+     */
     async executeSkill(name, params) {
+        let decision;
+        try {
+            decision = await this.createSkillGuard()(name, params);
+        }
+        catch (guardErr) {
+            return `拒绝: [harness-error] ${String(guardErr?.message ?? guardErr)}`;
+        }
+        if (!decision.allow) {
+            return `拒绝: [${decision.rejectedBy || 'harness'}] ${decision.reason || '未说明理由'}`;
+        }
         return this.skillRegistry.execute(name, params);
     }
     async addUserAction(content, importance) {