@bolloon/bolloon-agent 0.6.4 → 0.6.6

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

@@ -101,6 +101,7 @@ const p2p_document_tools_js_1 = require("./p2p-document-tools.js");
 const run_store_js_1 = require("./run-store.js");
 const goal_store_js_1 = require("./goal-store.js");
 const model_selection_js_1 = require("../llm/model-selection.js");
+// 2026-09-26: 工具名出网净化 (pi-ai.ts 唯一边界) + 回程派发还原 (原名 ↔ API 名)
 // 2026-09-28 (前缀 KV 可命中): CURRENT TURN 注入标记 —— "当前轮是否已注入"的唯一判据
 const pi_ai_js_1 = require("../llm/pi-ai.js");
 const pi_harness_js_1 = require("./pi-harness.js");
@@ -247,6 +248,10 @@ class PiAgentSession {
     identity;
     persona = null;
     minimaxAvailable = false;
+    /** 2026-10-13: pivot 路径会话累计真实消耗 (每轮 loop 的 totalTokens 累加, 刻度随会话单调增长) */
+    pivotCumulativeTokens = 0;
+    /** 2026-10-13: 上下文管理周期压缩在飞标志 (防一轮里重复触发) */
+    _ctxCycleCompacting = false;
     workflows = new Map();
     constraintLayer;
     workflowEngine;
@@ -341,6 +346,8 @@ class PiAgentSession {
     /** 2026-06-30: tool registry 模块 — 独立 alias resolve, 测试可消融. */
     _toolRegistry = new tool_registry_js_1.ToolRegistry();
     skillRegistry = new constraint_runtime_2.SkillRegistry();
+    /** 2026-10-13: 技能扫描 promise (loadSkills 保存, buildSkillsIndex await) — 确保首次对话前技能已就绪 */
+    _skillsReady = Promise.resolve();
     /** M2.4: 缓存 tool 列表, registerTools() 之后不变, runReActLoop 多次循环复用 */
     cachedToolDefinitions = '';
     /** M2.4: 缓存 persona section */
@@ -374,6 +381,41 @@ class PiAgentSession {
         return bg ? `${bg}\n${plans}` : plans;
     }
     cachedPersonaSection = '';
+    /**
+     * 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 '';
+        }
+    }
     /** 本轮迭代预算 (每轮重置; 批处理工具会退还 —— 见 iteration-budget.ts) */
     /** 上一个工具调用的参数指纹 (遥测判"是否重复调用") */
     lastToolSig = null;
@@ -855,14 +897,16 @@ 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 : (0, skill_loader_js_1.defaultSkillPaths)(os.homedir(), this.cwd);
-        (0, skill_loader_js_1.loadSkillsFromPaths)(resolved)
+        // 2026-10-13 (leo: 「成整个加载循环」): 保存 promise 供 buildSkillsIndex await ——
+        //   原来 fire-and-forget, 构造后立即读 registry = 0 ⇒ 技能索引空 ⇒ 模型不知道技能 ⇒ 循环断在起点。
+        this._skillsReady = (0, skill_loader_js_1.loadSkillsFromPaths)(resolved)
             .then((skills) => {
             for (const s of skills) {
                 if (this.skillRegistry.has(s.name)) {
@@ -959,7 +1003,7 @@ class PiAgentSession {
             _inboxMessages: this._inboxMessages,
             getChannelWallet: async () => {
                 try {
-                    const { CHANNELS_PATH } = await Promise.resolve().then(() => __importStar(require('../web/server-types.js')));
+                    const {} = await Promise.resolve().then(() => __importStar(require('../web/server-types.js')));
                     const { loadChannels } = await Promise.resolve().then(() => __importStar(require('../web/server-storage.js')));
                     const channels = await loadChannels();
                     const ch = channels.find((c) => c.id === this.actor.state.channelId);
@@ -1082,10 +1126,50 @@ class PiAgentSession {
      *   之前只有 runReActLoop 迭代内上报, chitchat/fallback/pivot 路径状态栏恒 0 */
     reportUsageToContextManager() {
         try {
-            (0, context_manager_js_1.getContextManager)().updateUsage(this.estimateHistoryTokens());
+            const cm = (0, context_manager_js_1.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 = (0, context_manager_js_1.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, 失败静默
     // ============================================================
@@ -1166,6 +1250,32 @@ class PiAgentSession {
             role: 'user',
             content: input
         });
+        // 2026-10-13 (leo: 「记忆加载和管理要变成一种执行的规范, 我刚开始就被复利性质地使用过, 所以这个没有实现」):
+        //   记忆加载原来只在 promptStream 调用 (1514), CLI 主路径 prompt() 从不召回 ⇒ 命令行 Agent 根本没有"记忆"
+        //   (用户贴屏: 「没有在工具的调用初始化过程当中看到记忆加载和记忆管理」)。这里与 promptStream 同款召回,
+        //   注入 systemPrompt 的 contextHintAddition —— 每轮执行都过这道闸, 就是"执行的规范"。
+        try {
+            const { recallMemory } = await Promise.resolve().then(() => __importStar(require('./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 Promise.resolve().then(() => __importStar(require('./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 自己的文档类功能
@@ -1573,7 +1683,11 @@ 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;
@@ -1897,6 +2011,8 @@ ${exports.PROACTIVE_WORK_DISCIPLINE}
 
 ${await this.renderActivePlansSection()}
 
+${await this.buildSkillsIndex()}
+
 工作模式:
 1. 理解用户自然语言请求
 2. 分析需要哪些工具来完成
@@ -1907,7 +2023,7 @@ ${await this.renderActivePlansSection()}
 重要 (一次命中要求):
 - 每次只调用一个工具
 - 仔细分析工具返回结果
-- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+- 任务未完成就继续调用工具推进, 直到全部完成
 - 如果需要更多信息，继续调用工具
 
 【工具调用格式 (严格遵守, 否则系统无法解析)】
@@ -1915,8 +2031,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 但永远是空
@@ -1950,6 +2065,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 = (0, context_manager_js_1.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 {
@@ -1970,7 +2104,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) {