@bolloon/bolloon-agent 0.3.47 → 0.3.49

package/dist/agents/knowledge-organizer.js

@@ -0,0 +1,470 @@
+/**
+ * knowledge-organizer.ts — 自动整理心跳 · 知识层整理 (2026-08-10)
+ *
+ * 目的: 自动整理不止 skills — 每次整理 tick 还维护 Bolloon 的"自我认知"知识层:
+ *
+ *   1. archiveContextOs      归档 Context OS 资产层 (快照 + tmp 清理)
+ *   2. tidySocialRelations   整理外部社交关系 (known_peers + dunbar tier 统计/失联)
+ *   3. tidyExternalAgents    整理外部智能体描述 (peers/<pk>/agents/*)
+ *   4. tidyInternalAgents    整理内部智能体描述 (channels persona + persona/<agentId>/)
+ *   5. maintainJudgeness     judgeness 内容维护 (descriptions 归档)
+ *   6. understandProjects    其他项目目录的理解 (扫描项目 → 04-Projects 索引)
+ *   7. understandUserProfile 用户画像的理解 (persona user.md + 01-Me → 画像快照)
+ *   8. archiveRecentLogs     最近记录的日志归档 (goals/engine 等 jsonl)
+ *   9. maintainGoals         用户长期/短期目标维护 (goals → 03-Current 摘要)
+ *
+ * 设计原则:
+ *   - 每个整理器是纯函数: 输入 home/cwd (可注入), 输出 OrganizeSection, 全部 try/catch —
+ *     单个失败不阻塞其他 (整理是尽力而为, 不抛错).
+ *   - 默认无 LLM (文件统计/归档/快照); 传 llm 时增强"理解类"整理器 (项目/画像/目标摘要).
+ *   - runKnowledgeOrganize 串行跑全部 (顺序稳定, 日志可读), 汇总 sections.
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+/** 读取 JSON 文件, 失败返回 null (安静) */
+async function readJson(p) {
+    try {
+        return JSON.parse(await fs.readFile(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 读取目录下直接子项 (文件+目录), 失败返回 [] */
+async function readDir(p) {
+    try {
+        return await fs.readdir(p);
+    }
+    catch {
+        return [];
+    }
+}
+/** 目录下 *.md 文件 (一层), 带 mtime */
+async function listMd(p) {
+    const entries = await readDir(p);
+    const out = [];
+    for (const e of entries) {
+        if (!e.endsWith('.md'))
+            continue;
+        try {
+            const st = await fs.stat(path.join(p, e));
+            out.push({ file: e, mtime: st.mtimeMs });
+        }
+        catch { /* 跳过 */ }
+    }
+    return out;
+}
+// ───────────────────────── 1. Context OS 归档 ─────────────────────────
+const CONTEXT_OS_LAYERS = [
+    '01-Me', '02-Network', '03-Current', '04-Projects', '05-Prompts',
+    '06-Protocols', '07-Knowledge', '08-Insights', '09-Tools', '10-Skills',
+    '11-Write', '12-Analysis',
+];
+/** 归档 Context OS: 统计各层资产 + 打快照清单 + 清理过期 tmp 草稿 */
+export async function archiveContextOs(home) {
+    const root = path.join(home, '.bolloon', 'context-os');
+    const snapshotsDir = path.join(root, 'snapshots');
+    let handled = 0;
+    let totalAssets = 0;
+    let archivedTmp = 0;
+    try {
+        await fs.mkdir(snapshotsDir, { recursive: true });
+        // 统计各层资产 (直接子文件, 排除 README.md)
+        const layerStats = [];
+        for (const layer of CONTEXT_OS_LAYERS) {
+            const dir = path.join(root, layer);
+            const files = (await readDir(dir)).filter((f) => !f.startsWith('.') && f !== 'README.md');
+            if (files.length > 0)
+                layerStats.push({ layer, count: files.length });
+            totalAssets += files.length;
+        }
+        // tmp/ 过期草稿 (>1 天未改) → 归档到 snapshots/trash-<ts>/
+        const tmpDir = path.join(root, 'tmp');
+        try {
+            const tmpEntries = await fs.readdir(tmpDir);
+            const now = Date.now();
+            const trashDir = path.join(snapshotsDir, `trash-${Date.now()}`);
+            for (const f of tmpEntries) {
+                const fp = path.join(tmpDir, f);
+                try {
+                    const st = await fs.stat(fp);
+                    if (now - st.mtimeMs > 24 * 3600 * 1000) {
+                        await fs.mkdir(trashDir, { recursive: true });
+                        await fs.rename(fp, path.join(trashDir, f));
+                        archivedTmp++;
+                    }
+                }
+                catch { /* 单个失败跳过 */ }
+            }
+        }
+        catch { /* tmp 不存在跳过 */ }
+        // 打快照清单 (轻量归档, 幂等)
+        const manifest = {
+            ts: new Date().toISOString(),
+            layers: layerStats,
+            totalAssets,
+            archivedTmp,
+        };
+        await fs.writeFile(path.join(snapshotsDir, `manifest-${Date.now()}.json`), JSON.stringify(manifest, null, 2), 'utf-8');
+        handled = totalAssets;
+        return {
+            key: 'context-os', label: 'Context OS 归档',
+            handled,
+            summary: `${layerStats.length} 层 · ${totalAssets} 个资产${archivedTmp > 0 ? ` · 归档 tmp ${archivedTmp} 个` : ''}`,
+        };
+    }
+    catch (e) {
+        return { key: 'context-os', label: 'Context OS 归档', handled, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 2. 外部社交关系 ─────────────────────────
+/** 整理外部社交关系: known_peers 统计 (活跃/失联) + dunbar tier 分布 */
+export async function tidySocialRelations(home) {
+    try {
+        const peers = (await readJson(path.join(home, '.bolloon', 'known_peers.json')))?.peers || {};
+        const peerEntries = Object.entries(peers);
+        const now = Date.now();
+        let live = 0;
+        let stale = 0;
+        for (const [, p] of peerEntries) {
+            const last = p?.lastConnectedAt ? new Date(p.lastConnectedAt).getTime() : 0;
+            if (now - last < 30 * 24 * 3600 * 1000)
+                live++;
+            else
+                stale++;
+        }
+        // dunbar tier 分布
+        const tierCount = {};
+        const peersDir = path.join(home, '.bolloon', 'peers');
+        const peerDirs = await readDir(peersDir);
+        for (const pk of peerDirs) {
+            const tier = await readJson(path.join(peersDir, pk, 'dunbar-tier.json'));
+            const t = tier?.tier || 'unknown';
+            tierCount[t] = (tierCount[t] || 0) + 1;
+        }
+        const tierDesc = Object.entries(tierCount)
+            .map(([t, n]) => `${t}=${n}`)
+            .join(' ');
+        return {
+            key: 'social', label: '外部社交关系',
+            handled: peerEntries.length,
+            summary: `${peerEntries.length} peers · 活跃 ${live} · 失联 ${stale} · tier[${tierDesc}]`,
+        };
+    }
+    catch (e) {
+        return { key: 'social', label: '外部社交关系', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 3. 外部智能体描述 ─────────────────────────
+/** 整理外部智能体描述: peers/<pk>/agents/ 下的远端 manifest */
+export async function tidyExternalAgents(home) {
+    try {
+        const peersDir = path.join(home, '.bolloon', 'peers');
+        const peerDirs = await readDir(peersDir);
+        let manifests = 0;
+        let peersWithAgents = 0;
+        for (const pk of peerDirs) {
+            const agentDir = path.join(peersDir, pk, 'agents');
+            const files = (await readDir(agentDir)).filter((f) => f.endsWith('.json') || f.endsWith('.md'));
+            if (files.length > 0) {
+                manifests += files.length;
+                peersWithAgents++;
+            }
+        }
+        return {
+            key: 'agents-ext', label: '外部智能体描述',
+            handled: manifests,
+            summary: `${manifests} 个远端 agent (${peersWithAgents} 个 peer)`,
+        };
+    }
+    catch (e) {
+        return { key: 'agents-ext', label: '外部智能体描述', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 4. 内部智能体描述 ─────────────────────────
+/** 整理内部智能体描述: channels.json persona + persona/<agentId>/ 6 文件 */
+export async function tidyInternalAgents(home) {
+    try {
+        // channels.json 真实位置在 ~/.bolloon/sessions/channels.json (server-storage 主路径), 兼容旧 ~/.bolloon/channels.json
+        const sessionsFile = path.join(home, '.bolloon', 'sessions', 'channels.json');
+        const legacyFile = path.join(home, '.bolloon', 'channels.json');
+        let channelsRaw = await readJson(sessionsFile);
+        if (!channelsRaw)
+            channelsRaw = await readJson(legacyFile);
+        // channels.json 是纯数组 (server-storage 主格式), 兼容旧 {channels:[...]} 对象形态
+        const channels = Array.isArray(channelsRaw) ? channelsRaw : channelsRaw?.channels || [];
+        let withPersona = 0;
+        for (const c of channels) {
+            if (c?.persona?.name || c?.persona?.description)
+                withPersona++;
+        }
+        const personaDir = path.join(home, '.bolloon', 'persona');
+        const agentDirs = (await readDir(personaDir)).filter((d) => !d.startsWith('.'));
+        let personaFiles = 0;
+        for (const d of agentDirs) {
+            personaFiles += (await readDir(path.join(personaDir, d))).filter((f) => f.endsWith('.md')).length;
+        }
+        return {
+            key: 'agents-int', label: '内部智能体描述',
+            handled: channels.length,
+            summary: `${channels.length} channels (${withPersona} 有 persona) · ${agentDirs.length} 个 persona 目录 · ${personaFiles} 个文档`,
+        };
+    }
+    catch (e) {
+        return { key: 'agents-int', label: '内部智能体描述', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 5. judgeness 维护 ─────────────────────────
+/** judgeness 内容维护: descriptions 统计 + 归档 >30 天未改的旧描述 */
+export async function maintainJudgeness(home) {
+    try {
+        const descDir = path.join(home, '.bolloon', 'judgeness', 'descriptions');
+        const files = await listMd(descDir);
+        const now = Date.now();
+        let archived = 0;
+        const archiveDir = path.join(descDir, '..', 'archive');
+        for (const f of files) {
+            if (now - f.mtime > 30 * 24 * 3600 * 1000) {
+                try {
+                    await fs.mkdir(archiveDir, { recursive: true });
+                    await fs.rename(path.join(descDir, f.file), path.join(archiveDir, f.file));
+                    archived++;
+                }
+                catch { /* 单个失败跳过 */ }
+            }
+        }
+        return {
+            key: 'judgeness', label: 'judgeness 维护',
+            handled: files.length,
+            summary: `${files.length} 条描述${archived > 0 ? ` · 归档 ${archived} 条旧描述` : ''}`,
+        };
+    }
+    catch (e) {
+        return { key: 'judgeness', label: 'judgeness 维护', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 6. 其他项目目录的理解 ─────────────────────────
+const PROJECT_MANIFESTS = ['package.json', 'pyproject.toml', 'go.mod', 'Cargo.toml', 'pom.xml', 'Makefile'];
+/** 扫描的候选项目根目录 (相对 home) — 覆盖用户常见项目位置 */
+const PROJECT_SCAN_ROOTS = ['Downloads', 'lean', 'DIAP-TS-SDK', 'alou', 'projects', 'workspace', 'dev', 'code', 'src'];
+/** 扫描 home 下的项目目录 (深度 1, 找 manifest), 跳过 node_modules/.git/dist */
+export async function scanProjects(home) {
+    const out = [];
+    for (const rootName of PROJECT_SCAN_ROOTS) {
+        const root = path.join(home, rootName);
+        const entries = await readDir(root);
+        for (const e of entries) {
+            if (e.startsWith('.') || e === 'node_modules' || e === 'Library')
+                continue;
+            const dir = path.join(root, e);
+            let type = '';
+            try {
+                const st = await fs.stat(dir);
+                if (!st.isDirectory())
+                    continue;
+                for (const m of PROJECT_MANIFESTS) {
+                    try {
+                        await fs.access(path.join(dir, m));
+                        type = m;
+                        break;
+                    }
+                    catch { /* 下一个 */ }
+                }
+                if (!type)
+                    continue;
+                out.push({ name: e, path: dir, type, mtime: st.mtimeMs });
+            }
+            catch { /* 跳过 */ }
+        }
+    }
+    // 去重 (同一目录可能被多个 root 覆盖)
+    const seen = new Set();
+    return out.filter((p) => {
+        if (seen.has(p.path))
+            return false;
+        seen.add(p.path);
+        return true;
+    });
+}
+/** 其他项目目录的理解: 扫描项目 → 更新 04-Projects/项目理解.md (llm 可选增强) */
+export async function understandProjects(home, llm) {
+    try {
+        const projects = await scanProjects(home);
+        const now = new Date().toISOString().slice(0, 10);
+        let extra = '';
+        if (llm && projects.length > 0) {
+            try {
+                const lines = projects.map((p) => `- ${p.name} (${p.type})`).join('\n');
+                const resp = await llm(`以下是用户 ${os.homedir()} 下的项目清单, 请用一句话概括每个项目可能是什么 (技术栈/用途), 按原样输出每行:\n${lines}\n\n输出格式: - 项目名: 一句话理解`);
+                extra = `\n\n## LLM 理解 (${now})\n${resp.slice(0, 2000)}`;
+            }
+            catch { /* LLM 增强失败用模板 */ }
+        }
+        const sorted = [...projects].sort((a, b) => b.mtime - a.mtime);
+        const body = `# 项目理解索引 (自动整理心跳, ${now})\n\n` +
+            `> 由自动整理心跳生成 — 扫描 home 下常见项目目录的 manifest (package.json / pyproject.toml / go.mod / Cargo.toml).\n\n` +
+            `## 项目清单 (${projects.length})\n\n` +
+            sorted.map((p) => `- **${p.name}** \`${p.type}\` — ${p.path}`).join('\n') +
+            extra + '\n';
+        const outFile = path.join(home, '.bolloon', 'context-os', '04-Projects', '项目理解.md');
+        await fs.mkdir(path.dirname(outFile), { recursive: true });
+        await fs.writeFile(outFile, body, 'utf-8');
+        return {
+            key: 'projects', label: '项目目录理解',
+            handled: projects.length,
+            summary: `${projects.length} 个项目已索引 → 04-Projects/项目理解.md`,
+        };
+    }
+    catch (e) {
+        return { key: 'projects', label: '项目目录理解', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 7. 用户画像的理解 ─────────────────────────
+/** 用户画像的理解: 汇总 persona/<agentId>/user.md + context-os/01-Me/ → 画像快照 */
+export async function understandUserProfile(home, llm) {
+    try {
+        const personaDir = path.join(home, '.bolloon', 'persona');
+        const agentDirs = (await readDir(personaDir)).filter((d) => !d.startsWith('.'));
+        const meDir = path.join(home, '.bolloon', 'context-os', '01-Me');
+        const meFiles = (await listMd(meDir)).filter((f) => f.file !== 'README.md');
+        let handled = agentDirs.length + meFiles.length;
+        const now = new Date().toISOString().slice(0, 10);
+        // 读 user.md 内容片段 (每 agent 目录)
+        let profileSnippet = '';
+        for (const d of agentDirs) {
+            const userMd = path.join(personaDir, d, 'user.md');
+            try {
+                const raw = (await fs.readFile(userMd, 'utf-8')).slice(0, 800);
+                if (raw.trim())
+                    profileSnippet += `\n### ${d}/user.md\n${raw}\n`;
+            }
+            catch { /* 无 user.md */ }
+        }
+        let extra = '';
+        if (llm && (profileSnippet || meFiles.length > 0)) {
+            try {
+                const resp = await llm(`以下是用户的画像素材 (persona user.md + 01-Me 资产). 请提炼 3-5 条"稳定的用户画像要点" (身份/偏好/目标/工作方式):\n${profileSnippet.slice(0, 3000)}\n\n输出要点列表 (每条一行, 以 - 开头)`);
+                extra = `\n\n## LLM 画像要点 (${now})\n${resp.slice(0, 2000)}`;
+            }
+            catch { /* LLM 增强失败 */ }
+        }
+        const meNames = meFiles.map((f) => f.file).join('; ');
+        const body = `# 用户画像快照 (自动整理心跳, ${now})\n\n` +
+            `> 由自动整理心跳汇总 persona user.md + Context OS 01-Me. 详细档案见 01-Me/个人档案.md.\n\n` +
+            `## 画像素材来源\n- persona 目录: ${agentDirs.length} 个 (${agentDirs.join(', ') || '无'})\n- 01-Me 资产: ${meFiles.length} 个 (${meNames || '无'})` +
+            (profileSnippet ? `\n\n## user.md 内容片段\n${profileSnippet.slice(0, 3000)}` : '') +
+            extra + '\n';
+        const outFile = path.join(meDir, '用户画像快照.md');
+        await fs.mkdir(meDir, { recursive: true });
+        await fs.writeFile(outFile, body, 'utf-8');
+        return {
+            key: 'user', label: '用户画像理解',
+            handled,
+            summary: `${agentDirs.length} 个 persona + ${meFiles.length} 个 01-Me 资产 → 用户画像快照`,
+        };
+    }
+    catch (e) {
+        return { key: 'user', label: '用户画像理解', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 8. 最近记录的日志归档 ─────────────────────────
+/** 最近记录的日志: 统计 + 归档 >30 天未改的 jsonl 旧文件 (排除活跃依赖: goals/event.jsonl) */
+export async function archiveRecentLogs(home) {
+    try {
+        const root = path.join(home, '.bolloon');
+        // 候选日志目录: goals/ engine/ trajectories/ sessions/jsonl/ sidechains/ (存在的才扫)
+        const logDirs = ['goals', 'engine', 'trajectories', path.join('sessions', 'jsonl'), 'sidechains'];
+        let total = 0;
+        let archived = 0;
+        const now = Date.now();
+        // goal-resume.ts 依赖 goals/event.jsonl 恢复目标事件 — 永不归档
+        const protectedFiles = new Set(['event.jsonl']);
+        for (const rel of logDirs) {
+            const dir = path.join(root, rel);
+            const entries = await readDir(dir);
+            for (const e of entries) {
+                if (!e.endsWith('.jsonl') && !e.endsWith('.log'))
+                    continue;
+                if (protectedFiles.has(e))
+                    continue;
+                total++;
+                try {
+                    const st = await fs.stat(path.join(dir, e));
+                    if (now - st.mtimeMs > 30 * 24 * 3600 * 1000) {
+                        const archiveDir = path.join(dir, 'archive');
+                        await fs.mkdir(archiveDir, { recursive: true });
+                        await fs.rename(path.join(dir, e), path.join(archiveDir, e));
+                        archived++;
+                    }
+                }
+                catch { /* 单个失败跳过 */ }
+            }
+        }
+        return {
+            key: 'logs', label: '最近日志归档',
+            handled: total,
+            summary: `${total} 个日志文件${archived > 0 ? ` · 归档 ${archived} 个旧文件` : ''}`,
+        };
+    }
+    catch (e) {
+        return { key: 'logs', label: '最近日志归档', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 9. 用户目标维护 ─────────────────────────
+/** 用户长期/短期目标维护: goals/queue.json + event.jsonl + 03-Current → 目标摘要 */
+export async function maintainGoals(home, llm) {
+    try {
+        const goalsDir = path.join(home, '.bolloon', 'goals');
+        const queue = (await readJson(path.join(goalsDir, 'queue.json'))) || {};
+        // queue.json 结构未知, 兼容 object/array
+        const queueItems = Array.isArray(queue) ? queue : Object.values(queue).filter((v) => v && typeof v === 'object');
+        const events = await readDir(goalsDir);
+        const now = new Date().toISOString().slice(0, 10);
+        const currentDir = path.join(home, '.bolloon', 'context-os', '03-Current');
+        const currentFiles = (await listMd(currentDir)).filter((f) => f.file !== 'README.md');
+        let extra = '';
+        if (llm && (queueItems.length > 0 || currentFiles.length > 0)) {
+            try {
+                const resp = await llm(`以下是用户当前目标素材 (goals queue + 03-Current 进行中的任务). 请区分长期目标与短期目标, 每条一行:\n- [长期/短期] 目标描述\n素材:\n${JSON.stringify(queueItems).slice(0, 1500)}\n${currentFiles.map((f) => f.file).join('\n')}`);
+                extra = `\n\n## LLM 目标分层 (${now})\n${resp.slice(0, 1500)}`;
+            }
+            catch { /* LLM 增强失败 */ }
+        }
+        const body = `# 用户目标摘要 (自动整理心跳, ${now})\n\n` +
+            `> 来源: goals/queue.json + goals/event.jsonl + 03-Current 进行中任务.\n\n` +
+            `## 目标队列\n${queueItems.length > 0 ? queueItems.map((g, i) => `- ${g?.description || g?.target || g?.id || `目标 ${i + 1}`}`).join('\n') : '(空)'}\n` +
+            `## 进行中任务 (03-Current)\n${currentFiles.length > 0 ? currentFiles.map((f) => `- ${f.file.replace(/\.md$/, '')}`).join('\n') : '(空)'}` +
+            extra + '\n';
+        const outFile = path.join(currentDir, '目标摘要.md');
+        await fs.mkdir(currentDir, { recursive: true });
+        await fs.writeFile(outFile, body, 'utf-8');
+        return {
+            key: 'goals', label: '用户目标维护',
+            handled: queueItems.length + currentFiles.length,
+            summary: `${queueItems.length} 条队列 + ${currentFiles.length} 个进行中 → 目标摘要`,
+        };
+    }
+    catch (e) {
+        return { key: 'goals', label: '用户目标维护', handled: 0, error: e?.message || String(e) };
+    }
+}
+// ───────────────────────── 总入口 ─────────────────────────
+/** 自动整理心跳 · 知识层: 串行跑全部 9 个整理器, 汇总 sections */
+export async function runKnowledgeOrganize(opts = {}) {
+    const home = opts.home || os.homedir();
+    const cwd = opts.cwd || process.cwd();
+    const llm = opts.llm;
+    const sections = [];
+    sections.push(await archiveContextOs(home));
+    sections.push(await tidySocialRelations(home));
+    sections.push(await tidyExternalAgents(home));
+    sections.push(await tidyInternalAgents(home));
+    sections.push(await maintainJudgeness(home));
+    sections.push(await understandProjects(home, llm));
+    sections.push(await understandUserProfile(home, llm));
+    sections.push(await archiveRecentLogs(home));
+    sections.push(await maintainGoals(home, llm));
+    const totalHandled = sections.reduce((acc, s) => acc + (s.error ? 0 : s.handled), 0);
+    return { sections, totalHandled };
+}

package/dist/agents/pi-sdk.js

@@ -28,6 +28,12 @@ import { initDocumentReceiver } from './p2p-document-tools.js';
 import { DiscoveredAgentsManager, createSocialHeartbeat } from '../social/heartbeat.js';
 import { SkillRegistry } from '@bolloon/constraint-runtime';
 import { loadSkillsFromPaths, defaultSkillPaths } from './skill-loader.js';
+/** 2026-08-10: unreported 逃生门判定 — LLM 反复不把工具结果写进回复时, 超过上限强制收尾 (防死循环) */
+export function decideUnreported(unreported, retries, max) {
+    if (unreported <= 0)
+        return 'none';
+    return retries < max ? 'retry' : 'force-final';
+}
 // 拆分后的子模块 — 重新导出保 backward compat
 export { TOOL_DEFINITIONS, } from './pi-sdk-types.js';
 export { PiSessionManager } from './pi-sdk-session-manager.js';
@@ -1124,6 +1130,11 @@ ${this.getToolDefinitions()}
         const MAX_TOOL_CALLS_PER_LOOP = 25; // 单轮循环总工具调用上限 → 注入 hint
         let totalToolCallsThisLoop = 0;
         const lastNTools = []; // 最近 MAX_IDEMPOTENT_TOOL 次工具名, 检测重复
+        // 2026-08-10: unreported 循环逃生门 — LLM 反复不把工具结果写进回复时, 3 次后强制 final (不死板)
+        const MAX_UNREPORTED_RETRIES = 3;
+        let unreportedRetries = 0;
+        // 2026-08-10: 工具失败时的终端逃生引导 (shell_exec 白名单命令可诊断环境/推进任务)
+        const SHELL_ESCAPE_HINT = ' [逃生] 若工具无法响应/报错, 可用 shell_exec 跑终端命令诊断 (白名单: ls/cat/head/tail/pwd/git status/npm run test 等), 或调整参数换一种方式完成; 不要重复调用同一失败工具.';
         // 2026-08-08: final 前 review 续跑 — 目标对齐 + 需求深挖 (见 loop-review.ts)
         //   不潦草收尾: LLM 想 <final gen> 时先跑 1-2 次 review, 达成用户需求才放行.
         //   上限=2 次 (用户要求"运行一两次"), 结束后按用户需求为准.
@@ -1671,7 +1682,7 @@ ${toolDefs}
                             // 2026-07-28: 注入 Observation + Reflection 替代旧 hardcode 提示
                             const obs = buildObservation(toolCall.name, toolCall.args, { success: false, error: result.error });
                             const ref = buildReflection(toolCall.name, result.error, totalErrors, lastFailedToolCount);
-                            this.messageHistory.push({ role: 'system', content: formatObservationWithReflection(obs, ref) });
+                            this.messageHistory.push({ role: 'system', content: formatObservationWithReflection(obs, ref) + SHELL_ESCAPE_HINT });
                             if (onStream)
                                 onStream({ type: 'status', content: `💡 Reflection: ${obs.summary} → ${ref[0]?.action || '放弃'}`, tool: 'system' });
                             if (lastFailedToolCount >= MAX_SAME_TOOL_FAILURES) {
@@ -1695,7 +1706,7 @@ ${toolDefs}
                         this.logToHarness(toolCall.name, toolCall.args, errorResult);
                         const obs = buildObservation(toolCall.name, toolCall.args, errorResult);
                         const ref = buildReflection(toolCall.name, errorResult.error, totalErrors, lastFailedToolCount);
-                        this.messageHistory.push({ role: 'system', content: formatObservationWithReflection(obs, ref) });
+                        this.messageHistory.push({ role: 'system', content: formatObservationWithReflection(obs, ref) + SHELL_ESCAPE_HINT });
                         if (onStream)
                             onStream({ type: 'status', content: `💡 Reflection: ${obs.summary}`, tool: 'system' });
                         console.error(`[PiAgent] 工具执行异常 (累计 ${totalErrors}/${this.MAX_TOTAL_ERRORS}): ${execError}`);
@@ -1728,18 +1739,33 @@ ${toolDefs}
                         console.log(`[PiAgent] 回复包含工具结果内容, 清除 successfulToolResults (${this.successfulToolResults.length} 个)`);
                         this.successfulToolResults = [];
                     }
-                    if (this.successfulToolResults.length > 0 && iteration < this.MAX_REACT_ITERATIONS) {
+                    // 2026-08-10: 逃生门 — decideUnreported: 未达上限 → 再提示一次; 超限 → 清空积压强制 final (防死循环)
+                    const unreportedDecision = decideUnreported(this.successfulToolResults.length, unreportedRetries, MAX_UNREPORTED_RETRIES);
+                    if (unreportedDecision === 'retry' && iteration < this.MAX_REACT_ITERATIONS) {
+                        unreportedRetries++;
                         const unreported = this.successfulToolResults.length;
-                        console.log(`[PiAgent] LLM 想 final_gen 但还有 ${unreported} 个工具结果未汇报, push hint 让其继续`);
+                        console.log(`[PiAgent] LLM 想 final_gen 但还有 ${unreported} 个工具结果未汇报 (${unreportedRetries}/${MAX_UNREPORTED_RETRIES}), push hint 让其继续`);
                         this.messageHistory.push({
                             role: 'system',
                             content: `[dive-into stop condition] 你之前已成功执行了 ${unreported} 个工具, 但当前回复里没把它们的结果告诉用户. 请基于已有的工具结果 (在 history 里) 写一个完整总结回复给用户, 用 <final gen> 结尾. 不要再调工具.`
                         });
                         if (onStream) {
-                            onStream({ type: 'status', content: `🔄 还有 ${unreported} 个工具结果未汇报, 让 LLM 继续总结`, tool: 'system' });
+                            onStream({ type: 'status', content: `🔄 还有 ${unreported} 个工具结果未汇报, 让 LLM 继续总结 (${unreportedRetries}/${MAX_UNREPORTED_RETRIES})`, tool: 'system' });
                         }
                         continue;
                     }
+                    else if (unreportedDecision === 'force-final') {
+                        // 反复提示仍未汇报超过上限 → 清空积压强制 final, 不再死循环
+                        console.log(`[PiAgent] unreported 循环超限 (${unreportedRetries} 次), 清空积压强制 final`);
+                        this.successfulToolResults = [];
+                        this.messageHistory.push({
+                            role: 'system',
+                            content: `[dive-into stop condition] 已多次提示汇报工具结果仍未完成 (超过 ${MAX_UNREPORTED_RETRIES} 次). 现在直接基于你已知的信息写最终回复给用户, 用 <final gen> 结尾, 不要再调任何工具.`
+                        });
+                        if (onStream) {
+                            onStream({ type: 'status', content: `🔄 工具结果汇报超限, 强制收尾`, tool: 'system' });
+                        }
+                    }
                     lastQualityScore = this.estimateResponseQuality(reply);
                     // 2026-07-29: 质量门 — 即使 LLM 声称完成, 质量太低也继续
                     if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {

package/dist/agents/skill-organizer.js

@@ -0,0 +1,322 @@
+/**
+ * skill-organizer.ts — 自动整理心跳 (2026-08-10)
+ *
+ * 目的: 把"自动整理"变成 Bolloon 的心跳之一 (与社交心跳并列), 周期性做两件事:
+ *
+ *   A. 扫描 skills view (~/.bolloon/skills + <cwd>/.bolloon/skills), 找出"遗留下来的 skills 指导":
+ *      - 外部智能体迁移残留 (openclaw/hermes 迁移的 skills 展平为 `<分类>-<技能>`, 如 apple-* / creative-* / autonomous-ai-agents-*)
+ *      - 空 body / 无 description 的占位 skill
+ *      - status: archived 的归档残留
+ *      - 用户级与项目级同名重复
+ *   B. 经验进化 (完整总结, 不再只是记录使用什么工具): 读 run-end 候选, 用 LLM 把
+ *      "工具调用记录" 扩写成完整的经验文档 (背景/触发条件/流程/注意事项/验证), 转正为正式 skill.
+ *
+ * 设计原则 (compile-first / 可测):
+ *   - 所有目录/LLM 可注入 (home/cwd/llm), 测试用临时 HOME + mock LLM.
+ *   - runSkillOrganize 纯函数式: 输入候选 + 现有 skills, 输出进化结果 + 遗留报告, 不依赖网络.
+ *   - startOrganizeHeartbeat 提供 CLI/server 统一的心跳壳: interval + 重入锁 + onStart/onEnd/onError,
+ *     CLI 通过 onStart/onEnd 把显示接到颜文字行 (inkSetTransient), 结束后清空.
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { getUserSkillsDir, getProjectSkillsDir, sanitizeSkillName } from './skill-writer.js';
+/** 迁移来源分类前缀 — 这些是外部智能体 (openclaw/hermes 等) 迁移进来的 skills, 属于"遗留"候选 */
+const MIGRATED_PREFIXES = [
+    'apple-',
+    'autonomous-ai-agents-',
+    'creative-',
+    'data-science-',
+    'email-',
+    'github-',
+    'media-',
+    'mlops-',
+    'note-taking-',
+    'openclaw-imports-',
+    'productivity-',
+    'research-',
+    'smart-home-',
+    'social-media-',
+    'software-development-',
+];
+// ───────────────────────── A. 遗留 skills 扫描 ─────────────────────────
+/** 判定一个 skill 是否"遗留": 返回原因列表 (空数组 = 正常) */
+export function leftoverReasons(meta) {
+    const reasons = [];
+    const name = meta.name || '';
+    // 1. 迁移残留: 带外部智能体分类前缀
+    if (MIGRATED_PREFIXES.some((p) => name.startsWith(p))) {
+        reasons.push('迁移遗留 (外部智能体分类前缀)');
+    }
+    // 2. 占位: 无描述或正文过短
+    const desc = (meta.description || '').trim();
+    const body = (meta.body || '').trim();
+    if (!desc)
+        reasons.push('无 description');
+    if (body.length < 50)
+        reasons.push('正文过短 (疑似占位)');
+    // 3. 归档残留
+    if (meta.status === 'archived')
+        reasons.push('status=archived (归档残留)');
+    return reasons;
+}
+/** 扫描一个 skill 目录, 返回遗留报告 */
+export async function scanSkillDir(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.'))
+            continue;
+        const skillFile = path.join(dir, entry.name, 'SKILL.md');
+        let raw = '';
+        try {
+            raw = await fs.readFile(skillFile, 'utf-8');
+        }
+        catch {
+            continue; // 没有 SKILL.md 不算 skill
+        }
+        const meta = parseSkillRaw(raw, entry.name);
+        const reasons = leftoverReasons(meta);
+        if (reasons.length > 0) {
+            out.push({ dir, name: meta.name, description: meta.description || '', reasons });
+        }
+    }
+    return out;
+}
+/** 轻量 frontmatter/正文解析 (不依赖 skill-loader, 避免循环依赖) */
+function parseSkillRaw(raw, fallbackName) {
+    let name = fallbackName;
+    let description = '';
+    let status = '';
+    let body = raw;
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?/);
+    if (fmMatch) {
+        body = raw.slice(fmMatch[0].length);
+        const fm = fmMatch[1];
+        const nameM = fm.match(/^name:\s*(.+)$/m);
+        const descM = fm.match(/^description:\s*(.+)$/m);
+        const statusM = fm.match(/^status:\s*(.+)$/m);
+        if (nameM)
+            name = nameM[1].trim();
+        if (descM)
+            description = descM[1].trim();
+        if (statusM)
+            status = statusM[1].trim();
+    }
+    return { name, description, status, body: body.trim() };
+}
+/** 扫描全部 skills view (用户级 + 项目级), 找同名重复 */
+export async function scanLeftoverSkills(opts = {}) {
+    const home = opts.home || os.homedir();
+    const cwd = opts.cwd || process.cwd();
+    const dirs = [getUserSkillsDir(home), getProjectSkillsDir(cwd)];
+    const found = new Map();
+    const seenNames = new Set();
+    for (const dir of dirs) {
+        const items = await scanSkillDir(dir);
+        for (const it of items) {
+            found.set(`${dir}::${it.name}`, it);
+        }
+        // 同名重复检测 (跨目录)
+        const names = (await fs.readdir(dir).catch(() => [])).filter((n) => !n.startsWith('.'));
+        for (const n of names) {
+            if (seenNames.has(n)) {
+                const dup = {
+                    dir,
+                    name: n,
+                    description: '同名 skill 已在其他目录存在',
+                    reasons: ['跨目录同名重复'],
+                };
+                found.set(`${dir}::dup::${n}`, dup);
+            }
+            seenNames.add(n);
+        }
+    }
+    return Array.from(found.values());
+}
+// ───────────────────────── B. 经验进化 (LLM 完整总结) ─────────────────────────
+/** 把候选的工具调用记录扩写成完整经验 — LLM prompt (结构化 JSON 输出) */
+export function buildEvolvePrompt(c) {
+    return `你是经验总结专家。下面是 Bolloon 智能体在一轮运行中连续成功调用的工具记录 (已运行 ${c.runs || 1} 次)。
+
+工具记录:
+名称: ${c.name}
+描述: ${c.description}
+原始记录:
+${String(c.body || '').slice(0, 4000)}
+
+请把这份"工具调用记录"扩写成一份完整的、可复用的经验文档, 要求:
+1. name: 一个简短的小写英文名 (字母数字连字符, 概括这套操作)
+2. description: 一句话描述 (什么场景用)
+3. body: 完整经验正文, 按以下结构:
+   ## 背景 — 这套操作在什么场景下用, 解决什么问题
+   ## 触发条件 — 什么信号/需求出现时应该使用
+   ## 流程 — 具体步骤 (保留原始工具名), 每步说明目的
+   ## 注意事项 — 易错点 / 边界情况 / 已知坑
+   ## 验证 — 怎么确认结果正确
+
+只输出一个 JSON 对象, 不要任何其他文字:
+{"name": "...", "description": "...", "body": "..."}`;
+}
+/** 解析 LLM 返回的 JSON (容错: 剥 markdown 代码块, 取第一个 {...}) */
+export function parseEvolveJson(raw) {
+    if (!raw)
+        return null;
+    const cleaned = raw.replace(/```(?:json)?/g, '').trim();
+    const m = cleaned.match(/\{[\s\S]*\}/);
+    if (!m)
+        return null;
+    try {
+        const obj = JSON.parse(m[0]);
+        return {
+            name: typeof obj.name === 'string' ? obj.name : undefined,
+            description: typeof obj.description === 'string' ? obj.description : undefined,
+            body: typeof obj.body === 'string' ? obj.body : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** 完整经验进化: 候选 → LLM 总结 → 正式 skill (转正 + 清理候选). 返回转正 skill 名列表 */
+export async function evolveCandidates(opts) {
+    const { listSkillCandidates, writeSkillCandidate } = await import('./skill-writer.js');
+    const home = opts.home || os.homedir();
+    const cands = await listSkillCandidates(home);
+    const evolved = [];
+    const max = opts.maxEvolve ?? 3;
+    // 优先进化 runs 多的 (更可能可复用)
+    const sorted = [...cands].sort((a, b) => (b.runs ?? 1) - (a.runs ?? 1)).slice(0, max);
+    for (const c of sorted) {
+        try {
+            const raw = await opts.llm(buildEvolvePrompt(c));
+            const parsed = parseEvolveJson(raw);
+            if (!parsed?.body || parsed.body.trim().length < 50) {
+                // LLM 输出不可用 → 保留候选, 记录一次失败 (不转正)
+                await writeSkillCandidate({
+                    ...c,
+                    body: `${c.body}\n- ${new Date().toISOString().slice(0, 16)} ${opts.source || 'organize'}: LLM 总结失败, 保留待人工`,
+                }).catch(() => { });
+                continue;
+            }
+            const { createSkill } = await import('./skill-writer.js');
+            const safeName = sanitizeSkillName(parsed.name || c.name) || sanitizeSkillName(c.name);
+            const r = await createSkill(safeName, parsed.description || c.description, parsed.body, {
+                status: 'active',
+                triggers: c.description ? [c.description.slice(0, 60)] : undefined,
+            });
+            if (!r.ok)
+                continue;
+            evolved.push(safeName);
+            // 转正成功 → 清理候选文件
+            const { listSkillCandidates: listAgain } = await import('./skill-writer.js');
+            const after = await listAgain(home);
+            for (const cc of after) {
+                if (cc.file && (cc.name === c.name || sanitizeSkillName(cc.name) === sanitizeSkillName(c.name))) {
+                    await fs.rm(cc.file, { force: true }).catch(() => { });
+                }
+            }
+        }
+        catch {
+            /* 单个候选失败不阻塞整轮 */
+        }
+    }
+    return { evolved, scanned: cands.length };
+}
+/** 自动整理主流程: 遗留扫描 (必做) + 经验进化 (有 LLM 时) */
+export async function runSkillOrganize(opts = {}) {
+    const evolve = opts.evolve ?? true;
+    const result = { scannedCandidates: 0, evolved: [], leftovers: [] };
+    try {
+        result.leftovers = await scanLeftoverSkills({ home: opts.home, cwd: opts.cwd });
+    }
+    catch (e) {
+        result.error = `遗留扫描失败: ${e?.message || String(e)}`;
+    }
+    if (evolve && opts.llm) {
+        try {
+            const { evolved, scanned } = await evolveCandidates({
+                llm: opts.llm,
+                source: opts.source,
+                home: opts.home,
+                maxEvolve: opts.maxEvolve,
+            });
+            result.evolved = evolved;
+            result.scannedCandidates = scanned;
+        }
+        catch (e) {
+            result.error = `${result.error ? result.error + '; ' : ''}经验进化失败: ${e?.message || String(e)}`;
+        }
+    }
+    else {
+        try {
+            const { listSkillCandidates } = await import('./skill-writer.js');
+            result.scannedCandidates = (await listSkillCandidates(opts.home || os.homedir())).length;
+        }
+        catch {
+            result.scannedCandidates = 0;
+        }
+    }
+    return result;
+}
+/** 自动整理总入口 (2026-08-10): skills 整理 (遗留扫描 + 经验进化) + 知识层整理 (9 类) */
+export async function runAutoOrganize(opts = {}) {
+    const result = await runSkillOrganize(opts);
+    try {
+        const { runKnowledgeOrganize } = await import('./knowledge-organizer.js');
+        result.knowledge = await runKnowledgeOrganize({ home: opts.home, cwd: opts.cwd, llm: opts.llm });
+    }
+    catch (e) {
+        result.error = `${result.error ? result.error + '; ' : ''}知识层整理失败: ${e?.message || String(e)}`;
+    }
+    return result;
+}
+/** 自动整理心跳: 定时触发整理, 带重入锁 (上一轮没跑完不重复触发) */
+export function startOrganizeHeartbeat(opts) {
+    const intervalMs = opts.intervalMs ?? 30 * 60_000;
+    let timer = null;
+    let stopped = false;
+    let running = false;
+    const runOnce = async () => {
+        if (running || stopped)
+            return null;
+        running = true;
+        try {
+            opts.onStart?.();
+            const r = await opts.run();
+            opts.onEnd?.(r);
+            return r;
+        }
+        catch (e) {
+            opts.onError?.(e instanceof Error ? e : new Error(String(e)));
+            return null;
+        }
+        finally {
+            running = false;
+        }
+    };
+    const schedule = () => {
+        if (stopped)
+            return;
+        timer = setTimeout(async () => {
+            await runOnce();
+            schedule();
+        }, intervalMs);
+    };
+    schedule();
+    return {
+        stop() {
+            stopped = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+        },
+        runOnce,
+    };
+}

package/dist/cli/ink-app.js

@@ -54,6 +54,9 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
     const [status, setStatus] = useState(initialStatus);
     const { exit } = useApp();
     const [thinking, setThinking] = useState(false);
+    // 2026-08-10: 临时状态行 (自动整理心跳/run-end 经验整理用) — 显示在颜文字行位置,
+    //   结束后设 null 即清空 (显示为空). 不进入消息历史, 不会残留显示效果.
+    const [transient, setTransient] = useState(null);
     const thinkingIdx = useRef(0);
     // 双击 Esc 退出当前进程 (500ms 窗口内第二次按下)
     const lastEscRef = useRef(0);
@@ -286,10 +289,15 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
         globalThis.__inkSetStatus = (s) => {
             setStatus(s);
         };
+        // 2026-08-10: 临时状态行 (自动整理/经验整理): 传字符串显示, 传 null 清空 (显示为空)
+        globalThis.__inkSetTransient = (v) => {
+            setTransient(v === undefined ? null : v);
+        };
         return () => {
             delete globalThis.__inkAppend;
             delete globalThis.__inkSetStatus;
             delete globalThis.__inkSetThinking;
+            delete globalThis.__inkSetTransient;
         };
     }, []);
     const onSubmit = useCallback((value) => {
@@ -539,7 +547,7 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
         }, 600);
         return () => clearInterval(timer);
     }, [thinking]);
-    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsxs(Box, { flexGrow: 1, flexDirection: "column", justifyContent: "flex-start", children: [_jsx(LogoBox, { width: terminalW }), _jsx(Messages, { msgs: msgs }), thinking && (_jsx(Box, { children: _jsxs(Text, { color: "yellow", children: [KAOMOJI[thinkingIdx.current], " \u601D\u8003\u4E2D..."] }) }))] }), _jsx(Box, { children: _jsx(Text, { bold: true, color: "#c4d640", children: '─'.repeat(terminalW) }) }), _jsx(Box, { children: _jsx(Text, { children: status }) }), _jsx(Box, { children: _jsx(Text, { bold: true, color: "#c4d640", children: '─'.repeat(terminalW) }) }), popupOpen && (tabState || mention) && (_jsx(MentionPopup, { title: popupTitle, items: filtered, sel: safeSel, width: terminalW, loading: loadingFiles })), picker && (_jsx(MentionPopup, { title: picker.title, items: picker.items, sel: Math.min(picker.sel, picker.items.length - 1), width: terminalW })), _jsxs(Box, { children: [_jsx(Text, { bold: true, color: "#c4d640", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit, focus: !popupOpen && !picker, placeholder: "\u8F93\u5165\u6D88\u606F... @\u667A\u80FD\u4F53 /\u547D\u4EE4 #\u6587\u4EF6 \u00B7 Esc \u53CC\u51FB\u9000\u51FA \u00B7 /queue \u6392\u961F \u00B7 !\u7EC8\u7AEF\u547D\u4EE4" }, tiKey)] }), _jsx(Box, { children: _jsx(Text, { bold: true, color: "#c4d640", children: '─'.repeat(terminalW) }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsxs(Box, { flexGrow: 1, flexDirection: "column", justifyContent: "flex-start", children: [_jsx(LogoBox, { width: terminalW }), _jsx(Messages, { msgs: msgs }), thinking && (_jsx(Box, { children: _jsxs(Text, { color: "yellow", children: [KAOMOJI[thinkingIdx.current], " \u601D\u8003\u4E2D..."] }) })), transient && (_jsx(Box, { children: _jsx(Text, { children: transient }) }))] }), _jsx(Box, { children: _jsx(Text, { bold: true, color: "#c4d640", children: '─'.repeat(terminalW) }) }), _jsx(Box, { children: _jsx(Text, { children: status }) }), _jsx(Box, { children: _jsx(Text, { bold: true, color: "#c4d640", children: '─'.repeat(terminalW) }) }), popupOpen && (tabState || mention) && (_jsx(MentionPopup, { title: popupTitle, items: filtered, sel: safeSel, width: terminalW, loading: loadingFiles })), picker && (_jsx(MentionPopup, { title: picker.title, items: picker.items, sel: Math.min(picker.sel, picker.items.length - 1), width: terminalW })), _jsxs(Box, { children: [_jsx(Text, { bold: true, color: "#c4d640", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit, focus: !popupOpen && !picker, placeholder: "\u8F93\u5165\u6D88\u606F... @\u667A\u80FD\u4F53 /\u547D\u4EE4 #\u6587\u4EF6 \u00B7 Esc \u53CC\u51FB\u9000\u51FA \u00B7 /queue \u6392\u961F \u00B7 !\u7EC8\u7AEF\u547D\u4EE4" }, tiKey)] }), _jsx(Box, { children: _jsx(Text, { bold: true, color: "#c4d640", children: '─'.repeat(terminalW) }) })] }));
 };
 export { InkApp };
 // ─── 启动 ────────────────────────────────────────────────────────────────────
@@ -576,3 +584,9 @@ export function inkSetThinking(v) {
     if (fn)
         fn(v);
 }
+/** 2026-08-10: 设置/清除临时状态行 (自动整理/经验整理). 传 null 清空 → 显示为空 */
+export function inkSetTransient(v) {
+    const fn = globalThis.__inkSetTransient;
+    if (fn)
+        fn(v);
+}

package/dist/index.js

@@ -16,7 +16,7 @@ import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
 import { printBanner, renderDialog, renderUserMessage, renderAgentMessage, renderMessageBox, renderToolCallListItem, termWidth } from './cli/loading-tui.js';
-import { startInk, stopInk, inkAppendLine as appendLine, inkSetStatus, inkSetThinking } from './cli/ink-app.js';
+import { startInk, stopInk, inkAppendLine as appendLine, inkSetStatus, inkSetThinking, inkSetTransient } from './cli/ink-app.js';
 // 启动自动检查更新：后台、节流、检测到新版本自动安装（可被 --no-update / BOLLOON_SKIP_UPDATE 关闭）
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
@@ -423,6 +423,8 @@ let cliStartTime = 0;
 let cliModelName = '…';
 let cliAgentName = '…';
 let cliActiveChannelId = null;
+// 2026-08-10: CLI 自动整理心跳 (与社交心跳并列, 独立于 server) — 退出时 stop
+let cliOrganizeHeartbeat = null;
 function fmtDuration(ms) {
     const s = Math.floor(ms / 1000);
     if (s < 60)
@@ -559,6 +561,64 @@ async function startCLI(comm) {
     catch { /* 降级: getCliCtxUsage 返回 0/1M */ }
     const initialStatus = `${C_ACCENT}${cliModelName}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ 0s${C_DIM} │${RESET} ${buildContextBar(getCliCtxUsage())}`;
     startInk((text) => { processInput(text, comm); }, initialStatus, getStatus);
+    // 2026-08-10: 自动整理心跳 (CLI 侧, 与社交心跳并列) — 启动后立即"固定看一下 skills view"
+    //   (扫描遗留 skills), 之后按周期 (默认 30min, env BOLLOON_ORGANIZE_HEARTBEAT_MS) 完整进化经验.
+    //   显示走 transient 颜文字行: 触发时显示, 结束后清空 (显示为空).
+    try {
+        const { startOrganizeHeartbeat } = await import('./agents/skill-organizer.js');
+        let firstOrganizeScan = true; // 启动第一轮只做快速遗留扫描 (无 LLM), 不阻塞启动
+        cliOrganizeHeartbeat = startOrganizeHeartbeat({
+            intervalMs: Number(process.env.BOLLOON_ORGANIZE_HEARTBEAT_MS) || 30 * 60_000,
+            onStart: () => inkSetTransient(`${C_DIM}(｀・ω・´) 自动整理经验中...${RESET}`),
+            onEnd: (r) => {
+                inkSetTransient(null); // 结束后去除显示效果 (显示为空)
+                // 2026-08-10: 整理结果统一进 bolloon 艺术字框 (renderMessageBox 圆角框, 与反思框同款)
+                const boxLines = [];
+                if (r && r.leftovers.length > 0) {
+                    boxLines.push(`🧹 遗留 skills (${r.leftovers.length}): ${r.leftovers.slice(0, 8).map(l => l.name).join(', ')}${r.leftovers.length > 8 ? ' ...' : ''}`);
+                }
+                if (r && r.evolved.length > 0) {
+                    boxLines.push(`✨ 经验进化: ${r.evolved.join(', ')}`);
+                }
+                // 知识层整理汇总 (Context OS/社交/智能体/judgeness/项目/画像/日志/目标)
+                const kSections = (r?.knowledge?.sections || []).filter(s => s.handled > 0 || s.error);
+                if (kSections.length > 0) {
+                    boxLines.push(`🧠 知识整理: ${kSections.map(s => s.error ? `${s.label}✗` : `${s.label}✓`).join(' ')}`);
+                }
+                if (boxLines.length > 0) {
+                    appendLine(renderMessageBox({ title: '自动整理完成', body: boxLines.join('\n'), color: C_ACCENT, maxLines: 10 }));
+                }
+            },
+            onError: () => inkSetTransient(null),
+            run: async () => {
+                // 启动第一轮 (firstOrganizeScan=true) 只做快速扫描 — 不拿 LLM, 立即执行.
+                // 后续周期轮才取 agent LLM 做完整经验进化 (2026-08-10: getAgent 在无 LLM 环境可能
+                //   长时间挂起 → 8s 超时降级为仅扫描)
+                let llm;
+                const needEvolve = !firstOrganizeScan;
+                if (needEvolve) {
+                    try {
+                        const a = await Promise.race([
+                            getAgent().catch(() => null),
+                            new Promise((res) => setTimeout(() => res(null), 8000)),
+                        ]);
+                        if (a && typeof a.promptStream === 'function') {
+                            llm = (p) => a.promptStream(p, () => { }, undefined, cliActiveChannelId || undefined);
+                        }
+                    }
+                    catch { /* 无 agent → 仅扫描 */ }
+                }
+                const { runAutoOrganize } = await import('./agents/skill-organizer.js');
+                const evolve = needEvolve && !!llm;
+                firstOrganizeScan = false;
+                return runAutoOrganize({ llm, source: 'cli:organize-heartbeat', evolve });
+            },
+        });
+        // 启动即跑一轮: 每次打开后固定看一下 skills view (遗留扫描, 快, 不阻塞)
+        // 延迟 3s 等 Ink 挂载完成 (global __inkAppend/__inkSetTransient 注册) — 否则首轮显示丢失
+        setTimeout(() => { cliOrganizeHeartbeat?.runOnce().catch(() => { }); }, 3000);
+    }
+    catch { /* 自动整理启动失败不阻塞 CLI */ }
     // Wait on a promise that resolves on Ctrl+C / 双击 Esc
     // (ink-app 的 requestExit 调 __inkRequestExit → resolve, 清理后 process.exit)
     let cliExitResolve = () => { };
@@ -568,6 +628,10 @@ async function startCLI(comm) {
     delete globalThis.__inkRequestExit;
     stopInk();
     appendLine(`\n${CYAN}👋 再见！${RESET}`);
+    try {
+        cliOrganizeHeartbeat?.stop();
+    }
+    catch { /* 非致命 */ }
     comm.stop();
     process.exit(0);
 }
@@ -1616,18 +1680,20 @@ async function processInput(input, comm) {
         appendLine(renderAgentMessage(response));
         // 停止思考动画
         inkSetThinking(false);
-        // 2026-08-04: run-end 经验整理 — 连续成功工具 ≥2 自动写 skill 候选 (颜文字加载)
+        // 2026-08-04: run-end 经验整理 — 连续成功工具 ≥2 自动写 skill 候选
+        // 2026-08-10: 显示改走 transient 行 (颜文字位置): 开始时显示, 结束后清空 (显示为空),
+        //   不再追加 ✨ 消息行 → 不残留显示效果
         if (runEndOkSteps.length >= 2) {
-            appendLine(`${C_DIM}(｀・ω・´) 整理本轮经验中... ${runEndOkSteps.length} 个工具调用${RESET}`);
+            inkSetTransient(`${C_DIM}(｀・ω・´) 整理本轮经验中... ${runEndOkSteps.length} 个工具调用${RESET}`);
             setImmediate(async () => {
                 try {
                     const { writeRunEndSkillCandidates } = await import('./agents/skill-writer.js');
-                    const r = await writeRunEndSkillCandidates(runEndOkSteps, 'cli:interactive');
-                    if (r.wrote) {
-                        appendLine(`${C_OK}✨ (◕‿◕) 经验候选已写入: ${r.names}${RESET}`);
-                    }
+                    await writeRunEndSkillCandidates(runEndOkSteps, 'cli:interactive');
                 }
                 catch { /* 非致命, 静默 */ }
+                finally {
+                    inkSetTransient(null); // 结束后去除显示效果 (显示为空)
+                }
             });
         }
         // 更新状态栏: 上下文进度 (2026-08-06: 每轮按当前 messageHistory 重算并写回 ContextManager,

package/dist/social/agent-heartbeat.js

@@ -50,6 +50,8 @@ const DEFAULTS = {
     backoffFactor: 2,
     maxSocialIntervalMs: 30 * 60_000,
     goalReevalMs: 60 * 60_000,
+    // 2026-08-10: 自动整理心跳
+    organizeIntervalMs: 30 * 60_000,
 };
 const MAX_BACKOFF_LEVEL = 6;
 export class AgentHeartbeat {
@@ -58,6 +60,9 @@ export class AgentHeartbeat {
     lastInitiated = new Map();
     beaconTimer = null;
     socialTimer = null;
+    // 2026-08-10: 自动整理心跳 timer + 重入锁 (上一轮没跑完不重复触发)
+    organizeTimer = null;
+    organizeRunning = false;
     started = false;
     // === 生命周期状态 ===
     phase = 'BOOTSTRAP';
@@ -78,6 +83,10 @@ export class AgentHeartbeat {
             onPeerAlive: options.onPeerAlive,
             onActivity: options.onActivity,
             onLifecycleChange: options.onLifecycleChange,
+            organizeEnabled: options.organizeEnabled ?? true,
+            organizeIntervalMs: options.organizeIntervalMs ?? DEFAULTS.organizeIntervalMs,
+            organize: options.organize,
+            onOrganizeEvent: options.onOrganizeEvent,
             beaconIntervalMs: options.beaconIntervalMs ?? DEFAULTS.beaconIntervalMs,
             socialIntervalMs: options.socialIntervalMs ?? DEFAULTS.socialIntervalMs,
             cooldownMs: options.cooldownMs ?? DEFAULTS.cooldownMs,
@@ -110,10 +119,15 @@ export class AgentHeartbeat {
         if (this.isSocialEnabled()) {
             this.scheduleSocial();
         }
+        // 2026-08-10: 自动整理心跳 — 与社交独立, 社交关闭也照跑
+        if (this.opts.organizeEnabled && this.opts.organize) {
+            this.scheduleOrganize();
+        }
         // 立即发一次 beacon, 让对端尽快看到自己
         this.tickBeacon().catch(() => { });
         console.log(`[heartbeat] 社交心跳已启动 (beacon=${this.opts.beaconIntervalMs}ms` +
-            `${this.isSocialEnabled() ? `, social=${this.opts.socialIntervalMs}ms, cooldown=${this.opts.cooldownMs}ms` : ', social=关闭'} )`);
+            `${this.isSocialEnabled() ? `, social=${this.opts.socialIntervalMs}ms, cooldown=${this.opts.cooldownMs}ms` : ', social=关闭'}` +
+            `${this.opts.organizeEnabled && this.opts.organize ? `, organize=${this.opts.organizeIntervalMs}ms` : ', organize=关闭'} )`);
     }
     /** 优雅停止: 清理全部定时器 (供全局 runtime 的 SIGTERM/SIGINT 清理调用) */
     stop() {
@@ -121,8 +135,11 @@ export class AgentHeartbeat {
             clearInterval(this.beaconTimer);
         if (this.socialTimer)
             clearTimeout(this.socialTimer);
+        if (this.organizeTimer)
+            clearTimeout(this.organizeTimer);
         this.beaconTimer = null;
         this.socialTimer = null;
+        this.organizeTimer = null;
         this.started = false;
         this.setPhase('PAUSED');
         console.log('[heartbeat] 社交心跳已停止 (定时器已清理)');
@@ -192,6 +209,50 @@ export class AgentHeartbeat {
             });
         }, this.currentSocialInterval());
     }
+    // ===================== 自动整理心跳 (2026-08-10) =====================
+    // 与社交心跳并列的第三条心跳: 周期性整理 skills 经验 (候选进化) + 扫描遗留 skills.
+    // 与社交生命周期完全独立 — 社交关闭/退避 RESTING 不影响整理照跑.
+    /** 是否启用了自动整理 */
+    isOrganizeEnabled() {
+        return this.opts.enabled && this.opts.organizeEnabled && !!this.opts.organize;
+    }
+    scheduleOrganize() {
+        if (!this.started || !this.isOrganizeEnabled()) {
+            this.organizeTimer = null;
+            return;
+        }
+        this.organizeTimer = setTimeout(() => {
+            this.tickOrganize()
+                .catch((e) => console.warn('[heartbeat] organize tick 失败:', e?.message))
+                .finally(() => {
+                if (this.started && this.isOrganizeEnabled())
+                    this.scheduleOrganize();
+            });
+        }, this.opts.organizeIntervalMs);
+    }
+    /** 跑一轮自动整理 (导出供测试/启动即跑: 每次打开后固定看一下 skills view) */
+    async tickOrganize() {
+        if (!this.isOrganizeEnabled() || this.organizeRunning)
+            return;
+        this.organizeRunning = true;
+        this.opts.onOrganizeEvent?.({ phase: 'start' });
+        try {
+            const self = await this.opts.self();
+            const r = await this.opts.organize({ self });
+            this.opts.onOrganizeEvent?.({
+                phase: 'end',
+                summary: r?.summary || (r?.done ? '完成' : ''),
+            });
+            return r;
+        }
+        catch (e) {
+            this.opts.onOrganizeEvent?.({ phase: 'error', error: e?.message || String(e) });
+            throw e;
+        }
+        finally {
+            this.organizeRunning = false;
+        }
+    }
     /** 社交决策 tick: 先评估生命周期, 再决定是否对存活 peer 发起对话 */
     async tickSocial() {
         this.opts.onActivity?.();

package/dist/web/server.js

@@ -2332,6 +2332,49 @@ export async function createWebServer(port = 3000, options = {}) {
                             ts: Date.now(),
                         }, 'p2p-global');
                     },
+                    // === 2026-08-10: 自动整理心跳 (与社交并列) ===
+                    // 周期性: ① 扫描 skills view 找遗留 skills ② 候选经验 LLM 完整进化 (不再只是记录工具).
+                    // 与社交生命周期独立 — 社交关闭 (BOLLOON_AGENT_HEARTBEAT_SOCIAL=0) 整理仍照跑.
+                    organizeEnabled: true,
+                    organizeIntervalMs: Number(process.env.BOLLOON_ORGANIZE_HEARTBEAT_MS) || 30 * 60_000,
+                    organize: async () => {
+                        try {
+                            watchdogRef?.recordActivity?.('agent-organize');
+                        }
+                        catch { }
+                        const { runAutoOrganize } = await import('../agents/skill-organizer.js');
+                        // 用第一个本地 channel 的 agent 做 LLM 完整经验进化 (拿不到则仅扫描)
+                        // 2026-08-10: getAgentForChannel 初始化可能挂起 → 8s 超时降级
+                        let llm;
+                        try {
+                            const channels = await loadChannels();
+                            const local = channels[0];
+                            if (local) {
+                                const agent = await Promise.race([
+                                    getAgentForChannel(local.id, local.did || '', local.name, local.didDocRef).catch(() => null),
+                                    new Promise((res) => setTimeout(() => res(null), 8000)),
+                                ]);
+                                if (agent && typeof agent.promptStream === 'function') {
+                                    llm = (p) => agent.promptStream(p, () => { }, undefined, local.id);
+                                }
+                            }
+                        }
+                        catch { /* 无 agent → 仅扫描 */ }
+                        const r = await runAutoOrganize({ llm, source: 'server:organize-heartbeat', evolve: !!llm });
+                        const kTotal = r.knowledge?.totalHandled ?? 0;
+                        return { done: true, summary: `进化 ${r.evolved.length} 个 skill, 遗留 ${r.leftovers.length} 个, 知识层 ${kTotal} 项` };
+                    },
+                    onOrganizeEvent: (evt) => {
+                        if (evt?.phase === 'start') {
+                            console.log('[heartbeat] 自动整理开始 (skills 遗留扫描 + 经验进化)');
+                        }
+                        else if (evt?.phase === 'end') {
+                            console.log(`[heartbeat] 自动整理完成${evt.summary ? `: ${evt.summary}` : ''}`);
+                        }
+                        else if (evt?.phase === 'error') {
+                            console.warn(`[heartbeat] 自动整理失败 (non-fatal): ${evt?.error || ''}`);
+                        }
+                    },
                 });
                 agentHeartbeat.start();
                 // 注册到全局, 让 24h HealthMonitor.checkHeartbeat 能观测到本智能体 (getDiscoveredAgents/isAntColonyEnabled)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.3.47",
+  "version": "0.3.49",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",