@bolloon/bolloon-agent 0.3.32 → 0.3.34

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

@@ -2574,6 +2574,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/cli/ink-app.js

@@ -251,6 +251,10 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
     const [tiKey, setTiKey] = useState(0);
     // 全局: 思考动画控制
     useEffect(() => {
+        // 2026-08-06: 防御 — 某些环境 (tsx/完整 CLI 初始化) 下 stdin 会处于 paused,
+        // 不恢复则 useInput 收不到任何输入 (实测 isPaused=true, listeners=0)
+        if (process.stdin.isPaused())
+            process.stdin.resume();
         globalThis.__inkSetThinking = (v) => setThinking(v);
         globalThis.__inkAppend = (line) => {
             setMsgs(prev => [...prev, line]);
@@ -308,6 +312,15 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
                     acceptMention(it);
                 return;
             }
+            if (key.return && filtered.length === 0) {
+                // 弹窗无匹配项: Enter = 提交当前输入 (否则 /channel 无参 + Enter 永远提交不了 — 2026-08-06)
+                const v = input.trim();
+                if (v)
+                    onSubmit(v);
+                else
+                    setDismissed(mentionKey);
+                return;
+            }
             if (key.escape) {
                 if (tabState)
                     setTabState(null);
@@ -346,11 +359,11 @@ const InkApp = ({ onPrompt, initialStatus, getStatusUpdate, terminalW, terminalH
                 });
                 return;
             }
-            if (_input && !key.ctrl && !key.meta) {
+            if (_input && !key.ctrl && !key.meta && !key.return) {
                 setInput(cur => cur + _input);
                 return;
             }
-            return; // 其余键忽略
+            return; // 其余键忽略 (return/tab/esc 等由 TextInput 或上层处理)
         }
         // ── 正常模式 ──
         // Tab 命令补齐 (无触发符的普通 token 也补)

package/dist/cli/mention-data.js

@@ -151,11 +151,14 @@ const SKIP_DIRS = new Set([
     'coverage', '.next', '.nuxt', '.venv', 'venv', '__pycache__', 'tmp', 'release',
     '.bolloon', '.boll', '.turbo', '.idea', '.vscode', 'bin', 'lib', 'assets',
 ]);
-/** cwd 有限深度 BFS, 只收文件, 上限 cap 个, 排序稳定 */
-export async function loadFiles(_query, base = process.cwd(), maxDepth = 3, cap = 400) {
+/** cwd 有限深度 BFS, 只收文件, 上限 cap 个, 排序稳定; 超时兜底 (冷缓存 fs.readdir 偶发挂起, 2026-08-05) */
+export async function loadFiles(_query, base = process.cwd(), maxDepth = 3, cap = 400, timeoutMs = 5000) {
     const out = [];
+    const deadline = Date.now() + timeoutMs;
     const stack = [{ dir: base, depth: 0 }];
     while (stack.length > 0 && out.length < cap) {
+        if (Date.now() > deadline)
+            break; // 超时返回已收集部分, 弹窗不卡"扫描中"
         const { dir, depth } = stack.pop();
         let entries;
         try {

package/dist/index.js

@@ -360,15 +360,24 @@ const pendingQueue = [];
 let cliStartTime = 0;
 let cliModelName = '…';
 let cliAgentName = '…';
+let cliActiveChannelId = null;
 function fmtDuration(ms) {
     const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
     const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${s % 60}s`;
     const h = Math.floor(m / 60);
-    if (h > 0)
-        return `${h}h${m % 60}m`;
-    if (m > 0)
-        return `${m}m${s % 60}s`;
-    return `${s}s`;
+    return `${h}h ${m % 60}m`;
+}
+/** 状态栏: 模型 │ 当前智能体 (含 channel) │ ⏱ 时间 │ 上下文进度条 (模块级, CLI/Web 共用) */
+function getStatus() {
+    const barLen = 12;
+    const filled = Math.round((cliContextPct / 100) * barLen);
+    const bar = '█'.repeat(filled) + '░'.repeat(barLen - filled);
+    const agentPart = cliActiveChannelId ? `${cliAgentName} ${C_DIM}(ch:${cliActiveChannelId.slice(0, 10)})${RESET}` : cliAgentName;
+    return `${C_ACCENT}${cliModelName}\x1b[0m\x1b[90m  │\x1b[0m ${agentPart} \x1b[90m│\x1b[0m ⏱ ${fmtDuration(Date.now() - cliStartTime)}\x1b[90m │\x1b[0m ${bar} ${cliContextPct}%`;
 }
 function statusBarLine() {
     const dur = cliStartTime ? fmtDuration(Date.now() - cliStartTime) : '0s';
@@ -412,14 +421,22 @@ async function startCLI(comm) {
     cliModelName = foundProvider ? foundProvider[1] : '未配置';
     cliAgentName = agentIdentity?.name || 'bolloon';
     cliStartTime = Date.now();
+    // 恢复上次 active channel (session 恢复: CLI 与 Web 共用 active-channel.json)
+    try {
+        const { getIdentityStore } = await import('./agents/agent-identity-store.js');
+        const store = getIdentityStore();
+        await store.load();
+        const active = await store.getActive();
+        if (active) {
+            cliAgentName = active.name;
+            cliActiveChannelId = active.channelId ?? null;
+        }
+    }
+    catch {
+        /* 无 channels/active 记录时保持默认 */
+    }
     // 进入 Ink TUI 输入循环
     const initialStatus = `${C_ACCENT}${cliModelName}\x1b[0m\x1b[90m  │\x1b[0m ${cliAgentName} \x1b[90m│\x1b[0m ⏱ 0s`;
-    const getStatus = () => {
-        const barLen = 12;
-        const filled = Math.round((cliContextPct / 100) * barLen);
-        const bar = '█'.repeat(filled) + '░'.repeat(barLen - filled);
-        return `${C_ACCENT}${cliModelName}\x1b[0m\x1b[90m  │\x1b[0m ${cliAgentName} \x1b[90m│\x1b[0m ⏱ ${fmtDuration(Date.now() - cliStartTime)}\x1b[90m │\x1b[0m ${bar} ${cliContextPct}%`;
-    };
     startInk((text) => { processInput(text, comm); }, initialStatus, getStatus);
     // Wait on a promise that resolves on Ctrl+C / 双击 Esc
     // (ink-app 的 requestExit 调 __inkRequestExit → resolve, 清理后 process.exit)
@@ -461,6 +478,49 @@ async function processInput(input, comm) {
         appendLine(`${C_DIM}──${RESET}`);
         return;
     }
+    // /channel — 切换当前智能体 (agent channel), 参数 name/id/number 自动解析
+    if (trimmed.toLowerCase().startsWith('/channel')) {
+        const q = trimmed.slice('/channel'.length).trim();
+        try {
+            const { getIdentityStore } = await import('./agents/agent-identity-store.js');
+            const store = getIdentityStore();
+            await store.load();
+            if (!q) {
+                // 无参: 列出所有 channel + active
+                const list = await store.listForDisplay();
+                const active = await store.getActive();
+                if (list.length === 0) {
+                    appendLine(`${C_DIM}暂无智能体 channel (channels.json 为空)${RESET}`);
+                    return;
+                }
+                appendLine(`${C_ACCENT}智能体列表:${RESET} (${active ? `当前: ${active.name}` : ''})`);
+                for (const { index, identity, active: isActive } of list) {
+                    const mark = isActive ? '●' : '○';
+                    appendLine(`  ${mark} ${index}. ${identity.name}  ${C_DIM}${identity.id.slice(0, 24)}${RESET}`);
+                }
+                appendLine(`${C_DIM}用法: /channel <名字|id|序号>${RESET}`);
+                return;
+            }
+            const r = await store.resolve(q);
+            if (!r) {
+                appendLine(`${C_ERROR}未找到智能体: '${q}'${RESET} (可用 /channel 查看列表)`);
+                return;
+            }
+            const prev = await store.getActive();
+            await store.setActive(r.channel.id);
+            cliAgentName = r.identity.name;
+            cliActiveChannelId = r.channel.id;
+            inkSetStatus(getStatus()); // 触发状态栏立即重绘 (无需等 1s 定时器)
+            const extra = prev && prev.name !== r.identity.name ? ` (从 ${prev.name} 切换)` : '';
+            appendLine(`${C_ACCENT}→ 当前智能体: ${r.identity.name}${RESET}${extra}`);
+            appendLine(`${C_DIM}  channel: ${r.channel.id}  [${r.match}]${RESET}`);
+            appendLine(`${C_DIM}  persona: ${r.channel.persona?.description || r.channel.persona?.personality || '无'}${RESET}`);
+        }
+        catch (e) {
+            appendLine(`${C_ERROR}/channel 失败: ${String(e.message || e).slice(0, 200)}${RESET}`);
+        }
+        return;
+    }
     // /queue — 切换队列模式
     if (trimmed.toLowerCase() === '/queue') {
         queueMode = !queueMode;
@@ -493,6 +553,7 @@ async function processInput(input, comm) {
         appendLine(`  ${C_ACCENT}!<cmd>${RESET}  执行终端命令  ${C_DIM}如 !ls -la${RESET}`);
         appendLine(`  ${C_ACCENT}/queue${RESET}  切换队列模式  ${C_DIM}输入排队, 当前结束后自动执行${RESET}`);
         appendLine(`  ${C_ACCENT}/dequeue${RESET} 出队一条`);
+        appendLine(`  ${C_ACCENT}/channel [名字|id|序号]${RESET} 切换当前智能体  ${C_DIM}无参列出所有; 支持名字/ID/序号三种解析${RESET}`);
         appendLine(`  ${C_ACCENT}@名字${RESET}     @ 命中智能体  ${C_DIM}弹出窗选择后发送给智能体${RESET}`);
         appendLine(`  ${C_ACCENT}/名字${RESET}     / 命中命令/技能/插件  ${C_DIM}输入 / 自动弹出${RESET}`);
         appendLine(`  ${C_ACCENT}#路径${RESET}     # 命中文件  ${C_DIM}输入 # 自动弹出文件列表${RESET}`);

package/dist/orbitdb/agent-tools.js

@@ -0,0 +1,225 @@
+/**
+ * agent-tools.ts — OrbitDB/CID 数据层的 agent 工具注册 (2026-08-06)
+ *
+ * 注册 10 个工具 (懒加载: 首次调用才拉起 helia, 不阻塞启动):
+ *   cid_save / cid_load / cid_update / cid_version / cid_list / cid_share
+ *   context_save_snapshot / context_restore
+ *   ui_save_component / ui_load_component
+ *
+ * 对应 Step 7 能力: agent.createMemory (cid_save type=memory),
+ *   context.saveSnapshot (context_save_snapshot), ui.loadCID (ui_load_component),
+ *   share(cid) (cid_share).
+ */
+/** 包装: 动态 import cid-database (首调拉起 helia) */
+async function db() {
+    const { getCIDDatabase } = await import('./cid-database.js');
+    return getCIDDatabase();
+}
+async function contextStore() {
+    const { getContextStore } = await import('./context-store.js');
+    return getContextStore();
+}
+async function uiStore() {
+    const { getUICidStore } = await import('./ui-cid.js');
+    return getUICidStore();
+}
+const fmt = (o) => JSON.stringify(o, null, 2).slice(0, 3000);
+export function registerOrbitdbTools(ctx) {
+    ctx.tools.set('cid_save', {
+        name: 'cid_save',
+        description: '保存数据到去中心化数据库 (OrbitDB), 返回内容寻址 CID. type 支持 memory/context/state/ui/knowledge. 同内容同 CID, 可用 cid_load 读回、cid_share 分享、cid_update 更新版本.',
+        parameters: { agentId: '所属智能体 id (必填)', type: '记录类型: memory/context/state/ui/knowledge (必填)', content: '要保存的数据 (JSON 对象, 必填)', metadata: '可选元数据 (JSON 对象)' },
+        execute: async (args) => {
+            try {
+                const agentId = String(args.agentId || '').trim();
+                const type = String(args.type || '').trim();
+                if (!agentId || !type)
+                    return { success: false, error: 'agentId 和 type 必填' };
+                const content = args.content ?? {};
+                const metadata = typeof args.metadata === 'object' && args.metadata ? args.metadata : undefined;
+                const rec = await (await db()).save({ agentId, type: type, content, metadata });
+                return { success: true, output: `✅ 已保存 (type=${type}):\n  CID: ${rec.id}\n  version: ${rec.version}\n  读回: cid_load(cid="${rec.id}")\n  分享: cid_share(cid="${rec.id}")` };
+            }
+            catch (e) {
+                return { success: false, error: `cid_save 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('cid_load', {
+        name: 'cid_load',
+        description: '按 CID 从去中心化数据库加载记录 (含跨节点分享的). 返回完整记录: id/agentId/timestamp/type/content/metadata/version.',
+        parameters: { cid: '记录 CID (必填)' },
+        execute: async (args) => {
+            try {
+                const cid = String(args.cid || '').trim();
+                if (!cid)
+                    return { success: false, error: 'cid 必填' };
+                const rec = await (await db()).load(cid);
+                if (!rec)
+                    return { success: false, error: `记录不存在: ${cid}` };
+                return { success: true, output: `📄 ${cid}\n${fmt(rec)}` };
+            }
+            catch (e) {
+                return { success: false, error: `cid_load 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('cid_update', {
+        name: 'cid_update',
+        description: '更新记录 → 生成新版本 (parentId 指向旧 CID). 用 cid_version 查看版本链.',
+        parameters: { cid: '旧记录 CID (必填)', content: '新内容 (JSON, 必填)', metadata: '可选新元数据' },
+        execute: async (args) => {
+            try {
+                const cid = String(args.cid || '').trim();
+                if (!cid)
+                    return { success: false, error: 'cid 必填' };
+                const rec = await (await db()).update(cid, args.content ?? {}, typeof args.metadata === 'object' && args.metadata ? args.metadata : undefined);
+                if (!rec)
+                    return { success: false, error: `记录不存在: ${cid}` };
+                return { success: true, output: `✅ 已更新 v${rec.version}:\n  新 CID: ${rec.id}\n  版本链: cid_version(cid="${rec.id}")` };
+            }
+            catch (e) {
+                return { success: false, error: `cid_update 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('cid_version', {
+        name: 'cid_version',
+        description: '查看记录的完整版本链 (从旧到新).',
+        parameters: { cid: '任意版本 CID (必填)' },
+        execute: async (args) => {
+            try {
+                const cid = String(args.cid || '').trim();
+                if (!cid)
+                    return { success: false, error: 'cid 必填' };
+                const chain = await (await db()).version(cid);
+                if (chain.length === 0)
+                    return { success: false, error: `记录不存在: ${cid}` };
+                return { success: true, output: `📚 版本链 (${chain.length} 个版本):\n${chain.map(r => `  v${r.version} ${r.id} ${new Date(r.timestamp).toISOString()}${r.parentId ? '' : ' (根)'}`).join('\n')}` };
+            }
+            catch (e) {
+                return { success: false, error: `cid_version 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('cid_list', {
+        name: 'cid_list',
+        description: '列出数据库记录 (可按 agentId / type 过滤). 适合查看某个智能体的全部记忆/状态/组件.',
+        parameters: { agentId: '可选: 按智能体过滤', type: '可选: 按类型过滤 (memory/context/state/ui/knowledge)' },
+        execute: async (args) => {
+            try {
+                const agentId = String(args.agentId || '').trim() || undefined;
+                const type = String(args.type || '').trim() || undefined;
+                const list = await (await db()).list({ agentId, type });
+                if (list.length === 0)
+                    return { success: true, output: '📭 无记录' };
+                return { success: true, output: `📋 ${list.length} 条记录:\n${list.slice(-20).map(r => `  v${r.version} [${r.type}] ${r.id.slice(0, 24)}… ${new Date(r.timestamp).toISOString().slice(0, 19)}`).join('\n')}` };
+            }
+            catch (e) {
+                return { success: false, error: `cid_list 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('cid_share', {
+        name: 'cid_share',
+        description: '分享记录: 把记录块写入 IPFS 网络 (helia blockstore), 返回 bolloon-cid:// 引用, 其他节点可用 cid_load 拉取.',
+        parameters: { cid: '记录 CID (必填)' },
+        execute: async (args) => {
+            try {
+                const cid = String(args.cid || '').trim();
+                if (!cid)
+                    return { success: false, error: 'cid 必填' };
+                const ref = await (await db()).share(cid);
+                return { success: true, output: `🔗 已分享: ${ref}` };
+            }
+            catch (e) {
+                return { success: false, error: `cid_share 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('context_save_snapshot', {
+        name: 'context_save_snapshot',
+        description: '保存 Context OS 快照: 抓取当前资产层 + 可选记忆摘要/focus → CID 版本化. 用 context_restore 恢复.',
+        parameters: { agentId: '智能体 id (必填)', memorySummary: '可选: 当前记忆摘要', focus: '可选: 当前 focus' },
+        execute: async (args) => {
+            try {
+                const agentId = String(args.agentId || '').trim();
+                if (!agentId)
+                    return { success: false, error: 'agentId 必填' };
+                const store = await contextStore();
+                const snap = await store.captureCurrentContext(agentId, {
+                    memorySummary: String(args.memorySummary || '').trim() || undefined,
+                    focus: String(args.focus || '').trim() || undefined,
+                });
+                const rec = await store.saveSnapshot(snap);
+                return { success: true, output: `📸 Context 快照已保存:\n  CID: ${rec.id}\n  layers: ${Object.keys(snap.layers).filter(k => snap.layers[k].length).length} 层有资产\n  恢复: context_restore(agentId="${agentId}")` };
+            }
+            catch (e) {
+                return { success: false, error: `context_save_snapshot 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('context_restore', {
+        name: 'context_restore',
+        description: '恢复某智能体最近一次 Context 快照 (含资产层/记忆摘要/focus). 用于跨会话恢复上下文.',
+        parameters: { agentId: '智能体 id (必填)' },
+        execute: async (args) => {
+            try {
+                const agentId = String(args.agentId || '').trim();
+                if (!agentId)
+                    return { success: false, error: 'agentId 必填' };
+                const snap = await (await contextStore()).restoreContext(agentId);
+                if (!snap)
+                    return { success: false, error: `无快照: ${agentId}` };
+                return { success: true, output: `♻️ 已恢复 ${agentId} 的 Context 快照 (${new Date(snap.capturedAt).toISOString()}):\n${fmt(snap).slice(0, 2500)}` };
+            }
+            catch (e) {
+                return { success: false, error: `context_restore 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('ui_save_component', {
+        name: 'ui_save_component',
+        description: '保存 UI 组件到去中心化存储 (CID 化). code 是 React 函数组件源码 (function Name(props){ return React.createElement(...) }), framework 默认 react. 之后可用 ui_load_component 按 CID 动态加载渲染.',
+        parameters: { agentId: '智能体 id (必填)', name: '组件名 (必填)', code: 'React 组件源码 (必填)', framework: '可选: react/vanilla', theme: '可选: 主题 JSON', description: '可选: 组件说明' },
+        execute: async (args) => {
+            try {
+                const agentId = String(args.agentId || '').trim();
+                const name = String(args.name || '').trim();
+                const code = String(args.code || '').trim();
+                if (!agentId || !name || !code)
+                    return { success: false, error: 'agentId/name/code 必填' };
+                const rec = await (await uiStore()).saveComponent(agentId, {
+                    name,
+                    code,
+                    framework: args.framework === 'vanilla' ? 'vanilla' : 'react',
+                    theme: typeof args.theme === 'object' && args.theme ? args.theme : undefined,
+                    description: String(args.description || '').trim() || undefined,
+                });
+                return { success: true, output: `🖼️ UI 组件已保存: ${name}\n  CID: ${rec.id}\n  加载: ui_load_component(cid="${rec.id}")` };
+            }
+            catch (e) {
+                return { success: false, error: `ui_save_component 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('ui_load_component', {
+        name: 'ui_load_component',
+        description: '按 CID 加载 UI 组件定义 (代码/theme/propsSchema). 配合 React 前端可动态渲染.',
+        parameters: { cid: '组件 CID (必填)' },
+        execute: async (args) => {
+            try {
+                const cid = String(args.cid || '').trim();
+                if (!cid)
+                    return { success: false, error: 'cid 必填' };
+                const def = await (await uiStore()).loadComponent(cid);
+                if (!def)
+                    return { success: false, error: `组件不存在: ${cid}` };
+                return { success: true, output: `🖼️ ${def.name} (${def.framework})\n  CID: ${cid}\n  theme: ${def.theme ? fmt(def.theme) : '无'}\n  code:\n${String(def.code).slice(0, 1500)}` };
+            }
+            catch (e) {
+                return { success: false, error: `ui_load_component 失败: ${String(e.message || e).slice(0, 200)}` };
+            }
+        }
+    });
+}

package/dist/orbitdb/cid-database.js

@@ -0,0 +1,174 @@
+/**
+ * cid-database.ts — 统一 CID 数据库层: CIDDatabase 接口 + OrbitDBAdapter (2026-08-06)
+ *
+ * 数据模型 (用户设计):
+ *   {
+ *     id: CID,            // 内容寻址 CID (dag-cbor encode + sha2-256, 内容不变 CID 不变)
+ *     agentId: string,
+ *     timestamp: number,
+ *     type: "memory" | "context" | "state" | "ui" | "knowledge",
+ *     content: object,
+ *     metadata: object,
+ *     version: number,    // 版本号 (update 递增)
+ *     parentId?: string   // 上一版本 CID (版本链)
+ *   }
+ *
+ * 存储:
+ *   - OrbitDB keyvalue store (持久化 ~/.bolloon/orbitdb/, 数据库名 bolloon-cid-store)
+ *   - key = record.id (CID), 支持 save/load/update/version/list/share
+ *   - CID 用 multiformats 本地计算 (不依赖 helia dag API), share() 时才把块放入 helia
+ */
+import { CID } from 'multiformats/cid';
+import * as dagCbor from '@ipld/dag-cbor';
+import { sha256 } from 'multiformats/hashes/sha2';
+import { concat as uint8Concat } from 'uint8arrays/concat';
+import { createOrbitDB } from '@orbitdb/core';
+import { createBolloonIpfs } from './ipfs-node.js';
+import * as path from 'path';
+import * as os from 'os';
+/** 内容 → CID (dag-cbor, sha2-256, codec 0x71); 先 JSON 清洗 (dag-cbor 不支持 undefined) */
+export async function contentToCid(obj) {
+    const cleaned = JSON.parse(JSON.stringify(obj)); // 丢弃 undefined 字段
+    const bytes = dagCbor.encode(cleaned);
+    const hash = await sha256.digest(bytes);
+    return CID.createV1(0x71, hash).toString();
+}
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+/**
+ * OrbitDB 后端实现。单例: 同一进程只建一个 (helia/OrbitDB 都是重量级节点)。
+ */
+export class OrbitDBAdapter {
+    dataDir;
+    node = null;
+    db = null;
+    _orbitdb = null;
+    orbitdb;
+    constructor(dataDir = path.join(home(), '.bolloon', 'orbitdb')) {
+        this.dataDir = dataDir;
+    }
+    /** 懒初始化: 首次使用时启动 helia + OrbitDB + 打开 keyvalue store */
+    async ensure() {
+        if (this.db)
+            return;
+        this.node = await createBolloonIpfs(path.join(this.dataDir, 'ipfs'));
+        this._orbitdb = await createOrbitDB({
+            ipfs: this.node.helia,
+            directory: path.join(this.dataDir, 'stores'),
+        });
+        this.db = await this._orbitdb.open('bolloon-cid-store', { type: 'keyvalue' });
+        // 共享底层实例 (只读暴露)
+        this.orbitdb = this._orbitdb;
+    }
+    async save(data) {
+        await this.ensure();
+        // 内容寻址: CID 只基于业务内容 (agentId/type/content), 不含时间戳/版本 → 同内容同 CID
+        const record = {
+            id: await contentToCid({ agentId: data.agentId, type: data.type, content: data.content }),
+            agentId: data.agentId,
+            timestamp: Date.now(),
+            type: data.type,
+            content: data.content,
+            metadata: data.metadata ?? {},
+            version: 1,
+            dbAddress: this.db.address,
+        };
+        // OrbitDB 用 dag-cbor 编码 value, 不支持 undefined 字段 → put 前 JSON 清洗
+        await this.db.put(record.id, JSON.parse(JSON.stringify(record)));
+        return record;
+    }
+    async load(cid) {
+        await this.ensure();
+        const rec = await this.db.get(cid);
+        if (rec)
+            return rec;
+        // KV 无 → 尝试从 helia 拉块 (网络分享的 CID)
+        try {
+            const stream = this.node.helia.blockstore.get(CID.parse(cid));
+            let bytes = new Uint8Array(0);
+            for await (const chunk of stream)
+                bytes = uint8Concat([bytes, chunk]);
+            return dagCbor.decode(bytes);
+        }
+        catch {
+            return null;
+        }
+    }
+    async update(cid, content, metadata) {
+        await this.ensure();
+        const old = await this.load(cid);
+        if (!old)
+            return null;
+        const record = {
+            id: await contentToCid({ agentId: old.agentId, type: old.type, content }),
+            agentId: old.agentId,
+            timestamp: Date.now(),
+            type: old.type,
+            content,
+            metadata: metadata ?? old.metadata,
+            version: old.version + 1,
+            parentId: old.id,
+            dbAddress: this.db.address,
+        };
+        await this.db.put(record.id, JSON.parse(JSON.stringify(record)));
+        return record;
+    }
+    async version(cid) {
+        await this.ensure();
+        const chain = [];
+        let cur = await this.load(cid);
+        // 从目标 CID 往回找最老, 再正序返回
+        const rev = [];
+        let guard = 0;
+        while (cur && guard++ < 1000) {
+            rev.push(cur);
+            cur = cur.parentId ? await this.load(cur.parentId) : null;
+        }
+        return rev.reverse();
+    }
+    async list(filter) {
+        await this.ensure();
+        // OrbitDB keyvalue.all() 返回 [{ key, value, hash }] 数组
+        const all = (await this.db.all());
+        const records = all.map(e => e.value);
+        return records
+            .filter(r => {
+            if (!r || typeof r !== 'object')
+                return false;
+            if (filter?.agentId && r.agentId !== filter.agentId)
+                return false;
+            if (filter?.type && r.type !== filter.type)
+                return false;
+            return true;
+        })
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+    async share(cid) {
+        await this.ensure();
+        const rec = await this.load(cid);
+        if (!rec)
+            throw new Error(`记录不存在: ${cid}`);
+        // 把记录块写入 helia blockstore, 供网络 peers 通过 DHT 拉取
+        await this.node.helia.blockstore.put(CID.parse(rec.id), dagCbor.encode(rec));
+        return `bolloon-cid://${rec.id}`;
+    }
+    async close() {
+        try {
+            await this._orbitdb?.stop();
+        }
+        catch { /* 忽略 */ }
+        try {
+            await this.node?.stop();
+        }
+        catch { /* 忽略 */ }
+        this.db = null;
+        this._orbitdb = null;
+        this.node = null;
+    }
+}
+/** 单例访问 (server/CLI 共享) */
+let _adapter = null;
+export function getCIDDatabase() {
+    if (!_adapter)
+        _adapter = new OrbitDBAdapter();
+    return _adapter;
+}

package/dist/orbitdb/context-store.js

@@ -0,0 +1,92 @@
+/**
+ * context-store.ts — Context OS 的 CID 化适配层 (2026-08-06)
+ *
+ * 在现有 Context OS 文件夹体系之上叠加 CID 快照/版本/共享能力 (不动原实现):
+ *   - saveSnapshot: 抓取当前资产层 (readContextAssets) → 存 CIDDatabase (type: 'context')
+ *   - restoreContext: 按 agentId 恢复最近快照
+ *   - contextVersions: 快照版本历史
+ *   - sharedMemory: 多 agent 共享记忆 (type: 'memory' 记录跨 agent 可见)
+ *
+ * 架构: Agent → ContextStore → CIDDatabase → OrbitDB → CID → IPFS
+ */
+import { getCIDDatabase, } from './cid-database.js';
+import { readContextAssets } from '../bootstrap/context-os.js';
+/** 快照 → 可用于恢复的上下文文本 (注入 prompt 用) */
+export function formatSnapshot(s) {
+    const lines = [`[Context 快照 @${new Date(s.capturedAt).toISOString()}]`];
+    for (const [layer, assets] of Object.entries(s.layers)) {
+        if (assets.length)
+            lines.push(`  ${layer}: ${assets.join(', ')}`);
+    }
+    if (s.memorySummary)
+        lines.push(`  记忆: ${s.memorySummary.slice(0, 200)}`);
+    if (s.focus)
+        lines.push(`  focus: ${s.focus}`);
+    return lines.join('\n');
+}
+export class ContextStore {
+    db;
+    constructor(db = getCIDDatabase()) {
+        this.db = db;
+    }
+    /** 抓取当前 Context OS 资产层 → 快照 (与现有 readContextAssets 打通; ctx 可带 identity/channel) */
+    async captureCurrentContext(agentId, extra, ctx) {
+        const layers = {};
+        try {
+            const listings = await readContextAssets();
+            for (const l of listings) {
+                layers[l.layer] = (l.files ?? []).map(a => a.file);
+            }
+        }
+        catch {
+            /* 资产层读取失败不阻塞快照 */
+        }
+        return {
+            agentId,
+            layers,
+            memorySummary: extra?.memorySummary,
+            focus: extra?.focus,
+            capturedAt: Date.now(),
+            identity: ctx?.identity,
+            channelId: ctx?.channelId,
+        };
+    }
+    /** 保存快照 → CID 记录 (type: 'context') */
+    async saveSnapshot(snapshot) {
+        return this.db.save({
+            agentId: snapshot.agentId,
+            type: 'context',
+            content: snapshot,
+            metadata: { kind: 'context-snapshot' },
+        });
+    }
+    /** 恢复: agentId 最近一次快照 */
+    async restoreContext(agentId) {
+        const snaps = await this.db.list({ agentId, type: 'context' });
+        const latest = snaps[snaps.length - 1];
+        return latest ? latest.content : null;
+    }
+    /** 快照版本历史 (全量, 从旧到新) */
+    async contextVersions(agentId) {
+        return this.db.list({ agentId, type: 'context' });
+    }
+    /** 多 agent 共享记忆: 全部 memory 记录 (跨 agent 可见), 可指定 agentId */
+    async sharedMemory(agentId) {
+        return this.db.list(agentId ? { agentId, type: 'memory' } : { type: 'memory' });
+    }
+    /** 保存一条记忆 (多 agent 共享池) */
+    async saveMemory(agentId, content, metadata) {
+        return this.db.save({ agentId, type: 'memory', content, metadata: { ...metadata, kind: 'shared-memory' } });
+    }
+    /** 按 CID 恢复任意记录 (含跨节点分享的) */
+    async loadRecord(cid) {
+        return this.db.load(cid);
+    }
+}
+/** 单例 */
+let _contextStore = null;
+export function getContextStore() {
+    if (!_contextStore)
+        _contextStore = new ContextStore();
+    return _contextStore;
+}

package/dist/orbitdb/ipfs-node.js

@@ -0,0 +1,82 @@
+/**
+ * ipfs-node.ts — Bolloon 的 OrbitDB 底层 IPFS 节点工厂 (2026-08-06)
+ *
+ * 基于 helia 7:
+ *   - createHelia() 内部已 withLibp2p 但**不传 opts** → 无法自定义 services
+ *     (HeliaInit 没有 libp2p 字段, 传了也被丢弃, 实测服务列表仍是默认 13 个)
+ *   - 正确姿势: createHeliaLight() (无 libp2p) + 手动 withLibp2p(helia, { services })
+ *   - OrbitDB 的 P2P 同步依赖 ipfs.libp2p.services.pubsub (sync.js:113) → 必须加 gossipsub
+ *   - libp2p 的 createLibp2p 是 { ...defaults, ...options } 浅合并: services 整个覆盖,
+ *     必须显式列出要保留的默认服务 (dht/identify/keychain/...)
+ *   - withLibp2p().start() 之后 libp2p getter 才可用 (之前抛 NotStartedError)
+ *
+ * 跑法: npx tsx scripts/smoke-orbitdb.ts
+ */
+import { createHeliaLight } from 'helia';
+import { withLibp2p } from '@helia/libp2p';
+import * as dagCbor from '@ipld/dag-cbor';
+import * as dagJson from '@ipld/dag-json';
+import * as json from 'multiformats/codecs/json';
+import { sha512 } from 'multiformats/hashes/sha2';
+import { gossipsub } from '@libp2p/gossipsub';
+import { identify, identifyPush } from '@libp2p/identify';
+import { kadDHT } from '@libp2p/kad-dht';
+import { keychain } from '@libp2p/keychain';
+import { autoNAT } from '@libp2p/autonat';
+import { uPnPNAT } from '@libp2p/upnp-nat';
+import { ping } from '@libp2p/ping';
+import { mdns } from '@libp2p/mdns';
+import { circuitRelayServer } from '@libp2p/circuit-relay-v2';
+import { dcutr } from '@libp2p/dcutr';
+import { http } from '@libp2p/http';
+import { delegatedRoutingV1HttpApiClientContentRouting, delegatedRoutingV1HttpApiClientPeerRouting } from '@helia/delegated-routing-v1-http-api-client';
+import { delegatedHTTPRoutingDefaults } from '@helia/delegated-routing-client';
+import { autoTLS } from '@ipshipyard/libp2p-auto-tls';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * 创建 Bolloon 用的 helia 节点 (libp2p 完整默认服务 + gossipsub pubsub)。
+ * dataDir 持久化节点身份/数据 (默认 ~/.bolloon/orbitdb-ipfs)。
+ */
+export async function createBolloonIpfs(dataDir) {
+    const dir = dataDir ?? path.join(process.env.HOME || os.homedir() || '/tmp', '.bolloon', 'orbitdb-ipfs');
+    // createHeliaLight 无 libp2p → withLibp2p 手动装配 (可传 services)
+    // codecs/hashers 照抄 createHelia 默认: OrbitDB 的 log entry 用 dag-cbor (codec 113),
+    // 不注册会报 "Could not load codec for 113"
+    const helia = withLibp2p(createHeliaLight({
+        codecs: [dagCbor, dagJson, json],
+        hashers: [sha512],
+    }), {
+        // 显式列出服务: createLibp2p 浅合并会覆盖默认 services
+        services: {
+            pubsub: gossipsub({ emitSelf: true }), // OrbitDB 同步必需; emitSelf 让单机也能 publish (否则 NoPeersSubscribedToTopic)
+            autoNAT: autoNAT(),
+            autoTLS: autoTLS(),
+            dcutr: dcutr(),
+            delegatedPeerRouting: delegatedRoutingV1HttpApiClientPeerRouting(delegatedHTTPRoutingDefaults()),
+            delegatedContentRouting: delegatedRoutingV1HttpApiClientContentRouting(delegatedHTTPRoutingDefaults()),
+            dht: kadDHT(),
+            identify: identify(),
+            identifyPush: identifyPush(),
+            keychain: keychain({ pass: 'bolloon-orbitdb-keychain-pass-2026' }),
+            ping: ping(),
+            relay: circuitRelayServer(),
+            upnp: uPnPNAT(),
+            mdns: mdns(),
+            http: http(),
+        },
+    });
+    await helia.start();
+    const peerId = helia.libp2p.peerId.toString();
+    return {
+        helia,
+        peerId,
+        start: async () => { await helia.start(); },
+        stop: async () => { await helia.stop(); },
+    };
+}
+/** 从地址字符串解析 OrbitDB 数据库地址的 database name */
+export function dbNameFromAddress(address) {
+    const parts = address.split('/');
+    return parts[parts.length - 1] || address;
+}

package/dist/orbitdb/ui-cid.js

@@ -0,0 +1,68 @@
+/**
+ * ui-cid.ts — UI 组件 CID 化层 (2026-08-06)
+ *
+ * 让 UI 组件也可以内容寻址:
+ *   - saveComponent: 组件定义 (代码 + props schema + theme) → CIDDatabase (type: 'ui')
+ *   - loadComponent: 按 CID 加载组件定义
+ *   - versionComponent: 组件版本管理 (复用 CIDDatabase.update 版本链)
+ *   - loadReactComponent: 从 CID 拉组件代码 → React 组件 (动态渲染)
+ *
+ * 架构: UI 组件 → UICidStore → CIDDatabase → OrbitDB/CID → IPFS
+ * 注: npm 无标准 "UI CID" 库, 按用户减法哲学自研轻量层 (数据层 node 通用,
+ *     浏览器渲染集成点留给 Web client)。
+ */
+import React from 'react';
+import { getCIDDatabase, } from './cid-database.js';
+export class UICidStoreImpl {
+    db;
+    constructor(db = getCIDDatabase()) {
+        this.db = db;
+    }
+    async saveComponent(agentId, def) {
+        return this.db.save({
+            agentId,
+            type: 'ui',
+            content: def,
+            metadata: { kind: 'ui-component', framework: def.framework },
+        });
+    }
+    async loadComponent(cid) {
+        const rec = await this.db.load(cid);
+        if (!rec)
+            return null;
+        return rec.content;
+    }
+    async listComponents(agentId) {
+        return this.db.list(agentId ? { agentId, type: 'ui' } : { type: 'ui' });
+    }
+    async versionComponent(cid, code, extra) {
+        const old = await this.loadComponent(cid);
+        if (!old)
+            return null;
+        return this.db.update(cid, {
+            ...old,
+            ...extra,
+            code,
+        });
+    }
+    async loadReactComponent(cid) {
+        const def = await this.loadComponent(cid);
+        if (!def)
+            throw new Error(`组件不存在: ${cid}`);
+        if (def.framework !== 'react')
+            throw new Error(`不是 React 组件: ${def.framework}`);
+        // 动态构造: code 是函数组件源码 → new Function 编译 (受限环境: 无 module 作用域)
+        const factory = new Function('React', `return (${def.code})`);
+        const component = factory(React);
+        if (typeof component !== 'function')
+            throw new Error('组件代码必须返回 React 组件函数');
+        return { component, def };
+    }
+}
+/** 单例 */
+let _uiStore = null;
+export function getUICidStore() {
+    if (!_uiStore)
+        _uiStore = new UICidStoreImpl();
+    return _uiStore;
+}

package/dist/security/tool-gate.js

@@ -60,6 +60,10 @@ const TOOL_WHITELIST = new Set([
     'fetch_url', 'web_search',
     // 2026-08-02: 远端 channel 工具 (本地智能体 @ 远程交流)
     'list_remote_channels', 'send_to_remote_channel',
+    // 2026-08-06: OrbitDB/CID 数据层工具 (src/orbitdb/agent-tools.ts)
+    'cid_save', 'cid_load', 'cid_update', 'cid_version', 'cid_list', 'cid_share',
+    'context_save_snapshot', 'context_restore',
+    'ui_save_component', 'ui_load_component',
 ]);
 export const gateWhitelist = { gate: 'whitelist', allowed: true };
 /**

package/dist/web/client.js

@@ -1546,6 +1546,7 @@
   var channelNameEl = document.getElementById("channel-name");
   var eventSources = /* @__PURE__ */ new Map();
   var currentChannelId = null;
+  var activeChannelId = null;
   var currentAgentId = "";
   var channels = [];
   var remoteChannels = [];
@@ -1676,6 +1677,18 @@
       channels.forEach((ch, i) => {
         console.log(`  [${i}] ${ch.name} - did: "${ch.did}"`);
       });
+      try {
+        const ar = await fetch("/active-channel");
+        const a = await ar.json();
+        if (a && a.channelId) {
+          activeChannelId = a.channelId;
+          if (!currentChannelId) currentChannelId = a.channelId;
+          document.title = `Bolloon \xB7 ${a.identity?.name || a.channelId}`;
+          console.log("[\u52A0\u8F7D\u9891\u9053] active channel:", a.channelId, "\u2192", a.identity?.name);
+        }
+      } catch (e) {
+        console.warn("[\u52A0\u8F7D\u9891\u9053] \u8BFB active channel \u5931\u8D25 (\u975E\u81F4\u547D):", e);
+      }
       renderChannels();
     } catch (err) {
       console.error("[\u52A0\u8F7D\u9891\u9053] \u5931\u8D25:", err);
@@ -2182,18 +2195,18 @@ ${msg.text || ""}`, "ai", false, log);
     }
     renderChannels();
   }
-  function renderChannelsLite(activeChannelId, activeSessionId) {
+  function renderChannelsLite(activeChannelId2, activeSessionId) {
     if (!channelList) return;
     channelList.querySelectorAll(".agent-row").forEach((row) => {
       const li = row.closest(".agent-group");
       const chId = li?.dataset.channelId;
-      row.classList.toggle("active", chId === activeChannelId);
+      row.classList.toggle("active", chId === activeChannelId2);
     });
-    if (activeChannelId) expandedAgents.add(activeChannelId);
-    const activeLi = channelList.querySelector(`.agent-group[data-channel-id="${activeChannelId}"]`);
+    if (activeChannelId2) expandedAgents.add(activeChannelId2);
+    const activeLi = channelList.querySelector(`.agent-group[data-channel-id="${activeChannelId2}"]`);
     if (activeLi) {
       activeLi.classList.add("expanded");
-      const ch = channels.find((c) => c.id === activeChannelId);
+      const ch = channels.find((c) => c.id === activeChannelId2);
       activeLi.querySelectorAll(".session-item").forEach((sessLi) => {
         const sessId = sessLi.dataset.sessionId;
         const shouldBeActive = sessId === activeSessionId;

package/dist/web/server.js

@@ -4031,6 +4031,52 @@ ${goalDesc}
             res.status(500).json({ error: err.message });
         }
     });
+    // 2026-08-06: active channel (统一 Agent Identity) — CLI /channel 与 Web UI 共用
+    //   active-channel.json 是唯一持久化点: CLI 切换写, Web 读同一文件 → 两边一致
+    const ACTIVE_CHANNEL_FILE = `${process.env.HOME || '/tmp'}/.bolloon/active-channel.json`;
+    const CHANNELS_JSON = `${process.env.HOME || '/tmp'}/.bolloon/sessions/channels.json`;
+    async function readActiveChannel() {
+        try {
+            const a = JSON.parse(await fs.readFile(ACTIVE_CHANNEL_FILE, 'utf-8'));
+            if (!a || typeof a.channelId !== 'string')
+                return { channelId: null };
+            // 解析 identity name (persona.name 优先)
+            let channels = [];
+            try {
+                channels = JSON.parse(await fs.readFile(CHANNELS_JSON, 'utf-8'));
+            }
+            catch { /* */ }
+            const ch = channels.find((c) => c?.id === a.channelId);
+            const name = ch?.persona?.name?.trim() || ch?.name || ch?.agentId || 'agent';
+            return { channelId: a.channelId, identity: { id: a.channelId, name, channelId: a.channelId } };
+        }
+        catch {
+            return { channelId: null };
+        }
+    }
+    app.get('/active-channel', async (_req, res) => {
+        try {
+            const a = await readActiveChannel();
+            res.json(a);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/active-channel', async (req, res) => {
+        try {
+            const channelId = String(req.body?.channelId || '').trim();
+            if (!channelId)
+                return res.status(400).json({ error: 'channelId 必填' });
+            await fs.mkdir(path.dirname(ACTIVE_CHANNEL_FILE), { recursive: true });
+            await fs.writeFile(ACTIVE_CHANNEL_FILE, JSON.stringify({ channelId, updatedAt: Date.now() }, null, 2), 'utf-8');
+            const a = await readActiveChannel();
+            res.json(a);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // v3: 列出本节点缓存的远端 channel (按 peerId 分组)
     app.get('/api/remote-channels', async (_req, res) => {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.3.32",
+  "version": "0.3.34",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",
@@ -62,12 +62,14 @@
     "@libp2p/autonat": "^3.0.25",
     "@libp2p/circuit-relay-v2": "^4.2.9",
     "@libp2p/dcutr": "^3.0.20",
+    "@libp2p/gossipsub": "^16.1.1",
     "@libp2p/identify": "^4.1.6",
     "@libp2p/kad-dht": "^16.2.6",
     "@libp2p/tcp": "^11.0.20",
     "@libp2p/upnp-nat": "^4.0.20",
     "@multiformats/multiaddr": "^13.0.3",
     "@noble/hashes": "^1.3.0",
+    "@orbitdb/core": "^4.0.0",
     "@polymarket/client": "^0.2.0",
     "@rayhanadev/iroh": "^0.1.1",
     "@x402/aptos": "^2.20.0",
@@ -92,6 +94,7 @@
     "dotenv": "^17.4.2",
     "esbuild": "^0.24.0",
     "express": "^5.2.1",
+    "helia": "^7.1.3",
     "ink": "^4.4.1",
     "ink-text-input": "^5.0.0",
     "libp2p": "^3.3.0",