@bolloon/bolloon-agent 0.3.34 → 0.3.36

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}` };
@@ -2103,7 +2131,8 @@ async function ensureKuboReady() {
         }
     }
 }
-async function kuboApi(pathAndQuery, init, timeoutMs = 30000) {
+/** Kubo HTTP API helper (POST only, 2026-08-03 实测 Kubo 只接受 POST). 2026-08-06 export 供 CLI /ipfs /ipns 命令用. */
+export async function kuboApi(pathAndQuery, init, timeoutMs = 30000) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {

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');

package/dist/bootstrap/snip-collapse.js

@@ -45,50 +45,54 @@ export function snipHistory(messages, opts = {}) {
         }
         return m;
     });
+    // Step 3 (提前): 窗口内也截断过长 tool 结果 — 2026-08-06 fix: 原来在 Step 2 return 之后,
+    //   窗口内消息永远走不到 tool 截断 (budgeted.length <= maxMessages 时提前返回).
+    //   originalLength 保留最早值 (budget-reduce 已记录原始长度, 不覆盖).
+    const trimToolResults = (list, boundaryProtected = false) => list.map(m => {
+        if (m.role === 'tool' && m.content.length > maxToolResultChars && m.transform !== 'snip') {
+            return {
+                ...m,
+                content: m.content.slice(0, maxToolResultChars) + `\n[...工具结果截断]`,
+                originalLength: m.originalLength ?? m.content.length,
+                transform: m.transform || 'snip-tool',
+            };
+        }
+        return m;
+    });
     // Step 2: Snip — 超过 maxMessages 时裁最老的
     if (budgeted.length <= maxMessages)
-        return budgeted;
-    // 工具调用链保护: 从尾部往前数, 保留最近的 assistant+tool 对
+        return trimToolResults(budgeted);
     const keepCount = maxMessages;
-    const result = [];
     const toRemove = budgeted.length - keepCount;
-    // 策略: 从最老的开始裁, 但要保证不会裁掉未配对的 assistant (tool_calls)
-    // 遍历时追踪 "悬空的 tool 消息" 保护
-    let removed = 0;
-    let protectedToolChain = 0; // 从尾部连续 tool 消息不裁
-    for (let i = budgeted.length - 1; i >= 0; i--) {
-        const m = budgeted[i];
-        if (m.role === 'tool' && protectedToolChain < 5) {
-            protectedToolChain++;
-        }
-        else if (m.role === 'assistant' && protectedToolChain > 0) {
-            // 遇到 assistant 代表这个工具链结束了
+    // 2026-08-06 重写: 原实现 protectedToolChain 计数逻辑混乱 (assistant 分支不重置,
+    //   条件 `budgeted.length - i > protectedToolChain` 语义错误), 且占位符路径只在
+    //   removed<=toRemove 时生效导致被裁消息数与实际不符.
+    //   新语义:
+    //     - 从头部裁 toRemove 条 (最老历史), 占位区间 = [0, removedIndex)
+    //     - 裁剪边界保护: 若保留区第一条是 tool 且前一条是 assistant, assistant 天然在
+    //       移除区 → 它变成占位符, 保持 [assistant占位, tool] 相邻, 不产生悬空 tool
+    //       (原生 tool_calls 路径要求 assistant→tool 相邻; 占位保留 role 序列形状)
+    //     - 被裁消息 → '[已裁减, Snip]' 占位符 (保留 role 顺序, 防配对错乱)
+    const result = [];
+    const removedIndex = budgeted.length - keepCount; // 保留区起点 (含)
+    // 边界保护 (2026-08-06 fix): 只验证不改变 cutAt —
+    //   之前 `cutAt -= 1` 把占位区间缩窄, 导致边界 assistant 反而保留 (悬空 tool 依旧).
+    //   assistant 本来就在移除区 [0, removedIndex), 转占位后 tool 前紧邻占位 assistant, 配对形状保持.
+    const firstKept = budgeted[removedIndex];
+    const before = removedIndex > 0 ? budgeted[removedIndex - 1] : undefined;
+    // boundaryProtected 仅语义标记 (测试/日志用), 占位区间不变
+    const boundaryProtected = firstKept.role === 'tool' && before?.role === 'assistant';
+    if (boundaryProtected) { /* 保护生效: tool 前紧邻占位 assistant */ }
+    for (let i = 0; i < budgeted.length; i++) {
+        if (i < removedIndex) {
+            result.push({ ...budgeted[i], content: '[已裁减, Snip]', originalLength: budgeted[i].content.length, transform: 'snip' });
         }
         else {
-            protectedToolChain = 0;
+            result.push(budgeted[i]);
         }
-        // 如果在保护区内, 不裁
-        if (i < budgeted.length - keepCount && budgeted.length - i > protectedToolChain) {
-            removed++;
-            if (removed <= toRemove) {
-                result.unshift({ ...m, content: '[已裁减, Snip]', transform: 'snip' });
-                continue;
-            }
-        }
-        result.unshift(m);
     }
     // Step 3: 如果 tool result 仍然太长, 进一步截断
-    return result.map(m => {
-        if (m.role === 'tool' && m.content.length > maxToolResultChars) {
-            return {
-                ...m,
-                content: m.content.slice(0, maxToolResultChars) + `\n[...工具结果截断]`,
-                originalLength: m.content.length,
-                transform: m.transform || 'snip-tool',
-            };
-        }
-        return m;
-    });
+    return trimToolResults(result);
 }
 /**
  * Phase 3: Context Collapse — 读时虚拟投影.

package/dist/cli/ink-app.js

@@ -62,6 +62,21 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
     const skillCache = useRef(null);
     const pluginCache = useRef(null);
     const fileCache = useRef(null);
+    // ── 程序化选择器 (2026-08-06: /login /model 等命令触发, 复用 MentionPopup 渲染) ──
+    const [picker, setPicker] = useState(null);
+    const pickerCb = useRef(null);
+    const pickerSelRef = useRef(0);
+    // 全局钩子: index.ts 命令打开/关闭选择器
+    useEffect(() => {
+        globalThis.__inkOpenPicker = (itemsArg, title, onPick) => {
+            pickerSelRef.current = 0;
+            pickerCb.current = onPick;
+            setPicker({ title: title || '选择', items: itemsArg, sel: 0 });
+            setInput('');
+        };
+        globalThis.__inkClosePicker = () => { pickerCb.current = null; setPicker(null); };
+        return () => { delete globalThis.__inkOpenPicker; delete globalThis.__inkClosePicker; };
+    }, []);
     // ── 输入历史 (↑/↓ 切换) ───────────────────────────────────────────────────
     const historyRef = useRef([]);
     const historyIdxRef = useRef(-1); // -1 = 正在编辑新草稿
@@ -296,6 +311,34 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
             requestExit();
             return;
         }
+        // ── 程序化选择器: 全键接管 (↑↓ 选择, Enter 确认, Esc 关闭) ──
+        if (picker) {
+            const itemsArg = picker.items;
+            if (key.upArrow) {
+                pickerSelRef.current = Math.max(0, pickerSelRef.current - 1);
+                setPicker({ ...picker, sel: pickerSelRef.current });
+                return;
+            }
+            if (key.downArrow) {
+                pickerSelRef.current = Math.min(itemsArg.length - 1, pickerSelRef.current + 1);
+                setPicker({ ...picker, sel: pickerSelRef.current });
+                return;
+            }
+            if ((key.return || key.tab) && itemsArg.length > 0) {
+                const it = itemsArg[Math.min(pickerSelRef.current, itemsArg.length - 1)];
+                const cb = pickerCb.current;
+                pickerCb.current = null;
+                setPicker(null);
+                cb?.(it);
+                return;
+            }
+            if (key.escape) {
+                pickerCb.current = null;
+                setPicker(null);
+                return;
+            }
+            return; // 其余键忽略
+        }
         // ── 弹出窗打开: 全键接管 (TextInput focus=false 不处理) ──
         if (popupOpen) {
             if (key.upArrow) {
@@ -456,7 +499,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: "white", children: '─'.repeat(terminalW) }) }), _jsx(Box, { children: _jsx(Text, { children: status }) }), _jsx(Box, { children: _jsx(Text, { bold: true, color: "white", children: '─'.repeat(terminalW) }) }), popupOpen && (tabState || mention) && (_jsx(MentionPopup, { title: popupTitle, items: filtered, sel: safeSel, width: terminalW, loading: loadingFiles })), _jsxs(Box, { children: [_jsx(Text, { bold: true, color: "green", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit, focus: !popupOpen, 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: "white", 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..."] }) }))] }), _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 };
 // ─── 启动 ────────────────────────────────────────────────────────────────────