@bolloon/bolloon-agent 0.5.4 → 0.6.0

package/dist/agents/plan-store.js

@@ -39,6 +39,8 @@ export async function createPlan(input, home) {
     const now = new Date().toISOString();
     const planId = `plan_${Date.now()}_${crypto.randomBytes(3).toString('hex')}`;
     const plan = {
+        // 初始版本 (落实④: 单调递增版本号, 供乐观并发)
+        rev: 1,
         planId,
         goal,
         createdBy: input.createdBy || 'agent',
@@ -79,6 +81,13 @@ export async function updatePlan(planId, input, home) {
     const plan = await loadPlan(planId, home);
     if (!plan)
         return { ok: false, error: `plan '${planId}' 不存在` };
+    // 2026-10-01 (落实④): 乐观并发校验 —— 带 expectedRev 且对不上 ⇒ **拒收**, 绝不默默覆盖
+    if (typeof input.expectedRev === 'number' && Number.isFinite(input.expectedRev)) {
+        const cur = Number(plan.rev ?? 1);
+        if (input.expectedRev !== cur) {
+            return { ok: false, error: `plan '${planId}' 已被更新 (期望 rev=${input.expectedRev}, 实际 rev=${cur}) —— 请重新读取后再改` };
+        }
+    }
     if (input.stepId && input.status) {
         const step = plan.steps.find(s => s.id === input.stepId);
         if (!step)
@@ -104,6 +113,9 @@ export async function updatePlan(planId, input, home) {
                 s.status = 'blocked';
         }
     }
+    // 2026-10-01 (落实④): 每次成功更新 ⇒ rev **单调递增** (乐观并发的基础; 也供 UI 丢弃过期快照)
+    plan.rev = Number(plan.rev ?? 1) + 1;
+    plan.updatedAt = new Date().toISOString();
     try {
         await savePlan(plan, home);
         return { ok: true, plan };
@@ -165,3 +177,27 @@ export function planToContext(plan) {
     }
     return lines.join('\n');
 }
+/**
+ * 待办/计划重注入 (2026-10-01 落实④)。
+ *
+ * 为什么必须**每轮**注入: 上下文压缩会把早先注入的计划文本丢掉 —— 一旦丢了, 智能体就"忘了自己在做什么"。
+ * 所以注入不是一次性动作, 而是每轮带上**当前**计划(有界: 条数与字符都封顶, 免得计划本身吃爆上下文)。
+ * 与既有 `planToContext` 的分工: 那个给单条 plan 用; 这个给"当前活跃计划一览"用。
+ */
+export function formatPlansForPrompt(plans, opts = {}) {
+    const maxChars = Number.isFinite(opts.maxChars) && opts.maxChars > 0 ? Math.floor(opts.maxChars) : 1200;
+    const maxItems = Number.isFinite(opts.maxItems) && opts.maxItems > 0 ? Math.floor(opts.maxItems) : 3;
+    const active = (plans || []).filter((p) => p && p.status === 'active').slice(0, maxItems);
+    if (!active.length)
+        return '';
+    const lines = ['## 我在做的 (每轮重注入, 压缩后也不会丢)'];
+    for (const p of active) {
+        const done = p.steps.filter((x) => x.status === 'done').length;
+        lines.push(`- [${done}/${p.steps.length}] ${p.goal}  (rev ${Number(p.rev ?? 1)})`);
+        for (const st of p.steps.filter((x) => x.status !== 'done').slice(0, 5)) {
+            lines.push(`    · (${st.status}) ${st.description}`);
+        }
+    }
+    const out = lines.join('\n');
+    return out.length <= maxChars ? out : out.slice(0, maxChars) + '\n…[计划列表已截断]';
+}

package/dist/agents/process-runner.js

@@ -9,6 +9,8 @@
  * 进程注册表: 模块级 Map<sessionId, {proc, cmd, startedAt, output[]}>, 供 process 工具查询.
  */
 import { spawn } from 'child_process';
+import os from 'node:os';
+import fs from 'node:fs';
 import * as path from 'path';
 const sessions = new Map();
 let seq = 0;
@@ -30,10 +32,12 @@ export function spawnBackground(raw, cwd = process.cwd()) {
     try {
         const proc = spawn(shell, shellArgs, { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }, windowsHide: true });
         session.proc = proc;
+        session.pid = proc.pid;
+        persistSessions();
         proc.stdout.on('data', (d) => { session.output = (session.output + d.toString()).slice(-16000); });
         proc.stderr.on('data', (d) => { session.output = (session.output + d.toString()).slice(-16000); });
-        proc.on('close', (code) => { session.exitCode = code; session.status = 'exited'; });
-        proc.on('error', (e) => { session.status = 'error'; session.error = e.message; });
+        proc.on('close', (code) => { session.exitCode = code; session.status = 'exited'; persistSessions(); });
+        proc.on('error', (e) => { session.status = 'error'; session.error = e.message; persistSessions(); });
     }
     catch (e) {
         session.status = 'error';
@@ -103,3 +107,61 @@ export function isValidSessionId(id) {
 export function sessionIdFromPath(p) {
     return path.basename(String(p || '').trim());
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// 2026-10-01 (用户: 「bolloon 后台开进程后无法回来进行管理」):
+//   实测根因: 会话表是**内存 Map** ✗ 且不落盘 ⇒ 重启/换一轮后 bolloon **忘了**后台进程 ✗
+//   ⇒ `process list` 空的 ⇒ "回不来管理" ✓。修: 落盘 `~/.bolloon/processes.json` +
+//   **懒恢复**(list/poll 时若表里没有就从盘上读 ✓) + 按 pid 探活(活着 ⇒ detached=true 仍可 kill ✓; 死了 ⇒ lost ✓)。
+// ─────────────────────────────────────────────────────────────────────────────
+export function processesPath(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'processes.json');
+}
+/** 探活: 只发 0 号信号, 真 kill 什么都不做 ✓ (EPERM 也算活着 ✓) */
+export function isPidAlive(pid) {
+    if (!pid || !Number.isFinite(pid))
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === 'EPERM';
+    }
+}
+/** 把当前的会话表写到盘上 (best-effort, 绝不影响命令执行 ✓) */
+export function persistSessions(home = os.homedir()) {
+    try {
+        const rows = [...sessions.values()].map((s) => ({
+            id: s.id, cmd: s.cmd, cwd: s.cwd, startedAt: s.startedAt,
+            status: s.status, exitCode: s.exitCode, pid: s.pid ?? null,
+        }));
+        fs.mkdirSync(path.dirname(processesPath(home)), { recursive: true });
+        fs.writeFileSync(processesPath(home), JSON.stringify(rows, null, 0), 'utf-8');
+    }
+    catch { /* 落盘失败不影响执行 */ }
+}
+/** 懒恢复: 表里没有的就从盘上读回来, 并按 pid 探活 ✓ */
+export function restoreSessions(home = os.homedir()) {
+    let n = 0;
+    try {
+        const file = processesPath(home);
+        if (!fs.existsSync(file))
+            return 0;
+        const rows = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        for (const r of Array.isArray(rows) ? rows : []) {
+            if (!r?.id || sessions.has(r.id))
+                continue;
+            const alive = isPidAlive(Number(r.pid));
+            sessions.set(r.id, {
+                id: String(r.id), cmd: String(r.cmd || ''), cwd: String(r.cwd || process.cwd()),
+                startedAt: Number(r.startedAt) || Date.now(), exitCode: r.exitCode ?? null,
+                status: r.status === 'running' ? (alive ? 'running' : 'exited') : (r.status || 'exited'),
+                output: alive ? '(重启后恢复: 进程仍在跑, 输出不再采集 —— 需要结果就重新跑或用文件落盘)' : '',
+                proc: null, pid: Number(r.pid) || undefined, detached: true,
+            });
+            n++;
+        }
+    }
+    catch { /* 坏文件忽略 */ }
+    return n;
+}

package/dist/agents/run-context.js

@@ -0,0 +1,20 @@
+let seq = 0;
+/** 建一个 RunContext; 未给的字段一律显式置空 (不继承上一个 Run 的残留) */
+export function createRunContext(partial = {}) {
+    seq += 1;
+    return {
+        requestId: partial.requestId ?? `rc-${Date.now().toString(36)}-${seq}`,
+        channelId: partial.channelId ?? '',
+        agentId: partial.agentId ?? '',
+        goalId: partial.goalId ?? '',
+        runId: partial.runId ?? '',
+        // 'chitchat' 是中性默认, 与旧实例字段初值一致 (不是继承上一个 Run 的残留)
+        intent: partial.intent ?? 'chitchat',
+        modelSnapshot: partial.modelSnapshot ?? null,
+        history: partial.history ?? null,
+        abortSignal: partial.abortSignal ?? null,
+        budget: partial.budget ?? null,
+        eventSink: partial.eventSink ?? null,
+        harnessContext: partial.harnessContext ?? null,
+    };
+}

package/dist/agents/runner-resolver.js

@@ -15,6 +15,7 @@
  * 现在 `init_llm` 是必需阶段, LLM 不可用直接 unresolved (而不是偷偷退化成 fallback)。
  */
 import * as os from 'os';
+import { deliverThroughActor } from '../kernel/channel-actor.js';
 import * as path from 'path';
 import * as fsp from 'fs/promises';
 import { readGoal } from './goal-store.js';
@@ -197,7 +198,7 @@ export async function resolveGoalRunner(req, opts = {}) {
         }
         agent.setGoalId?.(goal.goalId);
         agent.setContinuationGuards?.(r.guards || []);
-        const reply = await agent.prompt(r.instruction);
+        const reply = await deliverThroughActor(agent, () => agent.prompt(r.instruction));
         const runId = agent.getLastRunId?.() || agent.getRunId?.() || '';
         // 没有 Run = 这次执行没有事实记录: 如实报告, 不让上层把"没跑"当"跑完"
         if (!runId) {

package/dist/agents/shell-guard.js

@@ -83,7 +83,13 @@ const FALLBACK_PATH_DENYLIST = [
     /(^|\/)tsconfig.*\.json$/,
     /(^|\/)\.env(\.|$)/,
     /(^|\/)\.git\//,
-    /(^|\/)\.bolloon\//, // 策略文件 / sessions / persona
+    // 2026-10-01 (用户实测): 原先这行把**整个** ~/.bolloon/ 一刀封死 ⇒ patch 写自己的
+    //   context-os/01-Me/… 被拒, 而同一目录 write_context_asset(Node fs) 却成功 ✗ —— 门在打自己的脚。
+    //   收窄口径: 只封**凭证 / 身份密钥 / 会话数据 / 钱包**; agent 自己的工作区
+    //   (context-os · persona · memory · logs · goals · runs …) 一律放行。
+    /(^|\/)\.bolloon\/(identity\.json|keypair\.json|accounts\.json|llm-config\.json|bolloon-config\.json|agent-keys\/|iroh-secret[^/]*\.json|chain\.json)/,
+    /(^|\/)\.bolloon\/(sessions|wallets|bindings|eas-bind|_migrate_bak_[^/]*)\//,
+    /(^|\/)\.bolloon\/[^/]*\.token$/,
     /(^|\/)dist\//,
     // 2026-06-17: node_modules 不再 denylist, 因为 M3.4 自动 commit 阶段需要 npm install / npx vitest
     //   通过 allowlist 限定 agent 只能 npm install, 不能 rm node_modules (shell arg denylist 仍禁 rm -rf)
@@ -116,7 +122,19 @@ function getDefaultPolicy() {
     return {
         version: 1,
         commandAllowlist: Array.from(FALLBACK_COMMAND_ALLOWLIST),
-        pathAllowlist: [...FALLBACK_PATH_ALLOWLIST],
+        // 2026-10-01: agent 自己的数据工作区必须显式允许 —— 这道护栏是 deny → allow → **默认拒**,
+        //   所以光把旧禁区收窄还不够: allowlist 里没有的路径照样被拒 ✗ (用户实测 context-os 被拒就是这个)。
+        pathAllowlist: [
+            ...FALLBACK_PATH_ALLOWLIST,
+            ...(process.env.HOME ? [
+                `${process.env.HOME}/.bolloon/context-os/**`,
+                `${process.env.HOME}/.bolloon/persona/**`,
+                `${process.env.HOME}/.bolloon/memory/**`,
+                `${process.env.HOME}/.bolloon/logs/**`,
+                `${process.env.HOME}/.bolloon/goals/**`,
+                `${process.env.HOME}/.bolloon/runs/**`,
+            ] : []),
+        ],
         pathDenylist: FALLBACK_PATH_DENYLIST.map(r => r.source),
         cooldownMs: 6 * 60 * 60 * 1000,
         sandboxCwd: '.bolloon-shell-sandbox',
@@ -127,6 +145,44 @@ function getDefaultPolicy() {
  * 加载策略 (有缓存)
  * 加载失败返回 null, 调用方应回退到硬编码兜底
  */
+/**
+ * 已知过时的策略条目 (2026-10-01)。
+ *
+ * 事故: 盘上 `~/.bolloon/self-improve-policy.json` 是 2026-06-14 写下的**快照**,
+ *   里面还留着旧版的宽正则 `(^|\/)\.bolloon\/` —— 它把整个数据目录一刀封死,
+ *   于是 `patch ~/.bolloon/context-os/...` 被拒, 而 `write_context_asset`(走 Node fs) 同一目录能写 ✗,
+ *   用户看到的就是"同一个目录, 一个工具能写一个不能"。
+ *   更糟: 连 2026-06-17 已经明确解禁的 `pi-sdk.ts` 也还封着 ✗ ⇒ **改代码也压不过这份旧策略**。
+ * 规矩: 代码里的 FALLBACK_PATH_DENYLIST 是唯一真源; 盘上策略里凡属"过时快照"的条目一律作废并回写。
+ */
+/** agent 自己的数据工作区 (相对 ~/.bolloon) —— 必须在 allowlist 里, 否则默认拒 */
+export const DATA_WORKSPACE_SUBDIRS = ['context-os', 'persona', 'memory', 'logs', 'goals', 'runs'];
+/** 盘上策略缺这些条目时补齐 (与"作废过时条目"对称: 旧策略既要减法也要加法) */
+function ensureWorkspaceAllowed(policy, home) {
+    if (!Array.isArray(policy.pathAllowlist))
+        policy.pathAllowlist = [];
+    let changed = false;
+    for (const sub of DATA_WORKSPACE_SUBDIRS) {
+        const need = `${home}/.bolloon/${sub}/**`;
+        if (!policy.pathAllowlist.includes(need)) {
+            policy.pathAllowlist.push(need);
+            changed = true;
+        }
+    }
+    return changed;
+}
+const STALE_POLICY_PATTERNS = [
+    '(^|\\/)\\.bolloon\\/', // 旧: 整个数据目录一刀封 (已收窄为凭证/身份/会话/钱包)
+    '(^|\\/)src\\/agents\\/pi-sdk\\.ts$', // 旧: 2026-06-17 已解禁 (自进化需要)
+    '(^|\\/)node_modules\\/', // 旧: 2026-06-17 已从硬编码清单移除
+];
+function dropStalePolicyPatterns(policy) {
+    if (!Array.isArray(policy.pathDenylist) || policy.pathDenylist.length === 0)
+        return false;
+    const before = policy.pathDenylist.length;
+    policy.pathDenylist = policy.pathDenylist.filter((src) => !STALE_POLICY_PATTERNS.includes(String(src)));
+    return policy.pathDenylist.length !== before;
+}
 export function loadPolicy(forceReload = false) {
     const now = Date.now();
     if (!forceReload && cachedPolicy && now - policyLoadedAt < POLICY_TTL_MS) {
@@ -142,6 +198,17 @@ export function loadPolicy(forceReload = false) {
         }
         const raw = fs.readFileSync(POLICY_PATH, 'utf-8');
         const parsed = JSON.parse(raw);
+        // 2026-10-01: 盘上策略是**快照** —— 先作废已知过时条目 (否则改代码也压不过它), 再回写。
+        //   用户实测: `(^|\/)\.bolloon\/` 这条旧宽正则把整个数据目录封死, 而它只存在于盘上策略里。
+        try {
+            const dropped = dropStalePolicyPatterns(parsed);
+            const added = ensureWorkspaceAllowed(parsed, os.homedir());
+            if (dropped || added) {
+                fs.writeFileSync(POLICY_PATH, JSON.stringify(parsed, null, 2));
+                console.log(`[shell-guard] 已作废过时策略条目并回写: ${POLICY_PATH}`);
+            }
+        }
+        catch { /* 回写失败不影响本次使用 */ }
         // 极简 schema 校验
         if (!parsed.version || !Array.isArray(parsed.commandAllowlist) || !Array.isArray(parsed.pathAllowlist) || !Array.isArray(parsed.pathDenylist)) {
             console.warn('[shell-guard] 策略文件 schema 不对, 用硬编码兜底');
@@ -214,7 +281,7 @@ export function checkCommand(cmd, args) {
         auditShellCall('denied', cmd, args, `命令 '${cmd}' 不在白名单`);
         return {
             allowed: false,
-            reason: `命令 '${cmd}' 不在白名单. 允许: ${Array.from(allowSet).join(', ')}`,
+            reason: `命令 '${cmd}' 不在白名单. 允许的命令: ${shortRoots(Array.from(allowSet))}`,
             matchedBy: policy ? 'cmd-allowlist' : 'fallback-deny'
         };
     }
@@ -297,7 +364,7 @@ export function checkWritePath(targetPath) {
     auditShellCall('denied', '', [], `路径 '${targetPath}' 不在任何 allowlist 中`, targetPath);
     return {
         allowed: false,
-        reason: `路径 '${targetPath}' 不在白名单. 允许: ${allowlist.join(', ')}`,
+        reason: `路径 '${targetPath}' 不在白名单. 允许的根: ${shortRoots(allowlist)}`, // 2026-10-01: 不再把整张白名单(含临时目录)塞进错误 ✓
         matchedBy: 'path-allowlist'
     };
 }
@@ -340,6 +407,19 @@ export const SHELL_SANDBOX_CWD = path.resolve(process.cwd(), '.bolloon-shell-san
 // 与 checkCommand 的区别: 不查命令白名单/参数 allowlist — 完整 shell 命令字符串放行,
 //   只挡"高危破坏/碰核心数据"模式. 用户明确: 灵活一点, 少围栏, 核心的东西不碰不搞乱.
 // ============================================================================
+/**
+ * 自生命周期模式 (唯一的归类依据, 2026-10-01)。
+ * 为什么单列: 报错文案要按"是不是自生命周期"分岔, 原先用"模式串里有没有 bolloon 等词"猜 ⇒
+ * 数据目录那条 (串里含 .bolloon) 被误判, 把只读命令报成"会杀死宿主服务" ✗。
+ */
+const SELF_LIFECYCLE_PATTERNS = [
+    /\b(bolloon|bolloon-agent|bolloon-agent-service)\s+(restart|stop|kill|quit|shutdown)\b/i,
+    /\bpm2\s+(restart|stop|delete|kill)\s+[\w./-]*bolloon\b/i,
+    /\b(systemctl|service)\s+(restart|stop|kill)\s+[\w.-]*bolloon\b/i,
+    /\bpkill\s+(-[a-z]+\s+)*(-f\s+)?[\w./-]*bolloon\b/i,
+    /\btaskkill\s+[^|]*\/IM\s+[\w-]*bolloon\b/i,
+    /\btaskkill\s+[^|]*\/FI\s+\"?[^\"]*bolloon/i,
+];
 const TERMINAL_DENY_PATTERNS = [
     /\bsudo\b/, // 提权
     /\bsu\b/,
@@ -352,8 +432,15 @@ const TERMINAL_DENY_PATTERNS = [
     /\bwget\b[^|]*\|\s*(sh|bash)\b/,
     /\b:\(\)\s*\{[^}]*\}\s*;\s*:/, // fork bomb
     /\b(>|>>)\s*(\/etc\/|\/usr\/|\/System\/|\/bin\/|\/sbin\/)/, // 写系统目录
-    /[\/\s]\.bolloon\b/, // Bolloon 数据 (sessions/persona/keys; 覆盖 ~/.bolloon, $HOME/.bolloon, 空格.bolloon)
-    /[\/\s]\.(diap|hermes|openclaw)\b/, // 其他 agent 数据
+    // 2026-10-01 (用户报「偶尔会出反水 bug」): 原先 /[\/\s]\.bolloon\b/ 会匹配**任何**含 .bolloon 的路径
+    //   ⇒ 连 `ls ~/.bolloon/`、`cat .bolloon/x`、`grep -rn x .bolloon/` 这种**只读**命令都被拒;
+    //   而且因为模式串里带 "bolloon", 还会被下面的分类逻辑误判成"自生命周期命令", 打出
+    //   "命令会重启或杀死 bolloon 宿主服务" —— 门在打自己的脚。
+    //   收窄口径: **只在删/移/截断/重定向写入**这些数据目录时拒; 读 (ls/cat/grep/find/du/stat/mkdir -p) 一律放行。
+    /\b(rm|rmdir|mv|truncate|shred)\b[^|;]*[\s/]\.bolloon\b/,
+    /(>|>>)\s*[^\s]*[\s/]?\.bolloon\b/,
+    /\b(rm|rmdir|mv|truncate|shred)\b[^|;]*[\s/]\.(diap|hermes|openclaw)\b/, // 其他 agent 数据 (同样只拦写/删)
+    /(>|>>)\s*[^\s]*[\s/]?\.(diap|hermes|openclaw)\b/,
     /\brm\s+-rf\s+(\/|~|\*|\.|\$HOME)\b/, // 删根/家/通配
     /\bgit\s+push\b[^|]*\s+(-f|--force)/, // 强推
     /\bgit\s+reset\s+--hard\b/,
@@ -361,12 +448,7 @@ const TERMINAL_DENY_PATTERNS = [
     // 2026-08-11 (Hermes cron/lifecycle_guard 模式): 自生命周期命令 — agent 通过 terminal
     // 重启/杀掉自己宿主服务 (bolloon) 会形成复活循环: 服务死 → supervisor 复活 → 自动 resume
     // → 同一命令再自杀. 策略: 命令形状锚定 (只匹配真实命令标识符, 不匹配散文, 误报率低).
-    /\b(bolloon|bolloon-agent|bolloon-agent-service)\s+(restart|stop|kill|quit|shutdown)\b/i,
-    /\bpm2\s+(restart|stop|delete|kill)\s+[\w./-]*bolloon\b/i,
-    /\b(systemctl|service)\s+(restart|stop|kill)\s+[\w.-]*bolloon\b/i,
-    /\bpkill\s+(-[a-z]+\s+)*(-f\s+)?[\w./-]*bolloon\b/i,
-    /\btaskkill\s+[^|]*\/IM\s+[\w-]*bolloon\b/i,
-    /\btaskkill\s+[^|]*\/FI\s+"?[^"]*bolloon/i,
+    ...SELF_LIFECYCLE_PATTERNS,
 ];
 /** 检查完整 shell 命令 (terminal 工具用). denylist-only: 命中高危模式即拒, 否则放行. */
 export function checkTerminalCommand(rawCmd) {
@@ -379,7 +461,9 @@ export function checkTerminalCommand(rawCmd) {
             // 2026-08-11: 用户可见静态文案走 i18n 目录 (Hermes locales 模式); 目录不可用时中文直出
             let reason;
             try {
-                const isSelfLifecycle = /(bolloon|pm2|systemctl|service|pkill|taskkill)/.test(pattern.source);
+                // 2026-10-01: 归类改成**显式名单** —— 原先靠"模式串里有没有 bolloon 等词"猜, 于是
+                // 数据目录那条 (串里含 .bolloon) 被误判成自生命周期, 报错文案完全指错方向 ✗。
+                const isSelfLifecycle = SELF_LIFECYCLE_PATTERNS.includes(pattern);
                 reason = isSelfLifecycle
                     ? i18nT('guard.self_lifecycle_reason', undefined, { pattern: String(pattern) })
                     : i18nT('guard.deny_reason', undefined, { pattern: String(pattern) });
@@ -417,3 +501,15 @@ export function writePolicy(newPolicy) {
         return false;
     }
 }
+/**
+ * 错误信息里的白名单**短形态** (2026-10-01)。
+ * 为什么: 原来把**整张白名单**拼进 `reason` ✗ ⇒ 这条报错随后被塞进
+ *   ① 反思框(用户看到一屏白名单 ✗) ② 最终回复框(看着像"回复不完整" ✗ —— 其实是白名单切片 ✗)
+ *   ③ 熔断判定(长文本撞上无关关键词 ⇒ 被误判成"鉴权类错误" ⇒ 直接熔断停在 needs_human ✗)。
+ * 做法: 滤掉临时目录噪音(不该出现在给人看的错误里 ✓) + 只列前若干条 + 给总数 ✓。
+ */
+function shortRoots(entries, max = 6) {
+    const clean = entries.filter((e) => !/bolloon-bootstrap|\/var\/folders\/|\/tmp\//.test(e));
+    const shown = clean.slice(0, max).join(', ');
+    return clean.length > max ? `${shown} …(共 ${clean.length} 条)` : (shown || '(空)');
+}

package/dist/agents/skill-health.js

@@ -0,0 +1,90 @@
+/**
+ * 技能用量遥测 + 生命周期 (2026-10-01)。
+ * 形态要点: 遥测放**旁挂文件** ✓ —— 绝不写进用户自己写的 SKILL.md ✗(那是用户的文件 ✓)。
+ * 生命周期: active → stale(久未用) → archived; `pinned` 可退出自动流转 ✓。
+ * 边界(如实): 本模块只**计算状态并给建议** ✓, **不自动移动/删除任何技能文件** ✗(那是破坏性动作, 交人决定 ✓)。
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export function usagePath(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'skills', '.usage.json');
+}
+function load(home) {
+    try {
+        const o = JSON.parse(fs.readFileSync(usagePath(home), 'utf-8'));
+        return o && typeof o === 'object' ? o : {};
+    }
+    catch {
+        return {};
+    }
+}
+function save(m, home) {
+    try {
+        const p = usagePath(home);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(m), { mode: 0o600 });
+    }
+    catch { /* 遥测失败不影响工具调用 */ }
+}
+/** 用了一次(读技能时调 ✓); 失败只吞 ✓ */
+export function bumpUsage(skill, home, now = Date.now()) {
+    try {
+        const m = load(home);
+        const cur = m[skill] || { count: 0, lastUsedAt: 0 };
+        m[skill] = { ...cur, count: cur.count + 1, lastUsedAt: now };
+        save(m, home);
+    }
+    catch { /* best-effort */ }
+}
+/** 记下创建者(自审 / 用户点名) */
+export function markCreatedBy(skill, by, home, now = Date.now()) {
+    try {
+        const m = load(home);
+        const cur = m[skill] || { count: 0, lastUsedAt: 0 };
+        m[skill] = { ...cur, createdBy: by, lastUsedAt: cur.lastUsedAt || now };
+        save(m, home);
+    }
+    catch { /* best-effort */ }
+}
+/** 钉住(退出自动流转) */
+export function setPinned(skill, pinned, home) {
+    try {
+        const m = load(home);
+        const cur = m[skill] || { count: 0, lastUsedAt: 0 };
+        m[skill] = { ...cur, pinned };
+        save(m, home);
+    }
+    catch { /* best-effort */ }
+}
+export const STALE_AFTER_MS = 45 * 24 * 3600 * 1000; // 45 天没用 ⇒ stale
+/** 生命周期(只算不给动作 ✓): active / stale / archived-eligible */
+export function lifecycleOf(skill, home, now = Date.now()) {
+    const u = load(home)[skill];
+    if (!u)
+        return { state: 'unknown', reason: '旁挂遥测里没有它(可能是导入/内置技能)', count: 0, pinned: false };
+    if (u.pinned)
+        return { state: 'active', reason: '已 pinned(退出自动流转)', count: u.count, pinned: true };
+    const idle = now - (u.lastUsedAt || 0);
+    return {
+        state: idle > STALE_AFTER_MS ? 'stale' : 'active',
+        reason: idle > STALE_AFTER_MS ? `已 ${Math.round(idle / 86400000)} 天未用(仅状态, 不会自动删 ✓)` : `近用过(${u.count} 次)`,
+        count: u.count,
+        pinned: false,
+    };
+}
+/** 汇总(给面板/工具用 ✓) */
+export function usageSummary(home, now = Date.now()) {
+    const m = load(home);
+    let active = 0, stale = 0, pinned = 0;
+    for (const k of Object.keys(m)) {
+        const l = lifecycleOf(k, home, now);
+        if (l.pinned)
+            pinned++;
+        if (l.state === 'active')
+            active++;
+        else if (l.state === 'stale')
+            stale++;
+    }
+    return { total: Object.keys(m).length, active, stale, pinned };
+}

package/dist/agents/skill-ledger.js

@@ -0,0 +1,129 @@
+/**
+ * 技能账本 + 单条回滚 + 写来源隔离 (2026-10-01, 按"账本而非闸门"的形态做)。
+ *
+ * 三件事:
+ *  ① **账本**: 每次技能变更追加一条 JSONL(前后清单 + 内容寻址备份)⇒ 可单条回滚 ✓。
+ *     放 JSONL 不放数据库: 耐久 · 可 grep · 数据库重置也不丢 ✓。
+ *  ② **单条回滚**: 按 id 还原那一次变更; **唯独回滚是 fail-closed** ✓(安全快照拿不到就拒绝回滚,
+ *     绝不"半还原"✗); 其余全部吞错只记日志(账本坏掉不该挡住干活 ✓)。
+ *  ③ **写来源隔离**: 用 AsyncLocalStorage 区分"用户点名要的写"(foreground ✓)与
+ *     "自审/复盘产生的写"(review ✓)⇒ 自审**只许治理自己造出来的技能** ✓, 用户要的归用户 ✓。
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+const originStore = new AsyncLocalStorage();
+/** 在"自审"上下文里跑一段(其余一律按 foreground ✓) */
+export function runWithWriteOrigin(origin, fn) {
+    return originStore.run({ origin }, fn);
+}
+export function currentWriteOrigin() {
+    return originStore.getStore()?.origin ?? 'foreground';
+}
+export function isReviewWrite() {
+    return currentWriteOrigin() === 'review';
+}
+export function ledgerPath(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'skills', '.skill-ledger.jsonl');
+}
+export function blobsDir(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'skills', '.ledger-blobs');
+}
+function sha256(text) {
+    return crypto.createHash('sha256').update(text, 'utf-8').digest('hex');
+}
+/** 把内容按哈希存进 blobs(已存在则复用 ✓ 天然去重) */
+function putBlob(text, home) {
+    const h = sha256(text);
+    const p = path.join(blobsDir(home), h);
+    try {
+        if (!fs.existsSync(p)) {
+            fs.mkdirSync(path.dirname(p), { recursive: true });
+            fs.writeFileSync(p, text, { mode: 0o600 });
+        }
+    }
+    catch { /* 备份失败 ⇒ 由调用方决定是否允许这次变更(见 captureBefore) */ }
+    return h;
+}
+/** 变更前快照: 返回 beforeSha(拿不到安全快照时返回 undefined ⇒ 回滚能力缺失, 调用方须知道 ✓) */
+export function captureSkillBefore(file, home) {
+    try {
+        const text = fs.readFileSync(file, 'utf-8');
+        return { beforeSha: putBlob(text, home), bytesBefore: text.length };
+    }
+    catch {
+        return {}; // 文件不存在(新建)= 正常; 读不到 = 快照缺失
+    }
+}
+/** 追加一条账本(吞错只记日志 ✓ —— 账本坏掉不该挡住干活) */
+export function appendLedger(entry, home) {
+    const full = { id: entry.id || crypto.randomBytes(8).toString('hex'), at: entry.at ?? Date.now(), ...entry };
+    try {
+        const p = ledgerPath(home);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.appendFileSync(p, JSON.stringify(full) + '\n', { mode: 0o600 });
+    }
+    catch { /* telemetry, not a gate */ }
+    return full;
+}
+export function readLedger(home) {
+    try {
+        const raw = fs.readFileSync(ledgerPath(home), 'utf-8');
+        const out = [];
+        for (const line of raw.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch { /* 坏行跳过 */ }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/** 这个技能是不是"自审造出来的"?(决定自审有没有资格改它 ✓) */
+export function isAgentCreated(skill, home) {
+    return readLedger(home).some((e) => e.skill === skill && e.tool === 'create_skill' && e.origin === 'review');
+}
+/**
+ * 自审写前的资格检查(只读判断, 不改任何东西 ✓):
+ * 自审只许动**自己造出来**的技能 ✓; 用户点名要的归用户 ✓。
+ */
+export function reviewMayTouch(skill, home) {
+    if (!isReviewWrite())
+        return { ok: true, reason: 'foreground(用户点名要的写)' };
+    return isAgentCreated(skill, home)
+        ? { ok: true, reason: 'review(该技能由自审创建, 可治理)' }
+        : { ok: false, reason: '该技能不是自审创建的(用户点名要的归用户)⇒ 自审只记候选, 不动它' };
+}
+/**
+ * 单条回滚: 把某次变更前的快照还原回去 ✓。
+ * **fail-closed**: 快照缺失/内容哈希对不上 ⇒ 拒绝(绝不半还原 ✗)。
+ */
+export function rollbackEntry(id, home) {
+    const entry = readLedger(home).find((e) => e.id === id);
+    if (!entry)
+        return { ok: false, reason: `账本里没有 id=${id}` };
+    if (entry.tool === 'create_skill') {
+        // 创建类变更: 回滚 = 删掉那个文件(要用户明确同意 ⇒ 这里只报告, 不擅自删 ✗)
+        return { ok: false, reason: '该条是"新建技能"; 回滚等于删除文件 —— 需要你明确同意, 我不擅自删' };
+    }
+    if (!entry.beforeSha)
+        return { ok: false, reason: '该条没有变更前快照 ⇒ 拒绝回滚(fail-closed, 不做半还原)' };
+    try {
+        const blob = fs.readFileSync(path.join(blobsDir(home), entry.beforeSha), 'utf-8');
+        if (sha256(blob) !== entry.beforeSha)
+            return { ok: false, reason: '快照内容与哈希不符 ⇒ 拒绝回滚' };
+        fs.writeFileSync(entry.file, blob, { mode: 0o600 });
+        appendLedger({ origin: 'foreground', tool: 'rollback', skill: entry.skill, file: entry.file, beforeSha: entry.afterSha, afterSha: entry.beforeSha, note: `回到 ${entry.id}` }, home);
+        return { ok: true, reason: `已回滚到变更前(${entry.id})`, restored: entry.file };
+    }
+    catch (e) {
+        return { ok: false, reason: `回滚失败: ${String(e?.message || e).slice(0, 120)}` };
+    }
+}