@bolloon/bolloon-agent 0.3.33 → 0.3.35

package/dist/agents/agent-identity-store.js

@@ -0,0 +1,171 @@
+/**
+ * agent-identity-store.ts — 统一 Agent Identity 源 (2026-08-06)
+ *
+ * 解决 CLI 状态栏与 Web UI 智能体名称不一致的根因:
+ * 多个地方各自维护 agent 名称 → 统一从这里读。
+ *
+ * 数据流:
+ *   channels.json (唯一数据源)
+ *        │
+ *   AgentIdentityStore (读取 + active 持久化)
+ *        │
+ *   CLI 状态栏 / /channel 命令  ──  Web UI (GET /active-channel + /channels)
+ *
+ * active channel 持久化: ~/.bolloon/active-channel.json (CLI 与 Web 共用,
+ * 重启后自动恢复上次 channel / identity)。
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const HOME = () => process.env.HOME || '/tmp';
+/** channels.json 路径 (与 server-types.ts CHANNELS_PATH 对齐) */
+export function channelsPaths(home = HOME()) {
+    return [
+        path.join(home, '.bolloon', 'sessions', 'channels.json'),
+        path.join(home, '.bolloon', 'channels.json'),
+    ];
+}
+export function activeChannelFile(home = HOME()) {
+    return path.join(home, '.bolloon', 'active-channel.json');
+}
+export class AgentIdentityStore {
+    home;
+    channels = [];
+    activeChannelId = null;
+    loaded = false;
+    constructor(home = HOME()) {
+        this.home = home;
+    }
+    /** 读 channels.json + active-channel.json (幂等, 可重复调) */
+    async load() {
+        for (const p of channelsPaths(this.home)) {
+            try {
+                const raw = JSON.parse(await fs.readFile(p, 'utf-8'));
+                if (Array.isArray(raw)) {
+                    this.channels = raw;
+                    break;
+                }
+            }
+            catch { /* 该路径不存在则试下一个 */ }
+        }
+        try {
+            const a = JSON.parse(await fs.readFile(activeChannelFile(this.home), 'utf-8'));
+            if (a && typeof a.channelId === 'string')
+                this.activeChannelId = a.channelId;
+        }
+        catch { /* 无 active 记录 */ }
+        this.loaded = true;
+    }
+    get isLoaded() { return this.loaded; }
+    get rawChannels() { return this.channels; }
+    /** channel → AgentIdentity (persona.name 优先) */
+    toIdentity(c) {
+        const name = c.persona?.name?.trim() || c.name || c.agentId || 'agent';
+        return {
+            id: c.id,
+            name,
+            channelId: c.id,
+            avatar: c.persona?.name ? undefined : undefined,
+            metadata: {
+                agentId: c.agentId,
+                did: c.did,
+                persona: c.persona,
+                publicKey: c.publicKey,
+                cid: c.cid,
+                ipnsName: c.ipnsName,
+            },
+        };
+    }
+    /** 全部智能体身份 (channel 顺序 = 索引顺序, 1-based) */
+    getIdentities() {
+        return this.channels.map(c => this.toIdentity(c));
+    }
+    /**
+     * 解析 /channel <query>:
+     *   纯数字 → number (1-based 索引)
+     *   匹配 id → id (完整或前缀)
+     *   匹配 name → name (大小写不敏感)
+     * 优先级: number > id > name
+     */
+    async resolve(query) {
+        if (!this.loaded)
+            await this.load();
+        const q = String(query || '').trim();
+        if (!q)
+            return null;
+        // 1. number: 纯数字 → 1-based 索引
+        if (/^\d+$/.test(q)) {
+            const idx = parseInt(q, 10);
+            const ch = this.channels[idx - 1];
+            if (ch)
+                return { identity: this.toIdentity(ch), channel: ch, match: 'number', index: idx };
+        }
+        // 2. id: 完整或前缀
+        let found = this.channels.find(c => c.id === q);
+        if (found) {
+            const idx = this.channels.indexOf(found) + 1;
+            return { identity: this.toIdentity(found), channel: found, match: 'id', index: idx };
+        }
+        found = this.channels.find(c => c.id.startsWith(q));
+        if (found) {
+            const idx = this.channels.indexOf(found) + 1;
+            return { identity: this.toIdentity(found), channel: found, match: 'id', index: idx };
+        }
+        // 3. name: persona.name / channel.name 大小写不敏感 (含子串)
+        const ql = q.toLowerCase();
+        found = this.channels.find(c => {
+            const names = [c.persona?.name, c.name].filter(Boolean).map(n => String(n).toLowerCase());
+            return names.some(n => n === ql || n.includes(ql));
+        });
+        if (found) {
+            const idx = this.channels.indexOf(found) + 1;
+            return { identity: this.toIdentity(found), channel: found, match: 'name', index: idx };
+        }
+        return null;
+    }
+    /** 当前 active 身份 (无 active 或找不到时 → 第一个 channel, 与 Web UI 默认一致) */
+    async getActive() {
+        if (!this.loaded)
+            await this.load();
+        if (this.activeChannelId) {
+            const ch = this.channels.find(c => c.id === this.activeChannelId);
+            if (ch)
+                return this.toIdentity(ch);
+        }
+        return this.channels.length > 0 ? this.toIdentity(this.channels[0]) : null;
+    }
+    /** 切换 active channel + 持久化 (CLI /channel 与 Web POST /active-channel 共用) */
+    async setActive(channelId) {
+        if (!this.loaded)
+            await this.load();
+        const ch = this.channels.find(c => c.id === channelId);
+        if (!ch)
+            return null;
+        this.activeChannelId = channelId;
+        try {
+            await fs.mkdir(path.dirname(activeChannelFile(this.home)), { recursive: true });
+            await fs.writeFile(activeChannelFile(this.home), JSON.stringify({ channelId, updatedAt: Date.now() }, null, 2), 'utf-8');
+        }
+        catch (e) {
+            console.warn(`[identity-store] 持久化 active channel 失败 (非致命): ${e?.message}`);
+        }
+        return this.toIdentity(ch);
+    }
+    /** 列出所有 channel 供 /channel 无参显示 */
+    async listForDisplay() {
+        if (!this.loaded)
+            await this.load();
+        const active = this.activeChannelId;
+        return this.channels.map((c, i) => ({
+            index: i + 1,
+            identity: this.toIdentity(c),
+            active: c.id === active,
+        }));
+    }
+}
+let _store = null;
+/** 单例 (CLI / server 共用; 测试可 new AgentIdentityStore(tmpHome)) */
+export function getIdentityStore() {
+    if (!_store)
+        _store = new AgentIdentityStore();
+    return _store;
+}

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

@@ -1966,13 +1966,28 @@ export function registerBuiltinTools(ctx) {
                 let ipnsName = '';
                 try {
                     const ipfs = await sdk.IpfsClient.newWithRemoteNode('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
-                    const pub = await ipfs.publishAfterUpload?.(cid, kp);
+                    // 2026-08-06 fix: 之前传 kp (KeyPair 对象) 当 keyName → ensureKeyExists 拿对象比
+                    //   字符串永远 false → key/gen 自动生成名为 "[object Object]" 的 key.
+                    //   改用确定性 key 名 (与 did-builder.ts 一致: did-<did 冒号转横线>).
+                    const keyName = `did-${String(identity.did || '').replace(':', '-').replace(' ', '')}` || 'self';
+                    const pub = await ipfs.publishAfterUpload?.(cid, keyName);
                     ipnsName = pub?.name || pub?.ipnsName || '';
                 }
                 catch { /* IPNS 失败不致命, CID 仍可用 */ }
+                // 2026-08-06: 发布诊断 — 节点地址 + 公网可达性提示 (IPNS 记录进 DHT 但内容拉取依赖源节点可达)
+                let diag = '';
+                try {
+                    const id = await kuboApi('/api/v0/id');
+                    const addrs = id?.Addresses || [];
+                    const pubAddrs = addrs.filter((a) => !/127\.0\.0\.1|::1|10\.|100\.|192\.168|172\.(1[6-9]|2\d|3[01])\./.test(a));
+                    const peers = await kuboApi('/api/v0/swarm/peers');
+                    const peerCount = peers?.Peers?.length || 0;
+                    diag = `\n  [诊断] 节点在线, ${peerCount} peers; 公网可达地址 ${pubAddrs.length} 个${pubAddrs.length === 0 ? ' ⚠️ 无公网地址 (NAT 后), 公网用户只能解析 IPNS 但拉不到内容, 建议 pin 到公共服务或配置端口映射' : ''}`;
+                }
+                catch { /* 诊断失败静默 */ }
                 return {
                     success: true,
-                    output: `✅ DID 已发布到 IPFS:\n  DID: ${identity.did}\n  CID: ${cid}\n  IPNS: ${ipnsName || '(发布失败, CID 仍可用)'}\n  读回验证: curl -X POST "http://127.0.0.1:5001/api/v0/cat?arg=${cid}"`,
+                    output: `✅ DID 已发布到 IPFS:\n  DID: ${identity.did}\n  CID: ${cid}\n  IPNS: ${ipnsName || '(发布失败, CID 仍可用)'}\n  读回验证: curl -X POST "http://127.0.0.1:5001/api/v0/cat?arg=${cid}"${diag}`,
                 };
             }
             catch (e) {
@@ -2063,7 +2078,18 @@ export function registerBuiltinTools(ctx) {
                 const keyName = String(args.keyName || 'self').trim() || 'self';
                 await ipfs.ensureKeyExists(keyName);
                 const r = await ipfs.publishIpns(cid, keyName, '8760h', '1h');
-                return { success: true, output: `✅ IPNS 已发布:\n  name: ${r.name}\n  value: ${r.value}\n  解析: ipns_resolve(name="${r.name}")\n  公网访问: https://ipfs.io/ipns/${r.name}` };
+                // 2026-08-06: 诊断 — 公网可达性提示 (IPNS 记录进 DHT, 内容拉取依赖源节点公网可达)
+                let diag = '';
+                try {
+                    const id = await kuboApi('/api/v0/id');
+                    const addrs = id?.Addresses || [];
+                    const pubAddrs = addrs.filter((a) => !/127\.0\.0\.1|::1|10\.|100\.|192\.168|172\.(1[6-9]|2\d|3[01])\./.test(a));
+                    if (pubAddrs.length === 0) {
+                        diag = '\n  ⚠️ [诊断] 本机无公网可达地址 (NAT 后): 其他节点能解析 IPNS 但拉不到内容. 公网访问需 pin 到公共服务 (web3.storage/Pinata) 或给本机配置公网端口映射.';
+                    }
+                }
+                catch { /* 诊断失败静默 */ }
+                return { success: true, output: `✅ IPNS 已发布:\n  name: ${r.name}\n  value: ${r.value}\n  解析: ipns_resolve(name="${r.name}")\n  公网访问: https://ipfs.io/ipns/${r.name}${diag}` };
             }
             catch (e) {
                 return { success: false, error: `ipns_publish 失败: ${String(e.message || e).slice(0, 200)}` };
@@ -2080,7 +2106,9 @@ export function registerBuiltinTools(ctx) {
                 if (!name)
                     return { success: false, error: 'name 必填' };
                 await ensureKuboReady();
-                const r = await kuboApi(`/api/v0/name/resolve?arg=${encodeURIComponent(name)}`, undefined, 60000);
+                // 2026-08-06 fix: 加 recursive+nocache — 之前不带 nocache, 同一 key 重发布后
+                //   Kubo 返回本地缓存旧 CID (TTL 1h), 实测新内容发布后 resolve 到旧值.
+                const r = await kuboApi(`/api/v0/name/resolve?arg=${encodeURIComponent(name)}&recursive=true&nocache=true`, undefined, 60000);
                 const path = typeof r === 'object' && r !== null ? r.Path : String(r);
                 const cid = String(path).replace(/^\/ipfs\//, '').trim();
                 return { success: true, output: `🔗 ${name} → ${path}\n  CID: ${cid}` };
@@ -2574,6 +2602,17 @@ export function registerWalletTools(ctx) {
     catch (lspErr) {
         console.warn('[registerTools] LSP 工具注册失败 (非致命):', lspErr);
     }
+    // 2026-08-06: 注册 OrbitDB/CID 数据层工具 (cid_save/load/update/version/list/share + context 快照 + UI CID)
+    try {
+        import('../orbitdb/agent-tools.js').then(({ registerOrbitdbTools }) => {
+            registerOrbitdbTools(ctx);
+        }).catch((e) => {
+            console.warn('[registerTools] OrbitDB 工具注册失败 (非致命):', e);
+        });
+    }
+    catch (odbErr) {
+        console.warn('[registerTools] OrbitDB 工具注册失败 (非致命):', odbErr);
+    }
 }
 /**
  * 监听 P2P 消息 (远端 + 本地 inbox bus), 把消息存到 _inboxMessages 供 check_inbox 读.

package/dist/agents/pi-sdk.js

@@ -12,6 +12,7 @@
 import * as fsSync from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { getContextManager } from '../bootstrap/context-manager.js';
 import { documentReader } from '../documents/reader.js';
 import { getMinimax } from '../constraints/index.js';
 import { p2pNetwork } from '../network/p2p.js';
@@ -82,8 +83,21 @@ export class PiAgentSession {
     MAX_REACT_ITERATIONS = 10_000;
     MAX_REFINE_ATTEMPTS = 3;
     QUALITY_THRESHOLD = 0.6;
-    /** P1: 上下文溢出阈值 (单轮估算 token 数, 超过则强制终止防止 prompt-too-long) */
-    MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD = 60_000; // 60K tokens 上限
+    /** P1: 上下文溢出阈值 (单轮估算 token 数, 超过则强制终止防止 prompt-too-long)
+     *  2026-08-06: 从 ContextManager 动态读 (默认 1M, env MAX_CONTEXT_TOKENS 可调).
+     *  保留字段仅作降级兜底 (ContextManager 初始化失败时用 60K 老行为). */
+    MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD = 60_000; // fallback 60K tokens
+    /** 2026-08-06: 上下文窗口 (tokens) — 统一走 ContextManager 配置 (1M 默认). */
+    maxContextTokens() {
+        try {
+            const { getContextManager } = require('../bootstrap/context-manager.js');
+            const n = getContextManager().getConfig().maxTokens;
+            return Number.isFinite(n) && n > 0 ? n : this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD;
+        }
+        catch {
+            return this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD;
+        }
+    }
     /** 2026-06-16 新增: 累计错误总数兜底 (不管是否同工具, 累计 N 次就强制退出)
      *  防 LLM 轮换工具名绕开 MAX_SAME_TOOL_FAILURES 的死循环攻击 */
     MAX_TOTAL_ERRORS = 20;
@@ -1091,8 +1105,10 @@ ${this.getToolDefinitions()}
             // 2026-06-16 新增: loop 内自动压缩 — token 超 80% 阈值时跑一次
             // compact 失败走 C 路径: 不强行 break, 让现有 60K 阈值兜底 (后面有检查)
             //   2026-07-01 (v0.2.4 子任务 1): 触发判定走 shouldCompactBeforeIteration 纯函数
-            const compactThreshold = this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD * this.LOOP_COMPACT_RATIO;
+            const compactThreshold = this.maxContextTokens() * this.LOOP_COMPACT_RATIO;
             const estimatedTokensBefore = this.estimateHistoryTokens();
+            // 2026-08-06: 每轮上报 usage 到 ContextManager (CLI/Web 状态栏数据源, warning 事件触发点)
+            getContextManager().updateUsage(estimatedTokensBefore);
             if (shouldCompactBeforeIteration(estimatedTokensBefore, compactThreshold)) {
                 const tokensBeforeCompact = estimatedTokensBefore;
                 console.log(`[PiAgent] loop 入口 token ${tokensBeforeCompact} > ${compactThreshold}, 触发自动压缩`);
@@ -1108,10 +1124,10 @@ ${this.getToolDefinitions()}
             // 停止条件 3: context overflow (compact 后还超, 强制终止)
             //   2026-07-01 (v0.2.4 子任务 1): 委托给 react-loop.decideContextOverflow 纯函数
             const estimatedTokens = this.estimateHistoryTokens();
-            const overflowDecision = decideContextOverflow(estimatedTokens, this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD);
+            const overflowDecision = decideContextOverflow(estimatedTokens, this.maxContextTokens());
             if (overflowDecision.shouldExit) {
-                console.warn(`[PiAgent] context overflow (${estimatedTokens} tokens > ${this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD})`);
-                onStream?.({ type: 'error', content: `⏹️ 上下文溢出 (${estimatedTokens} tokens, 阈值 ${this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD})`, tool: 'loop' });
+                console.warn(`[PiAgent] context overflow (${estimatedTokens} tokens > ${this.maxContextTokens()})`);
+                onStream?.({ type: 'error', content: `⏹️ 上下文溢出 (${estimatedTokens} tokens, 阈值 ${this.maxContextTokens()})`, tool: 'loop' });
                 finalResponse = finalResponse || overflowDecision.finalAnswer;
                 break;
             }
@@ -1735,9 +1751,47 @@ ${toolDefs}
      */
     buildMessages() {
         try {
-            // 直接取 history 最后 15 条, tool 结果转 user role, 避免 tool_calls 配对
-            const slice = this.messageHistory.slice(-15);
+            // 2026-08-06: 来源优先用 projectedHistory (Context Collapse 投影, 非破坏) —
+            //   与 buildContext 一致; 之前只让字符串路径用投影, messages 数组路径被跳过,
+            //   导致 LLM 实际看到的还是未压缩的历史.
+            const source = this.projectedHistory ?? this.messageHistory;
+            const WINDOW = 15;
             const out = [];
+            // 早期历史压缩: 超过窗口时, 不直接丢弃 — 提取前段用户意图摘要注入 (同步, 无 LLM).
+            // 结构对齐 Context OS: System Prompt(persona) + 压缩摘要 + 最近消息.
+            if (source.length > WINDOW) {
+                const early = source.slice(0, source.length - WINDOW);
+                const slice = source.slice(-WINDOW);
+                const earlyUsers = early.filter(m => m.role === 'user' && (m.content || '').trim());
+                const earlyTools = early.filter(m => m.role === 'tool').length;
+                const earlyAssist = early.filter(m => m.role === 'assistant' && (m.content || '').trim()).length;
+                const snippet = earlyUsers.slice(-5).map(m => `- ${(m.content || '').slice(0, 120).replace(/\n/g, ' ')}`).join('\n') || '- (早期对话无用户文本)';
+                out.push({
+                    role: 'system',
+                    content: `[上下文压缩] 早期 ${early.length} 条消息已压缩 (用户 ${earlyUsers.length} 条 / AI ${earlyAssist} 条 / 工具结果 ${earlyTools} 条). 关键用户意图摘要:\n${snippet}\n[压缩结束] 以下是最近消息:`,
+                });
+                for (const m of slice) {
+                    const r = m.role;
+                    if (r === 'tool') {
+                        out.push({ role: 'user', content: `[工具结果]\n${(m.content || '').slice(0, 2000)}` });
+                        continue;
+                    }
+                    if (r === 'assistant') {
+                        out.push({ role: 'assistant', content: (m.content || '').slice(0, 4000) });
+                        continue;
+                    }
+                    if (r === 'user') {
+                        out.push({ role: 'user', content: (m.content || '').slice(0, 2000) });
+                        continue;
+                    }
+                    if (r === 'system') {
+                        out.push({ role: 'system', content: (m.content || '').slice(0, 2000) });
+                    }
+                }
+                return out;
+            }
+            // 窗口内: 原逻辑 (tool 转 user role, 避免 tool_calls 配对)
+            const slice = source.slice(-WINDOW);
             for (const m of slice) {
                 const r = m.role;
                 if (r === 'tool') {
@@ -1787,13 +1841,13 @@ ${toolDefs}
     async callLlmWithRecovery(llm, contextOrMessages, systemPrompt, signal, onStream, tools) {
         // Reactive compaction 预检: 估算 token 超 80% 阈值, 跑一次
         const estimated = this.estimateHistoryTokens();
-        if (estimated > this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD * 0.8) {
+        if (estimated > this.maxContextTokens() * 0.8) {
             console.warn(`[PiAgent] reactive compaction pre-check (${estimated} tokens > 80% threshold)`);
             onStream?.({ type: 'status', content: '⚠️ reactive compaction 预检触发', tool: 'recovery' });
             try {
                 const compacted = this.compressHistorySync(this.messageHistory);
                 this.messageHistory = compacted;
-                if (this.estimateHistoryTokens() > this.MAX_OUTPUT_TOKEN_ESCALATION_THRESHOLD * 0.8) {
+                if (this.estimateHistoryTokens() > this.maxContextTokens() * 0.8) {
                     await this.maybeAutoCompact(onStream, signal);
                 }
             }
@@ -1951,9 +2005,15 @@ ${toolDefs}
             const r = await llm.chat(userPrompt, systemPrompt, signal);
             return r.reply;
         };
+        // 2026-08-06: 预算 = ContextManager 配置 (1M * 55% ≈ 550K), 不再写死 8000.
+        //   之前 8000 与 48K 触发阈值矛盾: 一触发就一路跑到 LLM 摘要 (贵), 且 8000 远小于实际窗口.
+        const cm = getContextManager();
+        const cfg = cm.getConfig();
+        const maxTokens = Math.max(4000, Math.round(cfg.maxTokens * cfg.compressionThreshold));
+        const beforeTokens = this.estimateHistoryTokens();
         const { compactPipeline, isContextCollapseEnabled } = await import('../context-compaction/index.js');
         const result = await compactPipeline(this.messageHistory, {
-            maxTokens: 8000,
+            maxTokens,
             llmChat,
             collapseLlmChat: llmChat, // P1.2: Context Collapse 投影也用同一 LLM
             cacheScope: this.currentChannelId || 'default',
@@ -1961,9 +2021,12 @@ ${toolDefs}
         if (result.compacted && result.history.length < this.messageHistory.length) {
             const saved = this.messageHistory.length - result.history.length;
             const stagesApplied = result.stages.filter((s) => s.applied).map((s) => s.stage).join(' → ');
+            const afterTokens = this.estimateHistoryTokens();
+            const savedTokens = Math.max(0, beforeTokens - afterTokens);
+            cm.markCompressStart(beforeTokens);
             onStream?.({
                 type: 'status',
-                content: `🗜️ 上下文压缩: ${stagesApplied || 'no-op'} | 节省 ${saved} 条 (剩余 ${result.history.length}, collapse=${isContextCollapseEnabled() ? 'on' : 'off'})`,
+                content: `🗜️ 上下文压缩: ${stagesApplied || 'no-op'} | 节省 ${saved} 条 / ${savedTokens.toLocaleString()} tokens (剩余 ${result.history.length}, collapse=${isContextCollapseEnabled() ? 'on' : 'off'})`,
                 tool: 'compactor',
             });
             // 关键: 第 4 层 (Context Collapse) 是读时投影 (非破坏)
@@ -1977,6 +2040,29 @@ ${toolDefs}
                 this.messageHistory = result.history; // 真破坏性更新
                 this.projectedHistory = null;
             }
+            // 2026-08-06: snapshot 记录 before/after + 摘要 (供恢复/调试/UI), 事件广播
+            try {
+                const summaryLine = result.stages.map((s) => `${s.stage}(${s.before}→${s.after})`).join(' ');
+                const snap = cm.makeSnapshot({
+                    beforeTokens,
+                    afterTokens,
+                    summary: `压缩管道: ${summaryLine}; 节省 ${savedTokens} tokens / ${saved} 条消息`,
+                    preservedMemory: [
+                        ...this.messageHistory.filter(m => m.role === 'user').slice(-3).map(m => (m.content || '').slice(0, 80)),
+                    ],
+                    agentId: this.currentAgentId,
+                    channelId: this.currentChannelId,
+                });
+                cm.markCompressComplete(snap);
+            }
+            catch (snapErr) {
+                // snapshot 失败不阻塞主流程
+            }
+            cm.updateUsage(afterTokens);
+        }
+        else {
+            // 没压成也更新 usage (数据源保持新鲜)
+            cm.updateUsage(beforeTokens);
         }
     }
     isFinalResponse(content) {

package/dist/bootstrap/context-manager.js

@@ -0,0 +1,166 @@
+/**
+ * context-manager.ts — Context OS 资源管理器 (2026-08-06)
+ *
+ * 把"上下文压缩"升级为资源管理系统:
+ *   Token Budget → Monitor → Event → Compression Worker → Snapshot → Memory → UI 反馈
+ *
+ * 配置 (env 可覆盖):
+ *   MAX_CONTEXT_TOKENS    默认 1_000_000 (1M tokens 全局窗口)
+ *   COMPRESSION_THRESHOLD 默认 0.55 (55% 自动压缩)
+ *   WARNING_THRESHOLD     默认 0.50 (50% 状态栏 warning)
+ *
+ * 生命周期:
+ *   < 50%  normal
+ *   50-55% warning (UI 提示即将压缩)
+ *   >= 55% auto compression (触发后生成 summary + snapshot, 替换历史)
+ *
+ * 设计:
+ *   - 纯模块, 不 import pi-sdk (避免循环依赖); 只依赖 context-compaction 的 token 估算
+ *   - 事件订阅: CLI / Web UI / Logger 各自订阅, 压缩状态实时可见
+ *   - Snapshot 落盘 ~/.bolloon/context-os/snapshots/ (JSON), 可选 CID 化 (ContextStore)
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { randomUUID } from 'crypto';
+export function getContextConfig(env = process.env) {
+    const num = (v, def) => {
+        const n = Number(v);
+        return Number.isFinite(n) && n > 0 ? n : def;
+    };
+    const maxTokens = num(env.MAX_CONTEXT_TOKENS, 1_000_000);
+    const compressionThreshold = Math.min(1, Math.max(0, num(env.COMPRESSION_THRESHOLD, 0.55)));
+    const warningThreshold = Math.min(compressionThreshold, Math.max(0, num(env.WARNING_THRESHOLD, 0.5)));
+    return { maxTokens, compressionThreshold, warningThreshold };
+}
+export function usageFromTokens(usedTokens, config, lastCompressedAt = 0, lastSavedTokens = 0) {
+    const pct = config.maxTokens > 0 ? usedTokens / config.maxTokens : 0;
+    let stage = 'normal';
+    if (usedTokens >= config.maxTokens * config.compressionThreshold)
+        stage = 'compressing';
+    else if (usedTokens >= config.maxTokens * config.warningThreshold)
+        stage = 'warning';
+    if (lastCompressedAt > 0 && stage === 'normal')
+        stage = 'compressed';
+    return { usedTokens, maxTokens: config.maxTokens, pct, stage, lastCompressedAt, lastSavedTokens };
+}
+export function getSnapshotsDir(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'context-os', 'snapshots');
+}
+/** 持久化 snapshot 到磁盘 (JSON 文件, 供恢复/调试). 失败静默. */
+export async function saveSnapshotToDisk(snap, home) {
+    try {
+        const dir = getSnapshotsDir(home);
+        await fs.mkdir(dir, { recursive: true });
+        const file = path.join(dir, `${snap.timestamp}-${snap.id.slice(0, 8)}.json`);
+        await fs.writeFile(file, JSON.stringify(snap, null, 2), 'utf-8');
+        return file;
+    }
+    catch {
+        return null;
+    }
+}
+/** 读取最近一次 snapshot (按时间戳). 无 → null. */
+export async function loadLatestSnapshot(home) {
+    try {
+        const dir = getSnapshotsDir(home);
+        const files = (await fs.readdir(dir)).filter(f => f.endsWith('.json')).sort();
+        if (files.length === 0)
+            return null;
+        const raw = await fs.readFile(path.join(dir, files[files.length - 1]), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================
+// ContextManager (单例)
+// ============================================================
+export class ContextManager {
+    config;
+    listeners = new Set();
+    _usage;
+    constructor(config = getContextConfig()) {
+        this.config = config;
+        this._usage = usageFromTokens(0, config);
+    }
+    getConfig() {
+        return this.config;
+    }
+    /** 重载配置 (env 变化/测试用) */
+    reloadConfig(env) {
+        this.config = getContextConfig(env);
+    }
+    getUsage() {
+        return this._usage;
+    }
+    /** 更新当前 token 用量 (由 pi-sdk 每轮 LLM 调用前报告). 返回 stage 是否变化. */
+    updateUsage(usedTokens) {
+        const next = usageFromTokens(usedTokens, this.config, this._usage.lastCompressedAt, this._usage.lastSavedTokens);
+        const prevStage = this._usage.stage;
+        this._usage = next;
+        // warning 边界: normal → warning 时发一次 (不重复发)
+        if (prevStage !== 'warning' && next.stage === 'warning') {
+            this.emit({ type: 'context.warning', usage: next });
+        }
+        return next;
+    }
+    /** 压缩开始: 记录 before, 发事件, 返回 threshold 供日志. */
+    markCompressStart(beforeTokens) {
+        const thresholdTokens = Math.round(this.config.maxTokens * this.config.compressionThreshold);
+        this._usage = { ...this._usage, stage: 'compressing' };
+        this.emit({ type: 'context.compress.start', beforeTokens, thresholdTokens });
+        return thresholdTokens;
+    }
+    /** 压缩完成: 记录 after + snapshot, 发事件. */
+    markCompressComplete(snap) {
+        this._usage = {
+            usedTokens: snap.afterTokens,
+            maxTokens: this.config.maxTokens,
+            pct: snap.afterTokens / this.config.maxTokens,
+            stage: 'compressed',
+            lastCompressedAt: snap.timestamp,
+            lastSavedTokens: Math.max(0, snap.beforeTokens - snap.afterTokens),
+        };
+        this.emit({ type: 'context.compress.complete', snapshot: snap, usage: this._usage });
+        this.emit({ type: 'context.snapshot.created', snapshot: snap });
+        saveSnapshotToDisk(snap).catch(() => { });
+    }
+    /** 订阅事件. 返回取消函数. */
+    onEvent(handler) {
+        this.listeners.add(handler);
+        return () => this.listeners.delete(handler);
+    }
+    emit(evt) {
+        for (const h of this.listeners) {
+            try {
+                h(evt);
+            }
+            catch { /* 单个订阅者失败不影响其余 */ }
+        }
+    }
+    /** 创建 snapshot 对象 (不含 CID, 由调用方决定是否 CID 化) */
+    makeSnapshot(opts) {
+        return {
+            id: randomUUID(),
+            timestamp: Date.now(),
+            beforeTokens: opts.beforeTokens,
+            afterTokens: opts.afterTokens,
+            summary: opts.summary,
+            preservedMemory: opts.preservedMemory ?? [],
+            agentId: opts.agentId,
+            channelId: opts.channelId,
+        };
+    }
+}
+let _manager = null;
+export function getContextManager() {
+    if (!_manager)
+        _manager = new ContextManager();
+    return _manager;
+}
+/** 测试钩子: 重置单例 */
+export function _resetContextManagerForTest() {
+    _manager = null;
+}

package/dist/bootstrap/memory-compressor.js

@@ -14,6 +14,20 @@
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
+/** 统一消息字段: SessionStore (session-store.ts) 用 role, 老 cache 格式用 type. 读成 SessionMessageLite. */
+function toLite(m) {
+    const raw = m && typeof m === 'object' ? m : { content: String(m ?? '') };
+    let type = raw.type ?? raw.role ?? '';
+    if (type === 'assistant')
+        type = 'ai';
+    if (type === 'system' || type === 'tool')
+        type = 'system';
+    return {
+        type: type || 'unknown',
+        content: typeof raw.content === 'string' ? raw.content : JSON.stringify(raw.content ?? ''),
+        timestamp: raw.timestamp || raw.createdAt,
+    };
+}
 export function sanitizeAgentId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
 }
@@ -64,11 +78,9 @@ async function readSessionMessages(sessionCacheFile) {
     try {
         const raw = await fs.readFile(sessionCacheFile, 'utf-8');
         const parsed = JSON.parse(raw);
-        if (Array.isArray(parsed))
-            return parsed;
-        if (Array.isArray(parsed.messages))
-            return parsed.messages;
-        return [];
+        const list = Array.isArray(parsed) ? parsed : Array.isArray(parsed.messages) ? parsed.messages : [];
+        // 2026-08-06: 统一 role/type 字段 (SessionStore 写 role, 老格式写 type), 过滤空壳消息
+        return list.map((m) => toLite(m)).filter(m => m.type !== 'unknown' && m.content);
     }
     catch {
         return [];
@@ -100,22 +112,20 @@ ${aiSnippet || '  (无)'}
 /**
  * 尝试调 LLM 生成更精炼的中文摘要. 失败 → 抛错, 由 caller fallback.
  *
+ * 2026-08-06 修复: 之前调用不存在的 pi-ai.generateText → 100% 抛错 → 永远模板 fallback.
+ * 改用真实接口 getMinimax().chat(userMsg, systemPrompt) (pi-ai.ts 导出的 PiAIModel).
  * 用动态 import + 失败静默 — 不引入 pi-ai 强依赖 (避免循环).
  */
 async function tryLlmSummary(systemPrompt, userPrompt) {
     try {
         const piAi = await import('../llm/pi-ai.js');
-        const generateText = piAi.generateText;
-        if (typeof generateText !== 'function')
-            throw new Error('generateText not exported');
-        const result = await generateText({
-            messages: [
-                { role: 'system', content: systemPrompt },
-                { role: 'user', content: userPrompt },
-            ],
-            temperature: 0.2,
-            maxTokens: 800,
-        });
+        const getMinimax = piAi.getMinimax;
+        if (typeof getMinimax !== 'function')
+            throw new Error('getMinimax not exported');
+        const llm = getMinimax();
+        if (!llm || typeof llm.chat !== 'function')
+            throw new Error('LLM chat not available');
+        const result = await llm.chat(userPrompt, systemPrompt);
         const text = result?.reply || result?.text || '';
         if (typeof text !== 'string' || text.length < 20)
             throw new Error('LLM returned too-short text');