@bolloon/bolloon-agent 0.6.1 → 0.6.3

package/dist/electron-build/agents/pi-sdk.js

@@ -62,6 +62,8 @@ const transport_js_1 = require("../kernel/transport.js");
 const control_js_1 = require("../kernel/control.js");
 // K10 ②: 回合的模型经**内核运行时**只读取租约 (传输仍是 Pi 客户端 ⇒ 行为不变; 取不到如实回落)
 const model_runtime_js_1 = require("../kernel/model-runtime.js");
+// K10 余项: 会话生命周期的**规则**归内核 (落盘映射 · key 校验 · 读回过滤/水合 · 运行种子合并顺序), I/O 留本类经端口注入
+const session_lifecycle_js_1 = require("../kernel/session-lifecycle.js");
 const background_notices_js_1 = require("./background-notices.js");
 const skill_ledger_js_1 = require("./skill-ledger.js");
 const node_crypto_1 = require("node:crypto");
@@ -69,7 +71,12 @@ const experience_review_js_1 = require("./experience-review.js");
 const lesson_to_skill_js_1 = require("./lesson-to-skill.js");
 const managed_services_js_1 = require("./managed-services.js");
 const tool_subset_js_1 = require("./tool-subset.js");
-const code_write_gate_js_1 = require("./code-write-gate.js");
+// K10 余项: 收尾自检的**规则**归内核 (`kernel/code-write-gate.ts`) —— 原来是 agents 侧的一个模块
+const code_write_gate_js_1 = require("../kernel/code-write-gate.js");
+// K10 余项: 收尾自检的**编排与政策**也归内核 (该不该跑 · 系统自检也过门 · 被拒不执行且可见 · 失败不影响回合)
+const turn_selfcheck_js_1 = require("../kernel/turn-selfcheck.js");
+// K10 余项: 恢复一次运行的**编排与政策**也归内核 (漂移上报口径 · 只在漂了/核对不了时装 · 恢复态一定被清)
+const run_resume_js_1 = require("../kernel/run-resume.js");
 // 2026-10-01: 身份解析必须**静态导入** —— 之前在函数体里用 require(), 而打包后是 ESM ⇒
 //   require 是 undefined ⇒ 抛错被 catch 静默吞掉 ⇒ "自愈"根本没跑, DID 一直是空的 ✗。
 const agent_identity_js_1 = require("./agent-identity.js");
@@ -500,7 +507,9 @@ class PiAgentSession {
      *   · K5 Channel Actor 完成后改为 `createRunContext({ runId: request.resumeRunId })`, 届时删除 `currentRunId` 字段本体。
      */
     seedRunContext(extra = {}) {
-        return (0, run_context_js_1.createRunContext)({ runId: this.actor.state.activeRun, ...extra });
+        // **K10 余项**: 合并顺序 (活跃运行打底 · extra 覆盖) 是内核规则 —— 与 `seed-run` 端口共用 `composeRunSeed`
+        //   "活跃运行"这一处读取仍**只在本方法体内** (K2 播种的唯一读点, 有门钉住); 合并顺序由内核给。
+        return (0, run_context_js_1.createRunContext)((0, session_lifecycle_js_1.composeRunSeed)(this.actor.state.activeRun, extra));
     }
     /**
      * **K5 迁移中**: 本会话所属 channel 的 Actor (由 session factory 在创建时绑定)。
@@ -756,7 +765,7 @@ class PiAgentSession {
             if (this.actor) {
                 const n = await this.actor.hydrateHistory({
                     load: () => this._sessionStore.loadMessages(sessionKey),
-                    filter: (loaded) => this._filterToMessage(loaded),
+                    filter: (loaded) => (0, session_lifecycle_js_1.filterSessionMessages)(loaded),
                     maxMessages,
                 });
                 if (n > 0)
@@ -768,7 +777,7 @@ class PiAgentSession {
                 console.log(`[PiAgent] hydrate: 没有 ${sessionKey} 的历史`);
                 return;
             }
-            const hydrated = this._filterToMessage(loaded).slice(-maxMessages);
+            const hydrated = (0, session_lifecycle_js_1.hydrateSessionMessages)(loaded, maxMessages);
             if (hydrated.length > 0) {
                 this.replaceHistory(hydrated);
                 console.log(`[PiAgent] 从 ${sessionKey} 回灌 ${hydrated.length} 条历史`);
@@ -789,20 +798,24 @@ class PiAgentSession {
      * 公开方法 — claude code / 外部 harness 在每次 prompt 完成后调一下,
      *   即可获得"重启 / 跨进程接续"的语义.
      */
+    /**
+     * **K10 余项**: 取数拍 (Actor 快照, 走邮箱 ⇒ 与 append 串行) 与真写入仍是本类的;
+     *   而「消息 → 持久形态」的**映射规则**与 key 校验搬进内核 (`submitSessionOp` 的 `save-session`)。
+     *   写不进 ⇒ 响亮失败 (`assertSessionOk`), 不静默继续。
+     */
     async saveCurrentSession(key) {
-        // **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,
-            toolResult: m.toolResult,
-            toolCallId: m.toolCallId,
-            timestamp: Date.now(),
-            source: 'pi-session',
-        }));
-        await this._sessionStore.saveMessages(key, persisted);
+        const out = await (0, session_lifecycle_js_1.submitSessionOp)({ op: 'save-session', origin: 'pi-session', key }, this.sessionPorts());
+        (0, session_lifecycle_js_1.assertSessionOk)(out);
+    }
+    /** K10 余项: 会话生命周期端口实现 —— I/O 留本类, 规则在内核 (`kernel/session-lifecycle.ts`) */
+    sessionPorts() {
+        return {
+            historySnapshot: () => (this.actor ? this.actor.historySnapshot() : this.actor.state.messageHistory),
+            saveMessages: (key, messages) => this._sessionStore.saveMessages(key, messages),
+            loadMessages: (key) => this._sessionStore.loadMessages(key),
+            // 注意: **故意不提供** `activeRunId` / `newRunContext` —— "活跃运行"的读取必须只有一处 (K2 播种唯一读点, 门钉住),
+            //   本类走的是**同步** `seedRunContext` + 内核的 `composeRunSeed`。异步 `seed-run` 端口留给别的调用方 (其语义由内核门覆盖)。
+        };
     }
     /**
      * 2026-06-30: 从 disk 拉历史覆盖当前 messageHistory.
@@ -820,47 +833,12 @@ class PiAgentSession {
      * 返回 Message[] 数组 (空数组表示无历史).
      */
     async peekSessionHistory(key, maxMessages = 30) {
-        try {
-            const loaded = await this._sessionStore.loadMessages(key);
-            if (!loaded)
-                return [];
-            return this._filterToMessage(loaded).slice(-maxMessages);
-        }
-        catch {
-            return [];
-        }
-    }
-    /** hydrateMessageHistory 用的过滤逻辑 — 提到外面复用 */
-    _filterToMessage(loaded) {
-        const hydrated = [];
-        const VALID_ROLES = new Set(['user', 'assistant', 'tool', 'system']);
-        for (const m of loaded) {
-            // role 必须合法 (拒绝旧 schema {type:'user'} 没 role 字段的)
-            if (!VALID_ROLES.has(m.role))
-                continue;
-            // 跳过污染消息
-            if (typeof m.content === 'string' && m.content.startsWith('[AI 服务调用失败]'))
-                continue;
-            if (typeof m.content === 'string' && m.content.startsWith('[错误:'))
-                continue;
-            // 注意: '!m.content' 会跳过 content='' 的 tool call 消息 (assistant role + toolCall 字段),
-            //   这种是合法的 (LLM 输出只有 tool call, 没有正文) — 必须保留.
-            //   这里只跳过"无内容 + 也没 tool call/tool result"的废消息.
-            if (!m.content && !m.toolCall && !m.toolResult)
-                continue;
-            // 跳过空 tool role (tool result 占位但没有任何内容)
-            if (m.role === 'tool' && !m.toolResult)
-                continue;
-            hydrated.push({
-                role: m.role,
-                content: m.content ?? '',
-                toolCall: m.toolCall,
-                toolResult: m.toolResult,
-                toolCallId: m.toolCallId,
-            });
-        }
-        return hydrated;
+        // **K10 余项**: 读回过滤/水合规则归内核; 读失败 ⇒ 空数组, 但**原因进内核审计** (不再完全静默)
+        const out = await (0, session_lifecycle_js_1.submitSessionOp)({ op: 'peek-history', origin: 'pi-session', key, maxMessages }, this.sessionPorts());
+        return out.ok ? out.result : [];
     }
+    // **K10 余项 (减法)**: 原来的 `_filterToMessage` (合法 role 白名单 · 剔污染消息 · 保留"只有 tool call 无正文"的合法消息)
+    //   已整条搬进内核 `kernel/session-lifecycle.ts` 的 `filterSessionMessages` —— 规则一处一份, 这里不再留副本。
     /** 暴露 store 给测试 / 高级集成用. */
     get sessionStoreInstance() {
         return this._sessionStore;
@@ -1168,7 +1146,14 @@ class PiAgentSession {
                     return `[初始化未就绪] ${why}\n${hint}`;
                 }
             }
-            catch { /* 门禁自身异常 → 按"不能判定"处理会阻塞一切; 这里只在能读到状态时才拦 */ }
+            catch (err) {
+                // fail-closed: 门禁异常不能绕过初始化，否则会出现"身份未就绪但 Agent 已调用工具"。
+                const why = `初始化门禁读取失败: ${String(err?.message ?? err).slice(0, 240)}`;
+                this.pushHistory({ role: 'user', content: input });
+                this.pushHistory({ role: 'assistant', content: `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。` });
+                console.warn(`[PiAgent] 拒绝执行: ${why}`);
+                return `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。`;
+            }
         }
         this.minimaxAvailable = this.checkMinimax();
         this.actor.state.channelId = options?.channelId ?? this.actor.state.channelId;
@@ -1333,8 +1318,10 @@ class PiAgentSession {
                                 .catch(() => { });
                         }
                         catch { /* 落日志失败不影响主流程 */ }
+                        // 2026-10-02 (leo: 「cli 的 UI 需要有渲染过滤」): 这条是**内部运行日志** (复盘过程), 不是用户要看的结论
+                        //   ⇒ 不再进用户可见对话流; 走 console (由 CLI 的渲染过滤只落盘, `--verbose` 下照原样上屏)。
                         try {
-                            this.runCtx.eventSink?.({ type: 'status', content: `📚 复盘: ${m}`, tool: 'system' });
+                            console.log(`📚 复盘: ${m}`);
                         }
                         catch { /* 上屏失败不打断 */ }
                     };
@@ -2135,7 +2122,8 @@ ${await this.renderActivePlansSection()}
      * 而 Supervisor / 控制面要在运行结束后才知道"刚才跑的是哪条 run" (否则会拿旧 run 做决策)。
      */
     getLastRunId() {
-        return this.lastRunId || this.actor.state.activeRun;
+        // K10 余项: 取值优先级 (显式 lastRunId 优先 · 回落活跃运行) 是**内核规则**
+        return (0, run_lifecycle_js_1.pickRunIdForResume)(this.lastRunId, this.actor.state.activeRun);
     }
     /**
      * 2026-09-16 (M2): 从 checkpoint 恢复一次运行 —— **不是**重发原 prompt。
@@ -2148,49 +2136,32 @@ ${await this.renderActivePlansSection()}
      * 并把结论放进返回值 (`modelDrift`) 让调用方能上报; 一致时也有一句明确结论。
      * 判断失败 (读不到 Run 等) 不阻塞恢复。
      */
+    /**
+     * **K10 余项**: 编排与政策归内核 (`kernel/run-resume.ts`) —— 这里只做七件事:
+     *   核对漂移 · 准备 · 按需装配 · 落恢复态 · 驱动同一 runId 继续 · 清态 · 日志。
+     *   语义 (漂移上报口径 · 只在漂了/核对不了时装 · 装配失败不阻塞 · 恢复态一定被清) 由内核拥有。
+     */
     async resumeRun(runId) {
-        let modelDrift;
-        let modelApplied;
-        try {
-            const { detectRunConfigDrift } = await Promise.resolve().then(() => __importStar(require('../llm/model-selection.js')));
-            modelDrift = (await detectRunConfigDrift(runId)) || undefined;
-            if (modelDrift?.drifted) {
-                console.warn('[pi-sdk] 恢复时模型配置已偏离 Run 快照:', modelDrift.message);
-            }
-            else if (modelDrift) {
-                console.log('[pi-sdk] 恢复前核对:', modelDrift.message);
-            }
-        }
-        catch { /* 核对本身失败不阻塞恢复 */ }
-        const prep = await (0, run_store_js_1.prepareResume)(runId);
-        if (!prep.ok || !prep.plan)
-            return { ok: false, reason: prep.reason, ...(modelDrift ? { modelDrift } : {}) };
-        // 2026-09-26 (P6 × P7): 恢复一个在跑的 Run, 用的是**它自己那份快照**, 不是盘上现在的全局默认 ——
-        //   否则这次恢复就是"带着漂移继续跑", 之后再存快照会把漂移固化成历史。
-        //   只在"漂了"或"核对不了"时重装 (一致时运行时本来就是对的, 重装是白跑一趟)。
-        //   装配只有一处实现: `applyRunModelConfigToRuntime` → `installRuntime` (这里不自己 initMinimax)。
-        if (modelDrift && (modelDrift.drifted || !modelDrift.verified)) {
-            try {
+        const out = await (0, run_resume_js_1.resumeRunViaKernel)(runId, {
+            detectDrift: async (id) => {
+                const { detectRunConfigDrift } = await Promise.resolve().then(() => __importStar(require('../llm/model-selection.js')));
+                return ((await detectRunConfigDrift(id)) || undefined);
+            },
+            prepareResume: (id) => (0, run_store_js_1.prepareResume)(id),
+            applySnapshot: async (snapshot) => {
                 const { applyRunModelConfigToRuntime } = await Promise.resolve().then(() => __importStar(require('../llm/model-selection.js')));
-                modelApplied = await applyRunModelConfigToRuntime(modelDrift.snapshot);
-                console.log(`[pi-sdk] 已按 Run 快照装配运行时: ${modelApplied.provider}/${modelApplied.model} (configHash ${String(modelApplied.configHash).slice(0, 12)})`);
-            }
-            catch (e) {
-                // 装配失败不阻塞恢复 (如实说; 调用方可以从返回值里看出没装成)
-                console.warn('[pi-sdk] 按 Run 快照装配运行时失败, 保持当前运行时:', String(e?.message || e).slice(0, 160));
-            }
-        }
-        this.resumeRunId = runId;
-        this.resumePlan = prep.plan;
-        this.actor.state.goalBinding = prep.plan.goalId || this.actor.state.goalBinding;
-        try {
-            const reply = await this.prompt((0, run_store_js_1.buildResumeInstruction)(prep.plan), {});
-            return { ok: true, reply, ...(modelDrift ? { modelDrift } : {}), ...(modelApplied ? { modelApplied } : {}) };
-        }
-        finally {
-            this.resumeRunId = '';
-            this.resumePlan = null;
-        }
+                return (await applyRunModelConfigToRuntime(snapshot));
+            },
+            applyPlan: (plan) => {
+                this.resumeRunId = runId;
+                this.resumePlan = plan;
+                this.actor.state.goalBinding = plan.goalId || this.actor.state.goalBinding;
+            },
+            continueRun: (plan) => this.prompt((0, run_store_js_1.buildResumeInstruction)(plan), {}),
+            clearPlan: () => { this.resumeRunId = ''; this.resumePlan = null; },
+            log: (level, body) => (level === 'warn' ? console.warn('[pi-sdk] ' + body) : console.log('[pi-sdk] ' + body)),
+        });
+        return out;
     }
     /**
      * 2026-10-02 (K7): 把**本会话的 Harness 判定**包成 skill 门, 供 `BollharnessIntegration.setSkillGuard` 注入。
@@ -2245,46 +2216,24 @@ ${await this.renderActivePlansSection()}
      * (`usePivotLoop: true`, `promptWithPivotLoop` 提前 return) ⇒ 这条"系统自检过门"在**生产根本没触发过**。
      * 抽成方法后两条 loop 路径都调它 (一次一轮, 由 `typecheckRanThisTurn` 保证)。
      */
+    /**
+     * **K10 余项**: 编排与政策归内核 (`kernel/turn-selfcheck.ts`) —— 这里只做三件事: 取工具 · 问门 · 上报。
+     *   语义 (该不该跑 · 系统自检也过门 · 被拒不执行且可见 · 失败不影响回合) 由内核拥有, 换入口不必各写一份。
+     *   状态维护 (一轮只跑一次 / 清空本回合触达) 跟内核的 `decided` 走: 与迁移前逐条一致。
+     */
     async runTurnEndTypecheck() {
-        // 2026-10-01: **本回合改过 TS ⇒ 收尾自动类型检查** (一轮一次) —— 复用已有的 tsc_check 工具
-        if ((0, code_write_gate_js_1.decideTypecheck)(this.tsTouchedThisTurn, this.typecheckRanThisTurn)) {
+        const out = await (0, turn_selfcheck_js_1.runTurnEndSelfCheck)({ touched: this.tsTouchedThisTurn, ranThisTurn: this.typecheckRanThisTurn }, {
+            getTool: (name) => this.tools.get(name),
+            askGate: async (req) => this.piHarness().beforeToolCall({
+                tool: req.tool,
+                args: req.args,
+                ctx: this.harnessCtx(),
+                permissionMode: this.currentPermissionMode,
+            }),
+            emit: (evt) => this.runCtx.eventSink?.({ type: 'status', content: evt.content, tool: 'system' }),
+        });
+        if (out.decided) {
             this.typecheckRanThisTurn = true;
-            try {
-                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 d = await this.piHarness().beforeToolCall({
-                            tool: 'tsc_check',
-                            args: {},
-                            ctx: this.harnessCtx(),
-                            permissionMode: this.currentPermissionMode,
-                        });
-                        tscAllowed = d.allow;
-                        tscWhy = d.reason || d.rejectedBy || '';
-                    }
-                    catch (gateErr) {
-                        tscAllowed = false;
-                        tscWhy = `harness-error: ${String(gateErr?.message || gateErr)}`;
-                    }
-                    if (!tscAllowed) {
-                        this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查被门拒绝, 未执行: ${tscWhy.slice(0, 120)}`, tool: 'system' });
-                    }
-                    else {
-                        const r = await tscTool.execute({});
-                        const line = (0, code_write_gate_js_1.formatTypecheckResult)(r?.success !== false && !/error TS\d+/.test(String(r?.output || '')), String(r?.output || ''));
-                        this.runCtx.eventSink?.({ type: 'status', content: `🔎 ${line}`, tool: 'system' });
-                    }
-                }
-            }
-            catch (e) {
-                this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
-            }
             this.tsTouchedThisTurn = [];
         }
     }