@bolloon/bolloon-agent 0.5.3 → 0.5.5

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/session-store.js

@@ -102,6 +102,59 @@ export class SessionStore {
      * fs.writeFile 抛 EINVAL. 修法: filename 层 escape `:` → `__`, key 保持不变
      * (load/save/listKeys/deleteKey 全部透明).
      */
+    /**
+     * **写**的时候用这个 —— 与 resolveExisting 的区别: 不存在**不抛错**, 返回规范路径 (等于新建)。
+     *
+     * 2026-09-30 回归事故: 我把 resolveExisting (读语义, 不存在就抛 not found) 批量替换进了
+     *   saveMessages ⇒ 退出存档对"还没落盘的新会话"直接抛 `session not found`
+     *   (leo 贴的 `⚠ session 存档失败: SessionStore: session not found: 20260930_175348_870c70`)。
+     *   写路径必须容忍"还没有文件" —— 那正是它要创建的东西。
+     */
+    async resolveWritePath(key) {
+        const canonical = this.pathFor(key);
+        try {
+            await fs.access(canonical);
+            return canonical;
+        }
+        catch { /* 试老名 */ }
+        const legacy = path.join(this.cacheDir, `${key}.json`);
+        try {
+            await fs.access(legacy);
+            return legacy;
+        }
+        catch { /* 新会话 */ }
+        return canonical;
+    }
+    /**
+     * 读的时候用这个 —— 兼容**老文件名**。
+     *
+     * 2026-09-30 发现: 早期版本直接把 `channelId:sessionId` 当文件名写盘 (`real-123:default.json`),
+     *   后来 Windows 兼容改成 filenameEscape (`:` → `__`), 但**老文件没迁移** ⇒ 用 pathFor 去读
+     *   老会话一律 ENOENT (`/sessions` 里那些 `real-*:default` 全是 Preview `—`, 也续不上)。
+     *   这里: 先试新名, 不存在再试老名; 老名存在时**顺手迁移**成新名 (迁移失败就继续读老名)。
+     */
+    async resolveExisting(key) {
+        const canonical = this.pathFor(key);
+        try {
+            await fs.access(canonical);
+            return canonical;
+        }
+        catch { /* 试老名 */ }
+        const legacy = path.join(this.cacheDir, `${key}.json`);
+        try {
+            await fs.access(legacy);
+            try {
+                await fs.rename(legacy, canonical);
+            }
+            catch {
+                return legacy;
+            } // 迁移失败也能读
+            return canonical;
+        }
+        catch {
+            throw new Error(`SessionStore: session not found: ${key}`);
+        }
+    }
     pathFor(key) {
         if (!key || key.includes('/') || key.includes('..')) {
             throw new Error(`SessionStore: invalid key ${JSON.stringify(key)}`);
@@ -135,7 +188,7 @@ export class SessionStore {
                 totalCount: messages.length,
             },
         };
-        const filePath = this.pathFor(key);
+        const filePath = await this.resolveWritePath(key); // 写路径: 新会话就建 (不抛 not found)
         const tmpPath = `${filePath}.tmp`;
         await fs.writeFile(tmpPath, JSON.stringify(payload, null, 2), 'utf-8');
         await fs.rename(tmpPath, filePath);
@@ -177,7 +230,7 @@ export class SessionStore {
                 totalCount: messages.length,
             },
         };
-        const filePath = this.pathFor(key);
+        const filePath = this.pathFor(key); // 同步保存一律写规范文件名
         const tmpPath = `${filePath}.tmp`;
         fsSyncWrite(tmpPath, JSON.stringify(payload, null, 2));
         fsSyncRename(tmpPath, filePath);
@@ -192,7 +245,11 @@ export class SessionStore {
         if (!key || key.includes('/') || key.includes('..')) {
             throw new Error(`SessionStore: invalid key ${JSON.stringify(key)}`);
         }
-        const filePath = this.pathFor(key);
+        // 2026-09-30 回归修复: 读路径**不许**在"会话不存在"时抛错 —— 仓里的契约是
+        //   `loadMessages('cli:nonexistent') === null` (见 src/test/session-store.test.ts)。
+        //   用容错解析 (不存在 ⇒ 返回规范路径), 随后的 readFile 命中 ENOENT ⇒ return null。
+        //   老文件名(`real-123:default.json` 那批)由 resolveWritePath 兼容: 存在就返回老路径。
+        const filePath = await this.resolveWritePath(key);
         let raw;
         try {
             raw = await fs.readFile(filePath, 'utf-8');
@@ -222,6 +279,90 @@ export class SessionStore {
             return [];
         }
     }
+    /**
+     * 列最近改动的会话 (按 mtime 倒序), 带条数与首条用户消息预览。
+     *
+     * 2026-09-30 (leo: 「/session 没有反应, 没展示最新记录, 无法选择继续」): 只为"选一个继续"服务 ——
+     *   **只解析最新的 limit 个文件**(缓存目录可能上千个, 全量解析会卡住输入), 解析失败的那条如实记 0。
+     */
+    async listRecent(limit = 10) {
+        const out = [];
+        let files = [];
+        try {
+            files = await fs.readdir(this.cacheDir);
+        }
+        catch {
+            return out;
+        }
+        const cands = [];
+        for (const f of files) {
+            if (!f.endsWith('.json') || f.endsWith('.tmp'))
+                continue;
+            try {
+                const st = await fs.stat(path.join(this.cacheDir, f));
+                cands.push({ key: SessionStore.filenameUnescape(f.slice(0, -'.json'.length)), mtimeMs: st.mtimeMs });
+            }
+            catch { /* 单条 stat 失败跳过 */ }
+        }
+        cands.sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const c of cands.slice(0, Math.max(1, limit))) {
+            let messages = 0;
+            let preview = '';
+            let title = c.key; // 会话文件里没有 title 字段 ⇒ 默认就是 key (web 侧才有会话名)
+            try {
+                // 兼容老文件名 (`real-123:default.json` 未转义那批) —— 读不到规范名就试原名
+                let text = '';
+                try {
+                    text = await fs.readFile(this.pathFor(c.key), 'utf-8');
+                }
+                catch {
+                    text = await fs.readFile(path.join(this.cacheDir, `${c.key}.json`), 'utf-8');
+                }
+                const raw = JSON.parse(text);
+                const arr = Array.isArray(raw) ? raw : (raw?.messages || []);
+                messages = Array.isArray(arr) ? arr.length : 0;
+                const md = (!Array.isArray(raw) && raw?.metadata) || {};
+                if (typeof md.title === 'string' && md.title.trim())
+                    title = md.title.trim();
+                const mdPreview = typeof md.preview === 'string' ? md.preview.trim() : '';
+                // 预览要用**真实用户话**, 跳过自动注入的上下文块 (否则全是 <!-- current-turn … -->)
+                const isInjected = (x) => !!x && (/^<!--/.test(x.trim()) || /^#\s*你的项目上下文/.test(x.trim()) || /^\[cron\]/.test(x.trim()));
+                const first = (Array.isArray(arr) ? arr : []).find((m) => m && m.role === 'user' && m.content && !isInjected(String(m.content)));
+                preview = mdPreview || String(first?.content || '').replace(/\s+/g, ' ').trim().slice(0, 120);
+            }
+            catch { /* 损坏文件: 仍列出, 只是 0 条无预览 */ }
+            out.push({ key: c.key, title, mtimeMs: c.mtimeMs, messages, preview });
+        }
+        return out;
+    }
+    /**
+     * 合并写回会话文件的 metadata (原子: 先写 .tmp 再 rename)。
+     *   2026-09-30 (leo: 「Title/Preview 要有内容, 使用 AI 来总结进去」): AI 总结结果落在
+     *   `metadata.{title,preview,summarizedAt}`, **只算一次**, 后续 /sessions 直接读。
+     *   原子写是硬要求 —— 会话文件是用户的会话历史, 半截文件比没有标题糟得多。
+     */
+    async updateMetadata(key, patch) {
+        if (!key || key.includes('/') || key.includes('..'))
+            throw new Error(`SessionStore: invalid key ${JSON.stringify(key)}`);
+        const file = await this.resolveWritePath(key);
+        let raw = null;
+        try {
+            raw = JSON.parse(await fs.readFile(file, 'utf-8'));
+        }
+        catch (e) {
+            if (e?.code !== 'ENOENT')
+                throw new Error(`会话文件读不了 (${file}): ${String(e?.message || e).slice(0, 120)}`);
+            // 还没有文件 ⇒ 建成只有 metadata 的会话 (元数据更新对新会话应当有效, 不是错误)
+        }
+        const next = raw === null
+            ? { key, messages: [], metadata: { ...patch } }
+            : Array.isArray(raw)
+                ? { key, messages: raw, metadata: { ...patch } }
+                : { ...raw, metadata: { ...(raw?.metadata || {}), ...patch } };
+        const tmp = `${file}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(next, null, 2), 'utf-8');
+        await fs.rename(tmp, file);
+    }
     /** 删一条 session — 失败抛错. */
     async deleteKey(key) {
         if (!key || key.includes('/') || key.includes('..')) {

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 };
+}