@bolloon/bolloon-agent 0.6.4 → 0.6.6

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) {

package/dist/agents/skill-loader.js

@@ -108,33 +108,44 @@ export async function parseSkillFile(filePath) {
     const dirName = path.basename(path.dirname(filePath));
     return normalize(dirName, filePath, raw);
 }
-/** 扫描一个目录, 找所有 {name}/SKILL.md (一层嵌套结构) */
+/** 扫描一个目录, 找所有 {name}/SKILL.md — 支持多级嵌套 (2026-10-12, Hermes 式分类技能库) */
 export async function loadSkillsDir(dir) {
     const out = [];
+    await walkSkillsDir(dir, out);
+    return out;
+}
+/** 递归扫: 一层 {name}/SKILL.md + 深层子目录 (Hermes skills/<category>/<skill>/SKILL.md 形态) */
+async function walkSkillsDir(dir, out, depth = 0) {
     let entries;
     try {
         entries = await fs.readdir(dir, { withFileTypes: true });
     }
     catch {
-        return out;
+        return;
     }
     for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
         if (entry.name.startsWith('.'))
             continue;
-        const skillFile = path.join(dir, entry.name, 'SKILL.md');
-        const meta = await parseSkillFile(skillFile);
-        if (meta)
-            out.push(meta);
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // ① 这层有 SKILL.md → 即一个技能目录
+            const meta = await parseSkillFile(path.join(full, 'SKILL.md'));
+            if (meta) {
+                out.push(meta);
+                continue;
+            }
+            // ② 没有 → 递归下钻 (分类层), 防深到失控
+            if (depth < 6)
+                await walkSkillsDir(full, out, depth + 1);
+        }
     }
-    return out;
 }
-/** 默认 skill 路径优先级 (后者覆盖前者同名 skill) */
+/** 默认 skill 路径优先级 (后者覆盖前者同名 skill); 2026-10-12 加 `<cwd>/skills` (Hermes 式仓库技能库) */
 export function defaultSkillPaths(home = os.homedir(), cwd = process.cwd()) {
     return [
         path.join(home, '.bolloon', 'skills'), // 全局用户级
-        path.join(cwd, '.bolloon', 'skills'), // 项目级
+        path.join(cwd, '.bolloon', 'skills'), // 项目级 (传统 Bolloon)
+        path.join(cwd, 'skills'), // 项目级 (Hermes 式: 仓库根 skills/ 分类技能库)
         path.join(home, '.boll', 'skills'), // 全局 (兼容 bollharness 旧用户)
     ];
 }
@@ -168,7 +179,3 @@ export async function loadSkillsFromPaths(paths) {
     }
     return Array.from(seen.values());
 }
-/** 列出已加载的 skills (调试/UI 用) */
-export function describeSkill(s) {
-    return `${s.name}: ${s.description}`;
-}

package/dist/agents/skills-manager.js

@@ -25,7 +25,7 @@ import { sanitizeSkillName as sanitizeNameLoose, getUserSkillsDir as userSkillsD
 import { parseSkillFile as parseSkillFileLoose } from './skill-loader.js';
 import { parseSkillFile, defaultSkillPaths } from './skill-loader.js';
 import { getUserSkillsDir } from './skill-writer.js';
-import { collectSkillBundle, parseSkillBundle, parseSkillRef, fetchSkillBundle, installSkillBundle, } from './skill-share.js';
+import { collectSkillBundle, parseSkillBundle, installSkillBundle, } from './skill-share.js';
 // ─────────────────────────────────────────────────────────────────────────────
 export function registryPath(home = os.homedir()) {
     return path.join(home, '.bolloon', 'skills-registry.json');
@@ -400,30 +400,6 @@ export class SkillsManager {
             await this.onRegistryChanged({ home: opts.home ?? this.home, action: 'import', name: tx.name }).catch(() => null);
         return { ok: tx.ok, name: tx.name, version: tx.version, error: tx.error, skill: tx.skill };
     }
-    /** @deprecated 保留旧签名以兼容; 内部已走事务版 */
-    async importLegacy(ref, opts = {}) {
-        const cid = parseSkillRef(ref);
-        if (!cid)
-            return { ok: false, error: `无法识别的技能引用 (要 bolloon://skill/<cid> / ipfs://<cid> / 裸 CID): ${ref.slice(0, 60)}` };
-        const fetched = await fetchSkillBundle(cid);
-        if (!fetched.ok || !fetched.bundle)
-            return { ok: false, error: fetched.error || '取包失败' };
-        const inst = await installSkillBundle(fetched.bundle, { home: opts.home ?? this.home, cwd: opts.cwd ?? this.cwd, force: opts.force, scope: opts.scope });
-        if (!inst.ok)
-            return { ok: false, error: inst.error };
-        const h = opts.home ?? this.home;
-        const name = fetched.bundle.name;
-        this.cache = null;
-        const after = await this.inspect(name, { home: h });
-        if (after) {
-            await this.patchRegistry(name, {
-                status: 'installed', source: opts.source || 'shared', sourceRef: cid, trust: 'unverified',
-                contentHash: after.contentHash, version: after.version,
-            }, h);
-        }
-        return { ok: true, name, version: fetched.bundle.version, skill: (await this.inspect(name, { home: h })) || undefined };
-    }
-    /** 从已解析的技能包装入 (本地文件/已取到的包) */
     async install(bundleJson, opts = {}) {
         // 2026-09-16 (2-G.3): 同样走事务 (install 的默认来源保持 'imported')
         const tx = await this.importTransactional({ bundleJson }, { ...opts, source: opts.source || 'imported' });