@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/agents/pi-sdk.js

@@ -20,8 +20,6 @@ import { createPrivateActor } from '../kernel/channel-actor.js';
 import { submitRunLifecycle, assertLifecycleOk, pickRunIdForResume } 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';
 // K10 余项: 会话生命周期的**规则**归内核 (落盘映射 · key 校验 · 读回过滤/水合 · 运行种子合并顺序), I/O 留本类经端口注入
@@ -60,13 +58,14 @@ import { DeepThinkingEngine, AgentCoordinator } from '@bolloon/constraint-runtim
 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, recordDegradation, recordHarnessEvent, recordRecovery, setRunStatus, prepareResume, buildResumeInstruction, argsDigestOf, repeatedFailureCount, classifyError as classifyRunError } from './run-store.js';
+import { startRun, recordStep, finishRun, recordDegradation, recordHarnessEvent, prepareResume, buildResumeInstruction } 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 名)
 // 2026-09-28 (前缀 KV 可命中): CURRENT TURN 注入标记 —— "当前轮是否已注入"的唯一判据
 import { CURRENT_TURN_MARKER } from '../llm/pi-ai.js';
 import { PiAgentHarness } from './pi-harness.js';
-import { DiscoveredAgentsManager, createSocialHeartbeat } from '../social/heartbeat.js';
+import { DiscoveredAgentsManager, createSocialHeartbeat, } from '../social/heartbeat.js';
 import { SkillRegistry } from '@bolloon/constraint-runtime';
 import { loadSkillsFromPaths, defaultSkillPaths } from './skill-loader.js';
 /** 2026-08-10: unreported 逃生门判定 — LLM 反复不把工具结果写进回复时, 超过上限强制收尾 (防死循环) */
@@ -96,7 +95,6 @@ import { budgetReduce, snip, microcompact } from '../context-compaction/index.js
 import { ReactHarness } from '../security/react-harness.js';
 import { HooksEngine } from '../hooks/hooks-engine.js';
 import { DenyPipeline } from './deny-pipeline.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';
 // PiSessionManager 已抽到 ./pi-sdk-session-manager.ts (2026-07-06)
@@ -106,7 +104,6 @@ import { ToolRegistry } from './tool-registry.js';
  * 同一工具 + 同一组参数连续失败上限 (2026-07-01 起) —— 触发两条互不替代的动作:
  *   循环内: 注入 system 提示强制 LLM 收尾; 运行层 (M3): 熔断 → needs_human (交人)。
  */
-const MAX_SAME_TOOL_FAILURES = 3;
 /**
  * 2026-09-28 (前缀 KV 可命中): 把 chat() 回带的「当前轮已注入」内容写回调用方自己的 history.
  *
@@ -200,7 +197,10 @@ export class PiAgentSession {
     identity;
     persona = null;
     minimaxAvailable = false;
-    workflows = new Map();
+    /** 2026-10-13: pivot 路径会话累计真实消耗 (每轮 loop 的 totalTokens 累加, 刻度随会话单调增长) */
+    pivotCumulativeTokens = 0;
+    /** 2026-10-13: 上下文管理周期压缩在飞标志 (防一轮里重复触发) */
+    _ctxCycleCompacting = false;
     constraintLayer;
     workflowEngine;
     sessionManager;
@@ -294,6 +294,8 @@ export class PiAgentSession {
     /** 2026-06-30: tool registry 模块 — 独立 alias resolve, 测试可消融. */
     _toolRegistry = new ToolRegistry();
     skillRegistry = new SkillRegistry();
+    /** 2026-10-13: 技能扫描 promise (loadSkills 保存, buildSkillsIndex await) — 确保首次对话前技能已就绪 */
+    _skillsReady = Promise.resolve();
     /** M2.4: 缓存 tool 列表, registerTools() 之后不变, runReActLoop 多次循环复用 */
     cachedToolDefinitions = '';
     /** M2.4: 缓存 persona section */
@@ -326,18 +328,74 @@ export class PiAgentSession {
         }
         return bg ? `${bg}\n${plans}` : plans;
     }
+    /** M2.4 + 2026-10-15: persona section 缓存 (内容 + 源文件指纹)。指纹变了下一轮重建。 */
     cachedPersonaSection = '';
-    /** 本轮迭代预算 (每轮重置; 批处理工具会退还 —— 见 iteration-budget.ts) */
-    /** 上一个工具调用的参数指纹 (遥测判"是否重复调用") */
-    lastToolSig = null;
+    cachedPersonaFingerprint = '';
+    /**
+     * 2026-10-13 (leo: 「重新阅读理解，整体开发整个技能的实现方式… 成整个加载循环」):
+     * 技能库索引摘要 —— 注入 systemPrompt, 让模型**知道技能存在**(名字+一句话描述),
+     * 需要时用 `list_skills`(按关键词找) → `read_skill`(读全文, 结果进上下文) 按需加载。
+     *   为什么必须有: 技能描述**从不进提示** ⇒ 模型不知道 `read_skill` 该读什么 ⇒ 技能加载循环
+     *   断在起点 (此前 `describeSkill` 只 import 从不调用, 见 pi-sdk-tools.ts:915 注释)。
+     *   预算控制: 只列前 40 个 + 总数, 完整清单由 `list_skills` 按需取 —— 不撑爆 systemPrompt。
+     * 失败静默(返回 ''): 技能库读不到时循环退化成 "无技能", 不阻塞主流程。
+     */
+    async buildSkillsIndex() {
+        // 2026-10-13 (leo: 「成整个加载循环」): 先等技能扫描 promise 落地再读 registry ——
+        //   loadSkills 是构造期 fire-and-forget, 不 await 的话首次对话时 registry 还是空的。
+        try {
+            await this._skillsReady;
+        }
+        catch { /* 扫描失败不影响 (registry 为空时返回 '') */ }
+        try {
+            const all = this.skillRegistry.list();
+            if (!all.length)
+                return '';
+            const budget = 40;
+            const lines = all.slice(0, budget).map((sk) => {
+                const name = String(sk?.name ?? '').trim();
+                const desc = String(sk?.description ?? '').trim().replace(/\s+/g, ' ').slice(0, 100);
+                return name ? `- ${name}: ${desc}` : null;
+            }).filter(Boolean);
+            if (!lines.length)
+                return '';
+            const more = all.length > budget ? `\n…还有 ${all.length - budget} 个 (用 list_skills 按关键词找)` : '';
+            return `## 技能库 (${all.length} 个技能 — 需要时用 list_skills 找, read_skill 读全文执行; 内容进上下文, 按需加载不占首屏)\n${lines.join('\n')}${more}`;
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * 2026-10-15 (对齐 Hermes volatile 层 memory 整块注入): 稳态记忆块 ——
+     *   每轮 build systemPrompt 时把「重要且稳定」的结构化记忆整块给出 (crystallized 优先
+     *   + importance 降序, 见 memory-store.formatMemorySystemBlock), 不依赖当轮 query 召回。
+     *   与 recallMemory (memory-recall.ts 的 session 摘要召回, query 驱动) 互补:
+     *   召回 = 即时相关的历史背景; 这块 = 始终可见的用户事实/偏好/固化结论。
+     * 失败静默 (返回 ''): 记忆读不到 = 无记忆, 不阻塞主流程。缓存: 按 agentId 单例 store,
+     *   每轮 build 都 load 一次 (JSONL 小文件, load 已是最轻读盘; 避免 stale 记忆进 prompt)。
+     */
+    async buildStableMemoryBlock() {
+        try {
+            const agentId = this.actor?.state?.agentId || this.peerId || '';
+            if (!agentId)
+                return '';
+            const { getMemoryStore, formatMemorySystemBlock } = await import('./memory-store.js');
+            const store = getMemoryStore(agentId);
+            await store.load();
+            const all = await store.list(50);
+            return formatMemorySystemBlock(all, 6);
+        }
+        catch {
+            return '';
+        }
+    }
     /** 最近一条用户消息 (按需子集档用来判 intent) */
     lastUserIntent = '';
     /** 本回合改过的 TS 文件 (回合收尾自动类型检查用) */
     tsTouchedThisTurn = [];
     /** 本回合是否已跑过类型检查 (一轮只跑一次) */
     typecheckRanThisTurn = false;
-    iterBudget = null;
-    iterBudgetWarned = false;
     /** 上一次已复盘的**任务签名** (签名变了 ⇒ 立刻复盘, 对应"每次任务都总结" ✓) */
     lastReviewedTaskSig = undefined;
     /** 上一次回合后自审的时间 (节流; 0 = 从未) */
@@ -346,45 +404,14 @@ export class PiAgentSession {
     _sessionStore;
     /** 构造期间 fire-and-forget 任务的 promise — whenReady() 等它 */
     _readyPromise = null;
-    // 2026-06-16 修: 父要求把 ReAct loop 上限放大到 "几乎无限", 靠自动压缩上下文 + fail-safe 兜底
-    // 默认 10000 — 正常任务永远跑不到, 但作为防 LLM 死循环 / 防 OOM 的最后一道闸
-    // 旧默认 100 写死导致中等复杂度任务 (10-50 个 tool call + 多步反思) 会被误杀
-    MAX_REACT_ITERATIONS = 10_000;
-    MAX_REFINE_ATTEMPTS = 3;
-    QUALITY_THRESHOLD = 0.6;
-    /** P1: 上下文溢出阈值 (单轮估算 token 数, 超过则强制终止防止 prompt-too-long)
-     *  2026-08-06: 从 ContextManager 动态读 (默认 1M, env MAX_CONTEXT_TOKENS 可调).
-     *  保留字段仅作降级兜底 (ContextManager 初始化失败时用 60K 老行为). */
-    MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD = 60_000; // fallback 60K tokens
-    /** 2026-08-06: 上下文窗口 (tokens) — 统一走 ContextManager 配置 (1M 默认). */
-    maxContextTokens() {
-        try {
-            const { getContextManager } = _piRequire('../bootstrap/context-manager.js');
-            const n = getContextManager().getConfig().maxTokens;
-            return Number.isFinite(n) && n > 0 ? n : this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD;
-        }
-        catch {
-            return this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD;
-        }
-    }
-    /** 2026-06-16 新增: 累计错误总数兜底 (不管是否同工具, 累计 N 次就强制退出)
-     *  防 LLM 轮换工具名绕开 MAX_SAME_TOOL_FAILURES 的死循环攻击 */
-    MAX_TOTAL_ERRORS = 20;
-    /** 2026-06-19: 记录 loop 内成功执行的工具结果, 失败退出时汇总给用户 */
-    successfulToolResults = [];
     /** 2026-06-19: Agent Mesh 通信 — 本地 + 远端 inbox 缓存, 给 check_inbox 工具读 */
     _inboxMessages = [];
-    /** 2026-06-16 新增: loop 内自动压缩触发阈值 (相对 60K 阈值的比例) */
-    LOOP_COMPACT_RATIO = 0.8;
-    /** P1: max output token 升级重试 (LLM 截断时重试, 最多 3 次) */
-    MAX_OUTPUT_TOKEN_ESCALATION_RETRIES = 3;
     thinkingEngine = new DeepThinkingEngine(3);
     coordinator = new AgentCoordinator(3);
     harness = null;
     harnessEnabled = false;
     /** 8-gate + 4-guard 集中调度 (防越权 / 防 prompt 注入) */
     reactHarness = new ReactHarness();
-    usePivotLoop = true; // K4-B (2026-10-02): 默认切到 pivot —— 所有入口只跑**一套** loop (老 ReAct loop 待删)
     pivotLoopConfig;
     /** P2: 当前会话的 permission mode (每次 promptStream 入口解析) */
     currentPermissionMode = 'default';
@@ -402,8 +429,6 @@ export class PiAgentSession {
     _hooks = new HooksEngine();
     /** 2026-07-29: Unified Deny-First Pipeline */
     _denyPipeline = new DenyPipeline();
-    /** 2026-07-29: Snip + Context Collapse 启用标志 (默认启用) */
-    _enableSnipCollapse = true;
     /** 注册一个或多个工具到拒绝列表 */
     denyTool(...names) {
         for (const name of names)
@@ -629,7 +654,6 @@ export class PiAgentSession {
         this.workflowEngine = new WorkflowEngine(this.constraintLayer);
         this.sessionManager = new PiSessionManager(this.identity.did, this.cwd, this.actor.state.agentId);
         this.agentsManager = new DiscoveredAgentsManager();
-        this.usePivotLoop = config.usePivotLoop ?? true; // K4-B: 默认 true (K4-B 之前是 false ⇒ CLI 走老 loop, 与 web 分叉)
         this.pivotLoopConfig = config.pivotLoopConfig;
         this.initSession();
         initDocumentReceiver();
@@ -645,12 +669,6 @@ export class PiAgentSession {
             }
         }
         catch { /* env 读失败静默 */ }
-        // 2026-07-29: 从环境变量控制 Snip/Collapse
-        try {
-            if (process.env.BOLLOON_SNIP_COLLAPSE === '0')
-                this._enableSnipCollapse = false;
-        }
-        catch { /* 静默 */ }
         // 2026-07-29: 从 ~/.bolloon/hooks.yaml 加载 hook 配置
         //   失败静默 (无 hook 配置也正常)
         try {
@@ -808,14 +826,16 @@ export class PiAgentSession {
      * 2026-07-04: 移除 18 个 bollharness builtin skill (findBolloonBuiltinSkillsPath).
      *   历史遗留: 写 pi-sdk 时为方便演示, 把 bolloon 项目里的 19 个 skill 强制注入到 system prompt.
      *   问题: system prompt 涨到 22K chars, LLM (minimax M3) 在 pivot loop 里反复 think 不输出
-     *          `<final gen>`, session 落盘拿不到最终回答.
+     *          最终回答, session 落盘拿不到最终回答.
      *   现在: 只让用户放 .bolloon/skills/SKILL.md 才生效, 干净且 project-owned.
      *
      * 静默忽略不存在的目录.
      */
     loadSkills(paths) {
         const resolved = (paths && paths.length > 0) ? paths : defaultSkillPaths(os.homedir(), this.cwd);
-        loadSkillsFromPaths(resolved)
+        // 2026-10-13 (leo: 「成整个加载循环」): 保存 promise 供 buildSkillsIndex await ——
+        //   原来 fire-and-forget, 构造后立即读 registry = 0 ⇒ 技能索引空 ⇒ 模型不知道技能 ⇒ 循环断在起点。
+        this._skillsReady = loadSkillsFromPaths(resolved)
             .then((skills) => {
             for (const s of skills) {
                 if (this.skillRegistry.has(s.name)) {
@@ -912,7 +932,7 @@ export class PiAgentSession {
             _inboxMessages: this._inboxMessages,
             getChannelWallet: async () => {
                 try {
-                    const { CHANNELS_PATH } = await import('../web/server-types.js');
+                    const {} = 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.actor.state.channelId);
@@ -944,7 +964,7 @@ export class PiAgentSession {
         registerWalletTools(toolCtx);
         setupInboxListener(toolCtx);
         // 镜像到 ToolRegistry (alias resolve 用)
-        for (const [name, tool] of this.tools.entries()) {
+        for (const [, tool] of this.tools.entries()) {
             this._toolRegistry.register(tool);
         }
         // M3.3: 副作用工具走幂等性 cache
@@ -956,9 +976,6 @@ export class PiAgentSession {
     }
     /** M3.3: 工具结果缓存 — 防止 loop 重试时副作用 (写文件 / 改代码) 执行多次 */
     _idempotencyCache = new IdempotencyCache();
-    async registerP2PDocumentReceiver() {
-        await initDocumentReceiver();
-    }
     getToolDefinitions() {
         // M2.4 (2026-06-17): 缓存 tool 定义 — registerTools() 在构造时调一次, 此后不变
         // 2026-07-29: 拒绝列表变化时清空缓存, 重新生成
@@ -1035,10 +1052,50 @@ export class PiAgentSession {
      *   之前只有 runReActLoop 迭代内上报, chitchat/fallback/pivot 路径状态栏恒 0 */
     reportUsageToContextManager() {
         try {
-            getContextManager().updateUsage(this.estimateHistoryTokens());
+            const cm = getContextManager();
+            const estimated = this.estimateHistoryTokens();
+            // 2026-10-13 (leo: 刻度被覆盖回 0): pivot 路径在本轮内已上报真实消耗
+            //   (promptWithPivotLoop 内 updateUsage(pivotCumulative)); 这里若再用 actor 历史估算**覆盖**,
+            //   刻度会被拉回 ~0 (pivot 路径 actor 历史每轮只有 1-2 条)。⇒ 取 max, 只升不降。
+            cm.updateUsage(Math.max(estimated, cm.getUsage().usedTokens));
         }
         catch { /* 非致命 */ }
     }
+    /**
+     * 2026-10-13: 上下文管理周期 — 阈值触发压缩 (pivot 路径)。
+     *  ContextManager 的 markCompressStart/Complete + snapshot 原先只在 promptStream 的
+     *  maybeAutoCompact 里被调用; CLI 主路径 (prompt → promptWithPivotLoop) 从没触发过 ⇒
+     *  刻度显示到 'compressing' 但永远不会真压缩。这里补上最小周期:
+     *  累计上报 → stage 达压缩阈值 → 同步前 3 层压缩 (compressHistorySync, 零 LLM 成本) → snapshot。
+     * 失败静默, 不阻塞主流程。
+     */
+    async runContextCycle(usage) {
+        try {
+            const cm = getContextManager();
+            const history = this.actor.state.messageHistory;
+            if (history.length < 10) {
+                console.log(`[PiAgent] 上下文管理周期: 刻度达压缩阈值 (${Math.round(usage.pct * 100)}%), 历史仅 ${history.length} 条, 跳过压缩 (stage=compressing 留作警示)`);
+                return;
+            }
+            const beforeTokens = this.estimateHistoryTokens();
+            cm.markCompressStart(beforeTokens);
+            const compacted = this.compressHistorySync(history);
+            this.replaceHistory(compacted);
+            const afterTokens = this.estimateHistoryTokens();
+            const snap = cm.makeSnapshot({
+                beforeTokens,
+                afterTokens,
+                summary: `pivot 阈值压缩 (同步前3层): ${beforeTokens.toLocaleString()} → ${afterTokens.toLocaleString()} tokens`,
+                agentId: this.actor.state.agentId,
+                channelId: this.actor.state.channelId,
+            });
+            cm.markCompressComplete(snap);
+            console.log(`[PiAgent] 上下文管理周期: 压缩完成 ${beforeTokens.toLocaleString()}→${afterTokens.toLocaleString()} tokens, stage=${cm.getUsage().stage}, saved=${cm.getUsage().lastSavedTokens.toLocaleString()}`);
+        }
+        catch (err) {
+            console.warn('[PiAgent] 上下文管理周期: 压缩失败 (不阻塞主流程):', String(err?.message ?? err).slice(0, 160));
+        }
+    }
     // ============================================================
     // 2026-08-08: 运行轨迹采集 (trajectory) — 每轮运行 → 落盘 + OrbitDB, 失败静默
     // ============================================================
@@ -1119,6 +1176,32 @@ export class PiAgentSession {
             role: 'user',
             content: input
         });
+        // 2026-10-13 (leo: 「记忆加载和管理要变成一种执行的规范, 我刚开始就被复利性质地使用过, 所以这个没有实现」):
+        //   记忆加载原来只在 promptStream 调用 (1514), CLI 主路径 prompt() 从不召回 ⇒ 命令行 Agent 根本没有"记忆"
+        //   (用户贴屏: 「没有在工具的调用初始化过程当中看到记忆加载和记忆管理」)。这里与 promptStream 同款召回,
+        //   注入 systemPrompt 的 contextHintAddition —— 每轮执行都过这道闸, 就是"执行的规范"。
+        try {
+            const { recallMemory } = await import('./memory-recall.js');
+            const recalled = await recallMemory({ query: input, agentId: this.actor.state.agentId || this.peerId || '' });
+            if (recalled) {
+                this.contextHintAddition = [this.contextHintAddition, recalled].filter(Boolean).join('\n\n');
+            }
+        }
+        catch { /* 记忆召回失败静默 (增强层) */ }
+        // 2026-10-14 (P0, decentralized-memory-design §2.7): 结构化记忆 (MemoryEntry) 每轮同步召回 —
+        //   与上面会话摘要召回互补: 摘要是「整段会话的压缩」, 这里是「单条结构化记忆」 (带 kind/importance)。
+        //   借鉴 Hermes 冻结快照: 写入落盘不改 prompt, 召回走每轮注入 (progressive disclosure: 只带摘要+权重)。
+        try {
+            const { getMemoryStore, formatRecallBlock } = await import('./memory-store.js');
+            const store = getMemoryStore(this.actor.state.agentId || this.peerId || '');
+            await store.load();
+            const hits = await store.recall({ query: input, limit: 3 });
+            const block = formatRecallBlock(hits);
+            if (block) {
+                this.contextHintAddition = [this.contextHintAddition, block].filter(Boolean).join('\n\n');
+            }
+        }
+        catch { /* 结构化记忆召回失败静默 (增强层, 不阻塞对话) */ }
         // K9 (2026-10-02): 同 `promptWithPivotLoop` —— **回合入口的可用性判据必须问当前适配器**。
         //   这类 `!minimaxAvailable` 闸一共 6 处: 1223(prompt)/1466(promptStream)/1714(pivot, 已修)
         //   是**回合入口** ⇒ 全部改用 `inferenceAvailable()`; 其余三处是 Pi 自己的文档类功能
@@ -1526,7 +1609,11 @@ export class PiAgentSession {
             if (attempt > MAX_LOOP_RETRIES) {
                 console.warn(`[PiAgent] loop 自动重试 ${MAX_LOOP_RETRIES} 次后仍失败, 终止`);
                 if (onStream) {
-                    onStream({ type: 'status', content: `⛔ loop 自动重试 ${MAX_LOOP_RETRIES} 次后仍失败: ${lastAiFailureReason}`, tool: 'system' });
+                    // 2026-10-14 (leo: 「loop 自动重试提示漏进内容栏」): 老代码这条**漏标 internal** ——
+                    //   `onStream({type:'status'})` 事件在 CLI 渲染层 (index.ts) 只认发送点的显式 internal 声明,
+                    //   没标 → 走 appendLine 上内容栏。与下面 1717 行的「重试中」事件对齐, 补标 internal:true
+                    //   ⇒ 同一判据 (appendInternalRunLog: 落盘 + --verbose 上屏), 不进对话流。
+                    onStream({ type: 'status', internal: true, content: `⛔ loop 自动重试 ${MAX_LOOP_RETRIES} 次后仍失败: ${lastAiFailureReason}`, tool: 'system' });
                 }
                 result = lastAiFailureReason || 'AI 服务调用失败, 自动重试后仍不可用';
                 break;
@@ -1829,7 +1916,23 @@ export class PiAgentSession {
         catch (err) {
             console.warn('[PiAgent] classifyIntent in pivot failed:', err);
         }
-        // M2.4: persona 缓存
+        // M2.4: persona 缓存 — 2026-10-15 加指纹失效: persona 文档在外改了, 下一轮就重建
+        //   (对齐 Hermes invalidate_system_prompt 的 persona 侧; 与 systemPrompt 指纹是两条独立链路,
+        //    persona 走 personaFingerprint, Bolloon.md/AGENTS.md 走 contextFingerprint)
+        const agentId = this.actor?.state?.agentId || this.peerId || '';
+        if (agentId) {
+            try {
+                const { personaFingerprint } = await import('../bootstrap/persona-loader.js');
+                const fp = await personaFingerprint(agentId);
+                if (fp !== this.cachedPersonaFingerprint) {
+                    await this.sessionManager.reloadPersona();
+                    this.persona = this.sessionManager.getPersona();
+                    this.cachedPersonaFingerprint = fp;
+                    this.cachedPersonaSection = '';
+                }
+            }
+            catch { /* 指纹不可得 → 用旧缓存 (不阻塞) */ }
+        }
         if (!this.cachedPersonaSection && this.persona) {
             this.cachedPersonaSection = `
 角色描述: ${this.persona.description || '无'}
@@ -1850,6 +1953,10 @@ ${PROACTIVE_WORK_DISCIPLINE}
 
 ${await this.renderActivePlansSection()}
 
+${await this.buildSkillsIndex()}
+
+${await this.buildStableMemoryBlock()}
+
 工作模式:
 1. 理解用户自然语言请求
 2. 分析需要哪些工具来完成
@@ -1860,7 +1967,7 @@ ${await this.renderActivePlansSection()}
 重要 (一次命中要求):
 - 每次只调用一个工具
 - 仔细分析工具返回结果
-- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+- 任务未完成就继续调用工具推进, 直到全部完成
 - 如果需要更多信息，继续调用工具
 
 【工具调用格式 (严格遵守, 否则系统无法解析)】
@@ -1868,8 +1975,7 @@ ${await this.renderActivePlansSection()}
 - 工具调用格式: {"name":"<tool_name>","input":{"arg1":"value1"}}
 - 用 markdown json code block 包裹: \`\`\`json\n{"name":"X","input":{...}}\n\`\`\`
 - 工具调用前可以简短思考 (1-2 句话), 但**不要写长篇 thinking** (会撞 max_tokens)
-- 工具调用后必须等结果, 不要在同一个回复里继续输出
-- <final gen> 只在**真完成所有任务**时输出, 不要在工具调用前/中输出${this.judgmentGateAddition}${this.contextHintAddition}`;
+- 工具调用后必须等结果, 不要在同一个回复里继续输出${this.judgmentGateAddition}${this.contextHintAddition}`;
         // 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 但永远是空
@@ -1883,16 +1989,32 @@ ${await this.renderActivePlansSection()}
         // 2026-07-17 Bug 1 修: 注入 messageHistory (hydrateMessageHistory 从 session JSON 回灌的) 到 system prompt
         //   pivot loop execute() 内部自己维护 messageHistory, 跟 pi-sdk 的 actor 的 messageHistory 隔离,
         //   不注入的话 LLM 看不到历史对话, 每次都是新对话.
+        // 2026-10-16 (leo: prompt 比重降低, 流程由 kernel/意图驱动): 压缩历史注入 —
+        //   20 条 × 2000 = 40K 上限吃满 systemPrompt; 历史只为给 pivot 首轮"上次做到哪"的锚,
+        //   细节靠 contextHint (memory 摘要) 与工具补。8 条 × 300, 首尾保真。
         const historyLines = [];
-        const historyToInject = this.actor.state.messageHistory.slice(-20, -1);
+        const histAll = this.actor.state.messageHistory;
+        const historyToInject = histAll.slice(-8, -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);
+            // 工具结果只留首行 (JSON 常上千字符, 全量塞进 system 是浪费)
+            let text = String(m.content || '');
+            if (m.role === 'tool')
+                text = text.split('\n')[0].slice(0, 150);
+            else
+                text = text.slice(0, 300);
             if (text)
                 historyLines.push(`[${roleLabel}]: ${text}`);
         }
+        // 首条消息保留完整一点 (会话起点 / 用户最初意图, 是"根目标"锚)
+        if (histAll.length > 8) {
+            const first = histAll[0];
+            const firstText = String(first?.content || '').slice(0, 400);
+            if (firstText)
+                historyLines.unshift(`[${first?.role === 'user' ? '用户' : '你'}]: ${firstText}`);
+        }
         const historyBlock = historyLines.length > 0
-            ? `\n\n【历史对话 (最近 ${historyLines.length} 条)】\n${historyLines.join('\n')}\n【历史对话结束】`
+            ? `\n\n【历史对话 (最近 ${historyLines.length} 条, 压缩摘要)】\n${historyLines.join('\n')}\n【历史对话结束】`
             : '';
         const onCompact = async () => {
             // no-op (best-effort hook for future pi-sdk/pivot history sync)
@@ -1903,6 +2025,25 @@ ${await this.renderActivePlansSection()}
         let result;
         try {
             result = await loop.execute(input, llmWithHarness, systemPrompt + historyBlock, this.runCtx.eventSink ?? undefined, this.runCtx.abortSignal ?? undefined, onCompact);
+            // 2026-10-12 (leo: 「没有根据上下文加载刻度」): pivot 的 messageHistory 是 process-local,
+            //   `estimateHistoryTokens()` 读 actor 的旧历史 ⇒ 状态栏上下文刻度恒 0.00% 的根因。
+            //   pivot 自己累计的 `state.totalTokens` 才是这一轮**真实**消耗 —— 直接用它上报 ContextManager,
+            //   刻度立刻有数 (旧: 只在上面的 reportUsageToContextManager 里用 actor 历史估, 恒 0)。
+            try {
+                const pivotTokens = Number(result?.state?.totalTokens);
+                if (Number.isFinite(pivotTokens) && pivotTokens > 0) {
+                    // 2026-10-13: 会话累计 (多轮对话刻度单调增长; 单轮 totalTokens 只是本轮)
+                    this.pivotCumulativeTokens += pivotTokens;
+                    const cm = getContextManager();
+                    const usage = cm.updateUsage(this.pivotCumulativeTokens);
+                    // 上下文管理周期: 上报 → 阈值判断 → 触发压缩 (刻度有数之外, 到阈值真的会动)
+                    if (usage.stage === 'compressing' && !this._ctxCycleCompacting) {
+                        this._ctxCycleCompacting = true;
+                        void this.runContextCycle(usage).finally(() => { this._ctxCycleCompacting = false; });
+                    }
+                }
+            }
+            catch { /* 上报失败不阻塞主流程 */ }
         }
         finally {
             try {
@@ -1923,7 +2064,7 @@ ${await this.renderActivePlansSection()}
                 runId: this.actor.state.activeRun || undefined,
                 goalId: this.actor.state.goalBinding || undefined,
             });
-            console.log(`[PiAgent] reviewFinal (K4-B 恢复调用, 判定不参与流程): ${JSON.stringify(reviewDecision).slice(0, 160)}`);
+            console.log(`[PiAgent] reviewFinal (K4-B 恢复调用, 判定不参与流程): kind=${reviewDecision?.kind} reason=${String(reviewDecision?.reason ?? '').slice(0, 60)}`);
         }
         catch { /* 审查异常不改变本次结论 (门面内部对"审查失效"自有留痕策略) */ }
         if (result.response) {
@@ -1955,8 +2096,6 @@ ${await this.renderActivePlansSection()}
     awaitingExternal = false;
     /** 2026-09-16 (M3): 熔断原因 (同一工具连续失败达上限 → needs_human) */
     breakerReason = '';
-    /** 2026-09-16 (M3): 运行中核心写失败 (状态迁移等) —— 交给循环顶部硬闸, 不吞 */
-    persistenceFailure = '';
     /**
      * 2026-09-16 (M2-B): Supervisor 开新 Run 继续同一 Goal 时注入"上一个 Run 已成功的非幂等动作"。
      * 与 resume 的重放守卫同源 (run-store 的 buildContinuationPlan), 保证跨 Run 也不重复副作用。
@@ -1970,103 +2109,16 @@ ${await this.renderActivePlansSection()}
     setGoalId(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) {
-        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;
-    }
     /**
      * 2026-09-16 (M3): 工具失败接线 —— 分类 → recovery 留痕 → 熔断 / 外部等待。
      * 这是"错误恢复闭环"的运行时接线点 (此前 recordRecovery / repeatedFailureCount 只是数据结构)。
      */
-    async wireToolFailure(tool, errorText, args) {
-        if (!this.actor.state.activeRun)
-            return;
-        const cls = classifyRunError(errorText);
-        const digest = argsDigestOf(args);
-        let repeats = 1;
-        try {
-            const rec = await readRun(this.actor.state.activeRun);
-            // recordStep 已经把**这次**失败记进去了, 所以"连续失败次数"直接就是当前值 (不再 +1)
-            const seen = rec ? repeatedFailureCount(rec, tool, digest) : 0;
-            repeats = Math.max(seen, 1);
-        }
-        catch { /* 读不到就按首次记 */ }
-        const action = cls === 'transient' ? 'backoff'
-            : cls === 'auth' ? 'escalate'
-                : cls === 'external_no_reply' ? 'pause'
-                    : 'retry';
-        try {
-            await recordRecovery(this.actor.state.activeRun, {
-                errorClass: cls,
-                message: `${tool}: ${errorText}`.slice(0, 200),
-                action,
-                attempt: repeats,
-                recovered: false,
-            });
-        }
-        catch (err) {
-            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.actor.state.activeRun, 'awaiting_external');
-            // 2026-09-16 (2-C.4): 把"在等什么"写成持久化事实 (来源/关联/过期), 否则真实回包到了也不知道该唤醒谁。
-            try {
-                if (this.actor.state.goalBinding) {
-                    const { bindExternalWait, newContinuationId, defaultWaitExpiry } = await import('./external-events.js');
-                    const isDelegate = /delegate/i.test(String(tool || ''));
-                    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(),
-                        expiresAt: defaultWaitExpiry(Date.now(), Number(process.env.BOLLOON_EXTERNAL_WAIT_MS || 30 * 60_000)),
-                        note: `${isDelegate ? 'delegate 回包' : 'P2P 协作回复'} 等待中 (tool=${tool})`,
-                    });
-                }
-            }
-            catch (e) {
-                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.actor.state.activeRun, 'needs_human');
-            return;
-        }
-        // 重复失败熔断: 同一工具 + 同一组参数连续失败达 3 次
-        if (repeats >= MAX_SAME_TOOL_FAILURES) {
-            this.breakerReason = `同一工具 ${tool} 连续失败 ${repeats} 次 (${cls}) → 熔断, 不再重试`;
-            await this.safeSetRunStatus(this.actor.state.activeRun, 'needs_human');
-        }
-    }
     getRunId() {
         return this.actor.state.activeRun;
     }
@@ -2239,26 +2291,6 @@ ${await this.renderActivePlansSection()}
         }
         return { outputs, success: allSuccess };
     }
-    buildContext() {
-        // P1 接入: 同步跑前 3 层压缩 (Budget Reduction / Snip / Microcompact)
-        // 异步层 (Context Collapse / Auto-Compact) 在 promptStream 入口处单独跑 (用 LLM)
-        // 失败静默: 任何 stage 抛错 → 走老 slice(-10) 逻辑
-        //
-        // P1.2: 如果 maybeAutoCompact 算过 Context Collapse 投影, 用 this.projectedHistory (读时投影, 非破坏)
-        const source = this.projectedHistory ?? this.actor.state.messageHistory;
-        const recentMessages = this.compressHistorySync(source).slice(-10);
-        return recentMessages.map(m => {
-            if (m.role === 'user')
-                return `用户: ${m.content}`;
-            if (m.role === 'assistant')
-                return `助手: ${m.content}`;
-            if (m.role === 'tool') {
-                const result = m.toolResult ? JSON.stringify(m.toolResult) : m.content;
-                return `工具结果: ${result}`;
-            }
-            return m.content;
-        }).join('\n');
-    }
     /**
      * M3.5 (2026-06-17): 把 history 转成 messages 数组, 给 llm.chat() 用.
      *   不再用 buildContext() 把所有 role 压成字符串 — LLM 看不到 tool 调用结果.
@@ -2267,101 +2299,11 @@ ${await this.renderActivePlansSection()}
      * 取最近 N 条, 同步压缩前 3 层 (跟 buildContext 同步).
      * 跳过 projectedHistory 路径 — messages 数组必须真实, 不能用投影.
      */
-    buildMessages() {
-        try {
-            // 2026-08-06: 来源优先用 projectedHistory (Context Collapse 投影, 非破坏) —
-            //   与 buildContext 一致; 之前只让字符串路径用投影, messages 数组路径被跳过,
-            //   导致 LLM 实际看到的还是未压缩的历史.
-            const source = this.projectedHistory ?? this.actor.state.messageHistory;
-            const WINDOW = 15;
-            const out = [];
-            // 2026-09-28 (前缀 KV 可命中): 带 CURRENT TURN 注入的条目要**原样回带**.
-            // 两个理由: (1) 注入块是"当前轮的前缀", 重渲染 (重加 `[工具结果]` 前缀 / 再 slice 截断)
-            //   会改字节 → 下一轮前缀从这条起分叉; (2) 已注入的 tool 条目在 wire 上已经是 user 形状,
-            //   再套一次前缀就是双前缀, 连内容都变了.
-            const isInjectedEntry = (m) => typeof m.content === 'string' && m.content.includes(CURRENT_TURN_MARKER);
-            // 早期历史压缩: 超过窗口时, 不直接丢弃 — 提取前段用户意图摘要注入 (同步, 无 LLM).
-            // 结构对齐 Context OS: System Prompt(persona) + 压缩摘要 + 最近消息.
-            if (source.length > WINDOW) {
-                const early = source.slice(0, source.length - WINDOW);
-                const slice = source.slice(-WINDOW);
-                const earlyUsers = early.filter(m => m.role === 'user' && (m.content || '').trim());
-                const earlyTools = early.filter(m => m.role === 'tool').length;
-                const earlyAssist = early.filter(m => m.role === 'assistant' && (m.content || '').trim()).length;
-                const snippet = earlyUsers.slice(-5).map(m => `- ${(m.content || '').slice(0, 120).replace(/\n/g, ' ')}`).join('\n') || '- (早期对话无用户文本)';
-                out.push({
-                    role: 'system',
-                    content: `[上下文压缩] 早期 ${early.length} 条消息已压缩 (用户 ${earlyUsers.length} 条 / AI ${earlyAssist} 条 / 工具结果 ${earlyTools} 条). 关键用户意图摘要:\n${snippet}\n[压缩结束] 以下是最近消息:`,
-                });
-                for (const m of slice) {
-                    const r = m.role;
-                    if (isInjectedEntry(m)) {
-                        out.push({ role: 'user', content: String(m.content) });
-                        continue;
-                    }
-                    if (r === 'tool') {
-                        out.push({ role: 'user', content: `[工具结果]\n${(m.content || '').slice(0, 2000)}` });
-                        continue;
-                    }
-                    if (r === 'assistant') {
-                        out.push({ role: 'assistant', content: (m.content || '').slice(0, 4000), reasoningContent: m.reasoningContent });
-                        continue;
-                    }
-                    if (r === 'user') {
-                        out.push({ role: 'user', content: (m.content || '').slice(0, 2000) });
-                        continue;
-                    }
-                    if (r === 'system') {
-                        out.push({ role: 'system', content: (m.content || '').slice(0, 2000) });
-                    }
-                }
-                return out;
-            }
-            // 窗口内: 原逻辑 (tool 转 user role, 避免 tool_calls 配对)
-            const slice = source.slice(-WINDOW);
-            for (const m of slice) {
-                const r = m.role;
-                if (isInjectedEntry(m)) {
-                    out.push({ role: 'user', content: String(m.content) });
-                    continue;
-                }
-                if (r === 'tool') {
-                    out.push({ role: 'user', content: `[工具结果]\n${m.content || ''}` });
-                    continue;
-                }
-                if (r === 'assistant') {
-                    out.push({ role: 'assistant', content: m.content || '', reasoningContent: m.reasoningContent });
-                    continue;
-                }
-                if (r === 'user') {
-                    out.push({ role: 'user', content: m.content || '' });
-                }
-                if (r === 'system') {
-                    out.push({ role: 'system', content: m.content || '' });
-                }
-            }
-            return out;
-        }
-        catch (err) {
-            console.warn('[PiAgent] buildMessages failed (silent, falling back to text):', err);
-            // 退化: 用 buildContext 字符串包装成单 user message
-            return [{ role: 'user', content: this.buildContext() }];
-        }
-    }
     /**
      * 2026-09-28 (前缀 KV 可命中): 把 chat() 回带的当前轮写回自己的 messageHistory.
      * 逻辑在模块级 `writeBackCurrentTurnInto` (纯函数, 门可以直接驱它断言);
      * 这里只负责接到 `actor 的 messageHistory` 上, 并保证任何异常都静默 (写回失败不影响对话).
      */
-    writeBackCurrentTurn(wire) {
-        try {
-            return writeBackCurrentTurnInto(this.actor.state.messageHistory, wire);
-        }
-        catch (err) {
-            console.warn('[PiAgent] writeBackCurrentTurn failed (silent):', err);
-            return 0;
-        }
-    }
     /**
      * 估算 messageHistory 的 token 数 (4 字符 ≈ 1 token, 与 context-compaction 同步).
      * 失败静默: 任何异常 → 0 (不阻塞)
@@ -2383,142 +2325,6 @@ ${await this.renderActivePlansSection()}
      *
      * 失败静默: 全部失败 → 返回空 reply, 让上层 no-tool_use 终止
      */
-    async callLlmWithRecovery(llm, contextOrMessages, systemPrompt, signal, onStream, tools, 
-    /** 2026-09-28: 当前轮易变段 (循环进度/改进提示) —— 进 CURRENT TURN 区, 不进 system */
-    currentTurnContext) {
-        // Reactive compaction 预检: 估算 token 超 80% 阈值, 跑一次
-        const estimated = this.estimateHistoryTokens();
-        if (estimated > this.maxContextTokens() * 0.8) {
-            console.warn(`[PiAgent] reactive compaction pre-check (${estimated} tokens > 80% threshold)`);
-            onStream?.({ type: 'status', internal: true, content: '⚠️ reactive compaction 预检触发', tool: 'recovery' });
-            try {
-                // 同步压缩: 取快照与替换在**同一拍相邻两行** (中间没有 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);
-                }
-            }
-            catch (err) {
-                console.warn('[PiAgent] reactive compaction pre-check failed:', err);
-            }
-        }
-        // 错误分级 (M1.3, 2026-06-17):
-        //   - 401/403/400 (认证/请求错误): 不重试, 直接 fail-fast
-        //   - 429 (rate limit): 重试 2 次, 指数退避
-        //   - 5xx (上游错误): 重试 2 次, 指数退避
-        //   - network (ECONNRESET / fetch failed / abort/timeout): 重试 2 次
-        //   - 4xx prompt-too-long: 走 reactive compaction
-        // 这样以前所有错误都触发整个 runReActLoop 重跑(浪费 token),现在 4xx 直接失败
-        //   让上层把失败原因广播给用户,而不是闷在 loop 里 retry 3 次后给空回复
-        const classifyError = (err) => {
-            const msg = String(err?.message || err || '');
-            // 401/403: 认证失败
-            if (/401|unauthor|invalid api key|api_key|forbidden|403/i.test(msg))
-                return 'auth';
-            // 400 prompt-too-long
-            if (/token|too long|exceed|length|context|4000|413/i.test(msg))
-                return 'prompt_too_long';
-            // 429 rate limit
-            if (/429|rate.?limit|too many requests/i.test(msg))
-                return 'rate_limit';
-            // 5xx
-            if (/5\d\d|internal server|bad gateway|service unavailable|gateway timeout|cloudflare|502|503|504/i.test(msg))
-                return 'server';
-            // network
-            if (/econnreset|econnrefused|enotfound|etimedout|fetch failed|network|aborted|timeout/i.test(msg))
-                return 'network';
-            return 'other';
-        };
-        const isRetryable = (cls) => cls === 'rate_limit' || cls === 'server' || cls === 'network' || cls === 'prompt_too_long';
-        const maxAttempts = (cls) => isRetryable(cls) ? 3 : 1;
-        const backoffMs = (attempt) => Math.min(1000 * 2 ** attempt, 8000); // 1s, 2s, 4s, 8s cap
-        let lastErr = null;
-        let lastClass = 'other';
-        for (let attempt = 0; attempt < 4; attempt++) { // 最多 4 次尝试
-            try {
-                // M3.5 (2026-06-17): 传 messages 数组 (如果 contextOrMessages 是数组) 或字符串
-                //   数组版让 LLM 看到结构化的 user/assistant/tool role, 而不是把 history 拼成单字符串
-                // Bug 5: pass tool IDs for native OpenAI tool calling
-                // 2026-09-28 (前缀 KV 可命中): 显式 purpose/source —— pi-sdk 的 ReAct 循环**就是主对话**
-                //   (完整 IMMUTABLE PREFIX + 工具全集 + CURRENT TURN, 也只有它带 cache_prompt);
-                //   currentTurnContext 是调用方自己的当前轮易变段 (循环进度/改进提示), 走 CURRENT TURN 区.
-                // 2026-09-28: 回带最终 wire messages (含注入后的当前轮) → 上层据此写回 messageHistory.
-                const response = await llm.chat(contextOrMessages, systemPrompt, signal, tools, 'main-agent', 'react-loop', undefined, currentTurnContext);
-                // 2026-10-01 (用户: 「思考的记录可以也显示出来吗」): 思考模型的思维链原先只被"存起来回带",
-                //   **不显示** ✗。这里把它往流里送一份 —— 显示与否由 CLI 侧决定(BOLLOON_SHOW_THINKING, 默认显示) ✓。
-                try {
-                    const rc = String(response?.reasoningContent || '').trim();
-                    if (rc)
-                        this.runCtx.eventSink?.({ type: 'reasoning', content: rc });
-                }
-                catch { /* 送不出去不影响主流程 */ } // 2026-06-30: 透传 toolCalls (OpenAI 协议 native) 给上层, 让 assistant message 能 emit 真 id
-                return { reply: response.reply || '', toolCalls: response.toolCalls, messages: response.messages };
-            }
-            catch (err) {
-                // 用户主动 abort: 不重试, 立即抛
-                if (signal?.aborted || err?.name === 'AbortError')
-                    throw err;
-                lastErr = err;
-                lastClass = classifyError(err);
-                const errMsg = String(err?.message || err || '').slice(0, 200);
-                const attempts = maxAttempts(lastClass);
-                if (attempt + 1 >= attempts) {
-                    console.warn(`[PiAgent] LLM 调用失败, 不再重试 (class=${lastClass}, attempt=${attempt + 1}/${attempts}): ${errMsg}`);
-                    break;
-                }
-                console.warn(`[PiAgent] LLM 调用失败 (class=${lastClass}, attempt=${attempt + 1}/${attempts}), ${backoffMs(attempt)}ms 后重试: ${errMsg}`);
-                onStream?.({ type: 'status', content: `⚠️ LLM 调用失败 (${lastClass}), 重试 ${attempt + 2}/${attempts}...`, tool: 'recovery' });
-                if (lastClass === 'prompt_too_long') {
-                    try {
-                        await this.maybeAutoCompact(onStream, signal);
-                    }
-                    catch (compactionErr) {
-                        console.warn('[PiAgent] reactive compaction on prompt-too-long failed:', compactionErr);
-                    }
-                    // 重新生成 context (重试 prompt_too_long 时重建 messages — 包含压缩后的 history)
-                    if (Array.isArray(contextOrMessages)) {
-                        contextOrMessages = this.buildMessages();
-                    }
-                    else {
-                        contextOrMessages = this.buildContext();
-                    }
-                }
-                else if (errMsg.includes('insufficient tool messages') || errMsg.includes('must be followed by tool messages')) {
-                    // 2026-07-29: 特殊的 400 错误 — tool_calls 配对异常, 降级为纯文本 context
-                    console.warn('[PiAgent] insufficient tool messages — 降级为 buildContext 文本');
-                    if (Array.isArray(contextOrMessages)) {
-                        contextOrMessages = this.buildContext();
-                        // 也清除最近一轮的 toolCalls, 防止再触发
-                        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;
-                            }
-                        }
-                    }
-                }
-                else {
-                    // 指数退避
-                    await new Promise((r) => setTimeout(r, backoffMs(attempt)));
-                }
-            }
-        }
-        // 失败: 返回结构化错误 reply (而不是空字符串), 上层可识别 + UI 可显示
-        const errMsg = String(lastErr?.message || lastErr || '').slice(0, 300);
-        const userMsg = lastClass === 'auth'
-            ? `[AI 服务调用失败] 认证错误: ${errMsg}\n请检查 API key 配置 (env: OPENAI_API_KEY / ANTHROPIC_API_KEY 等)`
-            : lastClass === 'rate_limit'
-                ? `[AI 服务调用失败] 上游限流 (429): ${errMsg}\n请稍后重试`
-                : lastClass === 'server'
-                    ? `[AI 服务调用失败] 上游错误: ${errMsg}\n已重试 2 次仍失败, 可稍后重试`
-                    : lastClass === 'network'
-                        ? `[AI 服务调用失败] 网络错误: ${errMsg}\n请检查网络连接`
-                        : `[AI 服务调用失败] ${errMsg}`;
-        console.warn(`[PiAgent] callLlmWithRecovery 全部失败 (class=${lastClass}): ${errMsg}`);
-        return { reply: userMsg };
-    }
     /**
      * 同步压缩: 跑前 3 层 (Budget Reduction / Snip / Microcompact).
      * Context Collapse / Auto-Compact 是 async, 不在 buildContext 同步链里跑.
@@ -2640,91 +2446,7 @@ ${await this.renderActivePlansSection()}
             cm.updateUsage(beforeTokens);
         }
     }
-    isFinalResponse(content) {
-        // 2026-06-30: 抽到 ./parse-tool-call.ts 作为纯函数 — 这里只构建 ctx 并调用
-        return isFinalResponseImpl(content, this._parseCtx());
-    }
-    extractFinalAnswer(content) {
-        // 抽取实现已挪到 ./parse-tool-call.ts (纯函数, 易测)
-        return extractFinalAnswerImpl(content);
-    }
-    _parseCtx() {
-        return {
-            tools: new Set(Array.from(this.tools.keys())),
-            resolveAlias: (name) => this.resolveToolName(name),
-        };
-    }
-    parseToolCall(content) {
-        // 2026-06-30: 抽到 ./parse-tool-call.ts 作为纯函数 — 这里只构建 ctx 并调用
-        return parseToolCallImpl(content, this._parseCtx());
-    }
-    // [debug-2026-06-19] 临时: 打印 parseToolCall 输入和返回
-    _dbgParseToolCall(content) {
-        const r = this.parseToolCall(content);
-        console.log('[DBG parseToolCall] result:', JSON.stringify(r), 'content head:', JSON.stringify(content.substring(0, 200)));
-        return r;
-    }
-    /**
-     * 2026-06-19: 工具名大小写不敏感 + Claude Code 风格别名映射
-  
-    /**
-     * 2026-06-19: 工具名大小写不敏感 + Claude Code 风格别名映射
-     *   LLM 实际产出 Read/Edit/Write/Bash/Grep/Glob 等大写名 (Claude Code 工具命名)
-     *   bolloon 注册的是 read_document / edit_file / write_file / shell_exec / list_files
-     *   返回 this.tools 里的标准名, 或 null 表示未识别
-     */
-    /**
-     * 把 LLM 给的工具名 (可能大小写不一, 或者 Claude Code 风格的别名) 解析为
-     * bolloon 注册的标准工具名.
-     *
-     * 2026-06-30: 委托给 ToolRegistry 模块 — alias 表在 tool-registry.ts 统一维护,
-     *   这里只做 thin wrapper 保留 backward compat (private API 但其它地方可能用).
-     */
-    resolveToolName(name) {
-        return this._toolRegistry.resolve(name);
-    }
-    estimateResponseQuality(response) {
-        let score = 0.5;
-        if (response.length > 50)
-            score += 0.1;
-        if (response.length > 200)
-            score += 0.1;
-        if (response.length < 20)
-            score -= 0.3;
-        if (response.includes('\n'))
-            score += 0.1;
-        if (response.includes('-') || response.includes('•'))
-            score += 0.05;
-        if (response.includes('```'))
-            score += 0.1;
-        const conclusionWords = ['完成', '结果', '总结', '所以', '因此', '答案', '推荐'];
-        if (conclusionWords.some(w => response.includes(w)))
-            score += 0.1;
-        if (response.includes('调用工具') || response.includes('tool('))
-            score -= 0.2;
-        return Math.max(0, Math.min(1, score));
-    }
-    estimateToolResultQuality(result) {
-        let score = 0.5;
-        if (!result.success)
-            return 0.2;
-        if (result.output) {
-            score += 0.2;
-            if (result.output.length > 50)
-                score += 0.1;
-            if (result.output.length < 10)
-                score -= 0.1;
-            if (result.output.includes('❌') || result.output.includes('error'))
-                score -= 0.2;
-            if (result.output.includes('✅') || result.output.includes('success'))
-                score += 0.1;
-        }
-        if (result.error)
-            score -= 0.3;
-        return Math.max(0, Math.min(1, score));
-    }
     async handleFallback(input) {
-        const lowerInput = input.toLowerCase();
         const parts = input.trim().split(/\s+/);
         const cmd = parts[0].toLowerCase();
         const args = parts.slice(1).join(' ');
@@ -2807,7 +2529,6 @@ ${this.extractOperationsFromRef(operationsRef)}
     }
     extractOperationsFromRef(ref) {
         const lines = ref.split('\n');
-        const inOperationsSection = false;
         const operationLines = [];
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
@@ -3214,20 +2935,6 @@ ${this.extractOperationsFromRef(operationsRef)}
     }
     // ==================== Harness Integration ====================
     operationLog = [];
-    logToHarness(action, args, result) {
-        if (!this.harnessEnabled || !this.harness)
-            return;
-        this.operationLog.push({
-            timestamp: Date.now(),
-            action,
-            args,
-            result,
-            status: result.success ? 'ok' : 'error'
-        });
-        if (this.operationLog.length >= 10) {
-            this.archiveToHarness();
-        }
-    }
     archiveToHarness() {
         if (!this.harnessEnabled || !this.harness || this.operationLog.length === 0)
             return;