@bolloon/bolloon-agent 0.6.5 → 0.6.6

package/dist/agents/pi-sdk-tools.js

@@ -13,6 +13,7 @@ import { checkWritePath } from './shell-guard.js';
 import { p2pDocumentTools } from './p2p-document-tools.js';
 import { runSelfImproveLoop } from './pi-sdk-session-factory.js';
 import { getMinimax } from '../constraints/index.js';
+import { llmConfigStore } from '../llm/config-store.js';
 import { delegateToEngine, buildDelegateCommand } from '../external-engines/delegate.js';
 import { spawnBackground } from './process-runner.js';
 import { DELEGATE_ENV_MARK } from './background-notices.js';
@@ -858,11 +859,9 @@ export function registerBuiltinTools(ctx) {
     //   与 shell_exec 的区别: 直接接受完整 shell 命令字符串, 更适合模型自主写命令.
     // 2026-10-01 (优化 #2 v1): **工具发现** —— 125 个工具不可能都记住, 给一个"按关键词找工具"的入口。
     // 空关键词只回**分类索引**(名称清单), 有关键词才回"名称+用途摘要" ⇒ 不刷屏。
-    // 2026-10-01 (用户: 「skills 教训学习, bolloon 有吗, 从 hermes 触发的方法是什么, 学一下」):
-    //   **实测缺口**: `skill-loader` 把 1300 个技能**注册**进注册表 ✓, 但 `describeSkill` 只 import 从没调用 ✗
-    //   ⇒ 技能**描述从不进提示** ⇒ 模型不知道它们存在 ⇒ 技能触发链**断在这里** ✗。
-    //   她那边的做法: 启动自动装载 + 按**描述**在提示里露面 + 需要时用 `skill_view` 读全文 ✓。
-    //   bolloon 有 1300 个(她百来号) ⇒ 全量注入会撑爆提示 ✗ ⇒ 改成**两个发现工具**(和 `list_tools` 同一思路 ✓)。
+    // 2026-10-01 (用户: 「skills 教训学习, bolloon 有吗」): 技能发现 = 两个工具而非全量注入 —
+    //   技能库上千个, 全量注入会撑爆提示 (历史: 19 个 skill 曾把 systemPrompt 顶到 22K 导致模型不输出)。
+    //   做法同 `list_tools`: 按关键词找 (`list_skills`) → 读全文 (`read_skill`)。
     ctx.tools.set('list_skills', {
         name: 'list_skills',
         description: '用于**找技能**: 给关键词(中文/英文都行)⇒ 返回已装载技能的名字+说明(≤20 条); 不给关键词 ⇒ 先给总数与前若干条. 找到后用 read_skill 读全文再照做.',
@@ -4445,6 +4444,182 @@ export function registerWalletTools(ctx) {
             }
         }
     });
+    // 2026-10-14 (leo: 「需要向量记忆和去中心化记忆」, P0): 结构化记忆工具
+    //  —— MemoryEntry 本地 JSONL 持久化; embedding 向量 (P1) / OrbitDB 复制 (P3) 后续接
+    const memoryAgentId = () => ctx.identity?.did || String(ctx.cwd || '');
+    /**
+     * P1: 记忆 embedding 配置。读 llm-config 的 `embedding` 段:
+     *   { embedding: { provider, model, baseUrl?, apiKey?, groupId? } }
+     * 未配置 / provider 不可用 → { provider: 'none' } (记忆层回退关键词, 行为不变)。
+     * 诚实边界: 本仓现有 provider (glm 中转 / minimax 订阅 key) 实测无可用 embedding,
+     * 故默认 none; 将来任一供应商 key 就绪, 在此配置段填上即可, 记忆层零改动。
+     */
+    const getMemoryEmbeddingConfig = () => {
+        try {
+            const cfg = llmConfigStore?.config;
+            const emb = cfg?.embedding;
+            if (emb && typeof emb === 'object' && emb.provider && emb.provider !== 'none') {
+                return {
+                    provider: String(emb.provider),
+                    model: emb.model ? String(emb.model) : undefined,
+                    baseUrl: emb.baseUrl ? String(emb.baseUrl) : undefined,
+                    apiKey: emb.apiKey ? String(emb.apiKey) : undefined,
+                    groupId: emb.groupId ? String(emb.groupId) : undefined,
+                };
+            }
+        }
+        catch { /* 配置读取失败 → none */ }
+        return { provider: 'none' };
+    };
+    ctx.tools.set('memory_save', {
+        name: 'memory_save',
+        description: '保存一条**结构化长期记忆** (事实/偏好/洞察/事件/关系/技能反馈)。用于: 用户明确说"记住 X"、反复出现的偏好、值得跨会话保留的事实。自动去重 (同内容不重复), 自动打分重要性。',
+        parameters: {
+            content: '记忆内容 (必填, ≥2 字符)',
+            kind: '类型: fact | insight | preference | event | relationship | skill-feedback (默认 fact)',
+            importance: '手动重要性 0-1 (可选, 缺省自动启发式打分)',
+            refs: '关联证据 JSON 数组 (可选, 如 goalId/runId)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                // P1: 有 embedding adapter 时 save 顺便向量化 (存 vec, 供语义召回)
+                let adapter;
+                try {
+                    const { createEmbeddingAdapter } = await import('../llm/embedding-adapter.js');
+                    const a = createEmbeddingAdapter(getMemoryEmbeddingConfig());
+                    if (a.provider !== 'none')
+                        adapter = a;
+                }
+                catch { /* 无向量能力 → 只存文本 */ }
+                const entry = await store.save({
+                    content: String(args.content || '').trim(),
+                    kind: args.kind || 'fact',
+                    importance: args.importance !== undefined ? Number(args.importance) : undefined,
+                    refs: Array.isArray(args.refs) ? args.refs.map(String) : undefined,
+                    source: 'tool',
+                }, adapter);
+                // P3: 条目级 OrbitDB 同步 (失败静默 — 本地记忆仍权威)
+                try {
+                    const { syncMemoryEntryToOrbit } = await import('../orbitdb/memory-sync.js');
+                    await syncMemoryEntryToOrbit(entry);
+                }
+                catch { /* 同步失败不阻塞保存 */ }
+                return { success: true, output: `✅ 已保存记忆 #${entry.id.slice(0, 8)} (${entry.kind}, 重要性 ${entry.importance.toFixed(2)})` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_save 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_recall', {
+        name: 'memory_recall',
+        description: '按查询关键词**召回长期记忆** (事实/偏好/洞察)。每轮对话已自动做记忆召回, 这里用于显式深挖: 用户说"你还记得我之前说的 X"、或当前任务需要历史上下文时调用。',
+        parameters: {
+            query: '查询内容 (必填, 用关键词)',
+            limit: '返回条数 (默认 3)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore, formatRecallBlock } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                // P3: 召回前先拉远端条目合并 (LWW, updatedAt 大者胜; 网络不可用静默)
+                try {
+                    const { fetchRemoteEntries } = await import('../orbitdb/memory-sync.js');
+                    const remote = await fetchRemoteEntries(memoryAgentId());
+                    if (remote.length > 0)
+                        await store.mergeRemote(remote);
+                }
+                catch { /* 远端拉取失败 → 只用本地 */ }
+                const query = String(args.query || '');
+                // P1: 有 embedding adapter 时走向量召回; 无 → 关键词回退 (P0 行为不变)
+                let queryVec;
+                try {
+                    const { createEmbeddingAdapter } = await import('../llm/embedding-adapter.js');
+                    const adapter = createEmbeddingAdapter(getMemoryEmbeddingConfig());
+                    if (adapter.provider !== 'none' && query.trim()) {
+                        queryVec = await adapter.embed(query);
+                    }
+                }
+                catch { /* vector 不可用 → 关键词回退 */ }
+                const hits = await store.recall({
+                    query,
+                    limit: args.limit ? Number(args.limit) : 3,
+                    queryVec,
+                });
+                if (!hits.length)
+                    return { success: true, output: '📭 没有找到相关记忆 (可能是新话题或记忆未保存)' };
+                return { success: true, output: formatRecallBlock(hits) };
+            }
+            catch (e) {
+                return { success: false, error: `memory_recall 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    // P2: 价值分层工具 — 固化 / 遗忘 / 统计 (2026-10-11, decentralized-memory-design §2.7)
+    ctx.tools.set('memory_crystallize', {
+        name: 'memory_crystallize',
+        description: '固化一条记忆 (crystallize): 标记为「重要, 不淡忘」+ importance 加成。用于: 用户明确说"这个要记住"、反复确认的重要约定、多次命中的核心事实。返回固化后的条目。',
+        parameters: {
+            entryId: '记忆 ID (从 memory_recall 的返回里拿, 形如 #xxxxxxxx)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const id = String(args.entryId || '').replace(/^#/, '');
+                const e = await store.crystallize(id);
+                if (!e)
+                    return { success: false, error: `未找到记忆 #${id}` };
+                return { success: true, output: `✅ 已固化记忆 #${e.id.slice(0, 8)} (${e.kind}, importance ${e.importance.toFixed(2)}, 不再淡忘)` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_crystallize 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_forget', {
+        name: 'memory_forget',
+        description: '删除一条记忆 (entryId 从 memory_recall 返回拿)。用于: 用户说"忘掉这个/删掉这条记忆"、记忆过时/错误。删除不可恢复。',
+        parameters: {
+            entryId: '记忆 ID (形如 #xxxxxxxx)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const id = String(args.entryId || '').replace(/^#/, '');
+                const ok = await store.remove(id);
+                if (!ok)
+                    return { success: false, error: `未找到记忆 #${id}` };
+                return { success: true, output: `🗑️ 已删除记忆 #${id.slice(0, 8)}` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_forget 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_stats', {
+        name: 'memory_stats',
+        description: '查看记忆库统计: 总条数 / 已固化 / 已淡化 (decay)。用于: 用户问"我存了多少记忆"、诊断记忆衰减是否生效。',
+        parameters: {},
+        execute: async () => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const s = store.stats();
+                return { success: true, output: `📊 记忆统计: 共 ${s.total} 条 · 已固化 ${s.crystallized} · 已淡化 ${s.decayed}` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_stats 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
     // 2026-07-28: 注册 LSP 工具 (代码智能)
     // registerBuiltinTools 不是 async, 用同步 import 兜底
     try {

package/dist/agents/pi-sdk.js

@@ -63,6 +63,7 @@ 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 { 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';
@@ -200,6 +201,10 @@ export 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;
@@ -294,6 +299,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 */
@@ -327,6 +334,41 @@ export 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;
@@ -808,14 +850,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 +956,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);
@@ -1035,10 +1079,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 +1203,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 +1636,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;
@@ -1850,6 +1964,8 @@ ${PROACTIVE_WORK_DISCIPLINE}
 
 ${await this.renderActivePlansSection()}
 
+${await this.buildSkillsIndex()}
+
 工作模式:
 1. 理解用户自然语言请求
 2. 分析需要哪些工具来完成
@@ -1860,7 +1976,7 @@ ${await this.renderActivePlansSection()}
 重要 (一次命中要求):
 - 每次只调用一个工具
 - 仔细分析工具返回结果
-- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+- 任务未完成就继续调用工具推进, 直到全部完成
 - 如果需要更多信息，继续调用工具
 
 【工具调用格式 (严格遵守, 否则系统无法解析)】
@@ -1868,8 +1984,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 但永远是空
@@ -1903,6 +2018,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 +2057,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) {

package/dist/agents/process-runner.js

@@ -30,7 +30,15 @@ export function spawnBackground(raw, cwd = process.cwd()) {
     const shell = process.platform === 'win32' ? 'cmd' : '/bin/sh';
     const shellArgs = process.platform === 'win32' ? ['/c', raw] : ['-c', raw];
     try {
-        const proc = spawn(shell, shellArgs, { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }, windowsHide: true });
+        const proc = spawn(shell, shellArgs, {
+            cwd,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            windowsHide: true,
+            // 2026-10-13 (leo: 「有没有错误回收机制」): detached:true = 每条命令独立进程组,
+            //   killSession 才能按组杀 (负 pid) 回收整棵进程树, 不留 shell 的孤儿子进程。
+            //   副作用 (进程随父退出不自动回收) 由既有落盘恢复机制兜底 (persistSessions/restoreSessions)。
+            detached: process.platform !== 'win32',
+        });
         session.proc = proc;
         session.pid = proc.pid;
         persistSessions();
@@ -59,8 +67,11 @@ export function pollSession(id) {
         },
     };
 }
-/** 等待后台进程结束 (最多 timeoutMs). 返回最终状态. */
-export async function waitSession(id, timeoutMs = 30000) {
+/** 等待后台进程结束 (最多 timeoutMs). 返回最终状态.
+ *  2026-10-13 (leo: 「有没有错误回收机制, 超时回收机制?」): 超时后**回收** —— 默认 kill 挂起进程
+ *  (wait 语义 = "等它跑完取结果", 超时说明它不会在预算内跑完, 留着占资源没意义);
+ *  不想杀传 killOnTimeout=false (纯等待/轮询场景). */
+export async function waitSession(id, timeoutMs = 30000, killOnTimeout = true) {
     const s = sessions.get(id);
     if (!s)
         return { ok: false, error: `未知 session ${id}` };
@@ -71,9 +82,13 @@ export async function waitSession(id, timeoutMs = 30000) {
     while (Date.now() < deadline && s.status === 'running') {
         await new Promise((r) => setTimeout(r, 250));
     }
+    const timedOut = s.status === 'running';
+    if (timedOut && killOnTimeout) {
+        killSession(id); // 超时回收: 终止挂起进程, 不占资源
+    }
     return {
-        ok: s.status !== 'running',
-        session: { id: s.id, status: s.status, exitCode: s.exitCode, output: s.output.slice(-4000), timedOut: s.status === 'running' },
+        ok: !timedOut,
+        session: { id: s.id, status: s.status, exitCode: s.exitCode, output: s.output.slice(-4000), timedOut },
     };
 }
 /** 杀死后台进程. 返回是否已终止. */
@@ -85,10 +100,14 @@ export function killSession(id) {
         return { ok: true, reason: `进程已 ${s.status}` };
     }
     try {
-        if (process.platform === 'win32')
-            s.proc.kill('SIGTERM');
-        else
-            s.proc.kill('SIGTERM');
+        // 2026-10-13 (leo: 「有没有错误回收机制」): kill 只杀 shell 不杀子进程 = 进程树泄漏;
+        //   spawn 时 detached:true 让每条命令独立进程组 ⇒ 这里 kill 整个进程组 (负 pid = 组信号)。
+        //   spawnBackground 已带 detached:true (见该函数)。
+        try {
+            process.kill(-(s.proc.pid), 'SIGTERM');
+        }
+        catch { /* 组信号可能 EPERM (非组长) */ }
+        s.proc.kill('SIGTERM');
         s.status = 'killed';
         return { ok: true };
     }

package/dist/agents/react-loop.js

@@ -8,13 +8,12 @@
  * 决策表 (apply 到 LLM 回复 + 当前 state):
  *   1. reply 是 AI failure sentinel        → continue (push error 进 history, 让 LLM 反思)
  *   2. reply 可 parse 出 tool call         → execute-tool (调 tool, push result 进 history)
- *   3. reply 含 <final gen> 且无 tool_call → final (LLM 显式终止)
- *   4. reply 无 <final gen>, 无 tool_call  → continue (LLM 可能再想想, 让下一轮重新生成)
+ *   3. reply 有 tool_call → execute-tool (工具优先)
  *
  * 这个模块不调 LLM, 只接受 reply/state 返回下一步决策. LLM 调用 + 真正状态变更
  *   仍由 PiAgentSession 协调. 这样 claude code 可以独立 unit-test 决策边界.
  */
-import { parseToolCall, isFinalResponse } from './parse-tool-call.js';
+import { parseToolCall } from './parse-tool-call.js';
 /** 把 LLM 回复归到一种 next action — 纯函数. */
 export function decideNext(ctx) {
     if (ctx.signalAborted) {
@@ -42,12 +41,10 @@ export function decideNext(ctx) {
             reason: 'parse-tool-call',
         };
     }
-    // final gen 终止
-    if (isFinalResponse(ctx.reply)) {
-        return { kind: 'final', answer: ctx.reply, reason: 'final-gen-marker' };
-    }
-    // 默认 — 普通 text, 让 LLM 继续想
-    return { kind: 'continue', reason: 'no-tool-no-final' };
+    // 2026-10-12 (leo 拍板: 全项目去掉 <final gen> 截止符): 旧实现这里用
+    //   isFinalResponse (找 `<final gen>` 标记) 判结束 — 已移除。
+    //   无工具调用 = 正常 text, 让 LLM 继续想 (由外层质量/无进展门收尾)。
+    return { kind: 'continue', reason: 'no-tool' };
 }
 /**
  * isAiFailureSentinel — 检测 LLM 上游失败哨兵.
@@ -62,14 +59,9 @@ export function isAiFailureSentinel(reply) {
         trimmed.startsWith('[AI 调用失败]') ||
         trimmed.startsWith('[错误:');
 }
-/** extractFinalText — 抽 LLM 输出里能呈现给用户的最终文字 (已是 Message 状态). */
-export function extractFinalText(reply, marker = '<final gen>') {
-    const idx = reply.indexOf(marker);
-    if (idx !== -1) {
-        const after = reply.substring(idx + marker.length).trim();
-        return after || reply.substring(0, idx).trim();
-    }
-    return reply;
+/** extractFinalText — 抽 LLM 输出里能呈现给用户的最终文字. (2026-10-12: 不再按 <final gen> 切) */
+export function extractFinalText(reply) {
+    return reply.trim();
 }
 /**
  * 错误累计判定 — 当 totalErrors 达阈值时, 给 final 答案 + 汇总.

package/dist/agents/runner-resolver.js

@@ -44,20 +44,21 @@ function classify(err, stage) {
 /** 读本机 LLM 配置摘要 (只看结构与有无, 不打印任何密钥) */
 export async function probeLlmConfig(home = os.homedir()) {
     try {
-        const raw = JSON.parse(await fsp.readFile(path.join(home, '.bolloon', 'llm-config.json'), 'utf8'));
+        // 2026-10-06 技术债清理: 只读 canonical bolloon-config.json (旧 llm-config.json 已废弃, 迁移逻辑在 config-store)
+        const raw = JSON.parse(await fsp.readFile(path.join(home, '.bolloon', 'bolloon-config.json'), 'utf8'));
         const active = raw.activeProvider || raw.provider;
         const providers = raw.providers || {};
         const p = providers[active] || {};
         const needsKey = p.requiresApiKey !== false;
         const hasKey = !!(p.apiKey || p.api_key || process.env[`${String(active).toUpperCase()}_API_KEY`]);
         if (!active)
-            return { ok: false, reason: 'llm-config.json 没有 activeProvider' };
+            return { ok: false, reason: 'bolloon-config.json 没有 activeProvider' };
         if (needsKey && !hasKey)
             return { ok: false, provider: active, model: p.model, hasKey: false, reason: `provider ${active} 需要 apiKey 但没配` };
         return { ok: true, provider: active, model: p.model, hasKey };
     }
     catch (err) {
-        return { ok: false, reason: `llm-config.json 不可读: ${String(err?.message || err).slice(0, 100)}` };
+        return { ok: false, reason: `bolloon-config.json 不可读: ${String(err?.message || err).slice(0, 100)}` };
     }
 }
 async function stage(stages, name, required, timeoutMs, fn, log, noteOf) {