@bolloon/bolloon-agent 0.3.26 → 0.3.28

package/dist/bootstrap/lifecycle-hooks.js

@@ -9,7 +9,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { getCachedBolloonContext, clearBolloonContextCache } from './context-collector.js';
 import { formatContextForSystemPrompt } from './project-context.js';
-import { loadPersonaDocs, formatPersonaForSystemPrompt } from './persona-loader.js';
+import { loadPersonaDocs, formatPersonaForSystemPrompt, loadPersonaJudgmentDeclaration, formatJudgmentDeclaration } from './persona-loader.js';
 let lastSessionStartAt = 0;
 const MIN_INTERVAL_MS = 5000; // 同一进程 5s 内最多触发一次, 防止循环
 export async function onSessionStart(opts = {}) {
@@ -30,7 +30,13 @@ export async function onSessionStart(opts = {}) {
         if (opts.agentId) {
             try {
                 const docs = await loadPersonaDocs(opts.agentId);
-                const personaText = formatPersonaForSystemPrompt(docs);
+                let personaText = formatPersonaForSystemPrompt(docs);
+                // 2026-08-03 (Context OS P1): 追加 persona frontmatter 里的判断力声明
+                //   (judgment_style / stakes_default / revisable) — 与 judgeness 5 维对应
+                const decl = await loadPersonaJudgmentDeclaration(opts.agentId);
+                const declText = formatJudgmentDeclaration(decl);
+                if (declText)
+                    personaText = personaText ? `${personaText}\n\n${declText}` : declText;
                 if (personaText) {
                     systemAddition = personaText + '\n\n' + systemAddition;
                 }

package/dist/bootstrap/memory-compressor.js

@@ -144,7 +144,8 @@ export async function compressSessionToMemory(opts) {
     const timestamp = new Date().toISOString();
     let summaryBody;
     try {
-        const sysPrompt = '你是 bolloon 记忆压缩助手. 输入是一段 session 消息历史 (用户问题 + AI 回答), 输出 200-400 字中文摘要, 包含 3-5 条关键发现和未完成事项. 不要寒暄, 不要复述已知. 格式: ## 关键发现 / ## 待办.';
+        // 2026-08-03 (Context OS P4): 摘要 prompt 要求输出"价值点"段 — 供收尾路由入库 judgeness
+        const sysPrompt = '你是 bolloon 记忆压缩助手. 输入是一段 session 消息历史 (用户问题 + AI 回答), 输出 200-400 字中文摘要, 包含 3-5 条关键发现和未完成事项. 不要寒暄, 不要复述已知. 格式: ## 关键发现 / ## 待办. 最后单独输出 ## 价值点 段: 0-3 行, 每行 `- (类型) 一句话内容`, 类型 ∈ decision|lesson|knowledge|insight (decision=做出了什么决定; lesson=哪里出错下次怎么避免; knowledge=修正了什么认知; insight=改变了判断的洞察). 没有就写 `- (无)`';
         const recentSnippet = newMessages.slice(-10).map(m => `[${m.type}] ${m.content}`).join('\n---\n').slice(0, 6000);
         const userPrompt = `Channel: ${opts.channelId}\nSession: ${opts.sessionId}\n时间: ${timestamp}\n新增消息数: ${newMessages.length}\n\n最近消息:\n${recentSnippet}`;
         summaryBody = await tryLlmSummary(sysPrompt, userPrompt);
@@ -161,6 +162,18 @@ export async function compressSessionToMemory(opts) {
     await fs.mkdir(path.dirname(summaryPath), { recursive: true });
     await fs.appendFile(summaryPath, block, 'utf-8');
     await writeCursor(cursorPath, allMessages.length);
+    // 2026-08-03 (Context OS P4): 价值点分类路由 — 把摘要里的 decision/lesson/knowledge/insight
+    //   自动写入 human-values + judgeness (Context OS §6 对话收尾: 价值不流失).
+    //   失败静默, 不阻塞主对话. 幂等: 相同 decision 文本跳过.
+    try {
+        await routeValuePointsToJudgeness({
+            agentId,
+            channelId: opts.channelId,
+            summaryBody,
+            home,
+        });
+    }
+    catch { /* 静默 */ }
     // 2026-07-22 设计 C: 废气采样 — 压缩成功 = 上下文需要压缩的信号, 记入涡轮 (隐式)
     //   废气不进 prompt, 只调参 (背压高 → judgment 注入收紧). 落 log/memory.
     try {
@@ -179,3 +192,115 @@ export async function compressSessionToMemory(opts) {
         bytesWritten: Buffer.byteLength(block, 'utf-8'),
     };
 }
+/**
+ * 解析摘要里的 `## 价值点` 段.
+ * 容错 3 种行格式: `- (decision) 内容` / `- decision: 内容` / `- decision 内容`
+ * 无该段 / `- (无)` → 返回 [].
+ */
+export function extractValuePoints(summaryBody) {
+    if (!summaryBody)
+        return [];
+    const m = summaryBody.match(/##\s*价值点\s*\n([\s\S]*?)(?=\n##\s|\n---\s*$|$)/);
+    if (!m)
+        return [];
+    const lines = m[1].split('\n').map((l) => l.trim()).filter(Boolean);
+    const out = [];
+    const typeSet = ['decision', 'lesson', 'knowledge', 'insight'];
+    for (const line of lines) {
+        const stripped = line.replace(/^[-*•]\s*/, '');
+        if (stripped === '(无)' || stripped === '无' || stripped === '')
+            continue;
+        // - (type) content | - type: content | - type content
+        const m2 = stripped.match(/^\(?(\w+)\)?\s*[:：]?\s+(.+)$/);
+        if (!m2)
+            continue;
+        const t = m2[1].toLowerCase();
+        if (!typeSet.includes(t))
+            continue;
+        const content = m2[2].trim();
+        if (content.length < 4)
+            continue;
+        out.push({ type: t, content });
+    }
+    return out.slice(0, 3);
+}
+/** 幂等检查: human-values 里已有相同 decision 文本 → 跳过 (防重复入库) */
+async function alreadyRouted(decisionText, home) {
+    try {
+        const { loadAllJudgments } = await import('../pi-ecosystem-judgment/human-value-store.js');
+        const all = await loadAllJudgments();
+        return all.some((j) => String(j.decision).trim() === decisionText.trim());
+    }
+    catch {
+        return false; // 读失败 → 不跳过 (重试语义)
+    }
+}
+/**
+ * 把摘要里的价值点路由到 human-values + judgeness + Context OS 资产层.
+ * 失败静默 (由调用方 try/catch), 单条失败不影响其余.
+ * 落点 (Context OS §6 Step2 唯一落点):
+ *   decision → decisions/ (decision-store, 不重复写资产层)
+ *   lesson   → human-values + judgeness + 12-Analysis/ (复盘)
+ *   knowledge→ human-values + judgeness + 07-Knowledge/
+ *   insight  → human-values + judgeness + 08-Insights/
+ * 返回写入条数 (测试/日志用).
+ */
+export async function routeValuePointsToJudgeness(opts) {
+    const points = extractValuePoints(opts.summaryBody);
+    if (points.length === 0)
+        return 0;
+    let written = 0;
+    for (const p of points) {
+        try {
+            const decisionText = p.content.slice(0, 300);
+            if (await alreadyRouted(decisionText, opts.home))
+                continue;
+            const { storeHumanJudgment } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            const { reflectAfterJudgment } = await import('../judgeness/reflect.js');
+            const isLesson = p.type === 'lesson';
+            const judgment = await storeHumanJudgment({
+                decision: decisionText,
+                decision_type: isLesson ? 'reject' : 'approve',
+                reasons: [`来源: session 摘要价值点 (${p.type})`],
+                values_derived: [],
+                context: {
+                    domain: opts.channelId?.startsWith('ch_') ? '通用' : (opts.channelId || '通用'),
+                    complexity: 'simple',
+                    stakes: 'low',
+                    time_pressure: 'low',
+                },
+                metadata: {
+                    source: isLesson ? 'trajectory' : 'implicit',
+                    confidence: 0.6,
+                    revisable: true,
+                },
+                status: 'active',
+                appliesTo: [],
+            });
+            await reflectAfterJudgment(judgment, 'agent', sanitizeAgentId(opts.agentId)).catch(() => null);
+            written += 1;
+            // 2026-08-03 (Context OS P5): 唯一落点 — knowledge/insight/lesson 写入资产层
+            //   (幂等: 同标题已存在则跳过; 失败静默不影响主流程)
+            const assetLayer = p.type === 'knowledge' ? '07-Knowledge' :
+                p.type === 'insight' ? '08-Insights' :
+                    p.type === 'lesson' ? '12-Analysis' : null;
+            if (assetLayer) {
+                try {
+                    const { writeContextAsset } = await import('./context-os.js');
+                    await writeContextAsset({
+                        layer: assetLayer,
+                        title: p.content.slice(0, 40),
+                        content: `> 来源: session 价值点自动路由 (${p.type})\n\n${p.content}\n\n## 价值判断自检\n未来哪个具体场景会用到它? (待确认后固化, 当前 stage0)`,
+                        tags: [p.type, 'auto-routed'],
+                        domain: opts.channelId,
+                    }, opts.home);
+                }
+                catch { /* 资产层写入失败不影响 */ }
+            }
+        }
+        catch {
+            /* 单条失败跳过 */
+        }
+    }
+    return written;
+}

package/dist/bootstrap/persona-loader.js

@@ -4,6 +4,12 @@
  * 失败静默: 文件不存在 → 字段 = '', 不抛错
  * 安全: agentId sanitize (防路径穿越)
  * 6 段输出顺序: identity → soul → project → user → agent → wiki
+ *
+ * 2026-08-03 (Context OS 融合 P1):
+ *   - 支持 persona 文件 frontmatter 里的判断力声明 (judgment_style / stakes_default / revisable),
+ *     与 judgeness 5 维 facets 对应 — persona 提供"这个人怎么判断"的入口.
+ *   - formatPersonaForSystemPrompt 固定追加 INJECT 工作纪律段 (Context OS 读取协议),
+ *     任何 channel 即使无 persona 文件也有纪律约束.
  */
 import * as fs from 'fs/promises';
 import * as os from 'os';
@@ -45,6 +51,71 @@ export async function loadPersonaDocs(agentId, home) {
     }));
     return docs;
 }
+/**
+ * 轻量 frontmatter 解析 (不依赖 js-yaml).
+ * 只认 `key: value` 单行字段; 无 frontmatter (不以 --- 开头) → 返回 {}.
+ */
+export function parseSimpleFrontmatter(content) {
+    const out = {};
+    const m = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return out;
+    for (const line of m[1].split('\n')) {
+        const kv = line.match(/^\s*([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/);
+        if (kv)
+            out[kv[1]] = kv[2].replace(/^['"]|['"]$/g, '').trim();
+    }
+    return out;
+}
+/**
+ * 读 persona 6 文件 frontmatter 里的判断力声明 (Context OS 入口层 ↔ judgeness 5 维).
+ * 聚合所有文件中的 judgment_style / stakes_default / revisable 字段 (后者优先).
+ * 失败静默: 无 persona 文件 → 全部空值, 不抛错.
+ */
+export async function loadPersonaJudgmentDeclaration(agentId, home) {
+    const safeId = sanitizeAgentId(agentId);
+    const root = home || os.homedir();
+    const baseDir = path.join(root, '.bolloon', 'persona', safeId);
+    const decl = {
+        judgmentStyle: '',
+        stakesDefault: '',
+        revisable: true,
+        raw: {},
+    };
+    await Promise.all(FILE_KEYS.map(async (key) => {
+        try {
+            const content = await fs.readFile(path.join(baseDir, `${key}.md`), 'utf-8');
+            const fm = parseSimpleFrontmatter(content);
+            for (const [k, v] of Object.entries(fm)) {
+                if (k.startsWith('judgment_') || k === 'stakes_default' || k === 'revisable') {
+                    decl.raw[k] = v;
+                }
+            }
+        }
+        catch {
+            /* 单文件缺失/损坏跳过 */
+        }
+    }));
+    decl.judgmentStyle = decl.raw['judgment_style'] || decl.raw['judgmentStyle'] || '';
+    decl.stakesDefault = decl.raw['stakes_default'] || decl.raw['stakesDefault'] || '';
+    decl.revisable = decl.raw['revisable'] !== 'false';
+    return decl;
+}
+/** 把判断力声明格式化成一行段 (server contextHint 注入用) */
+export function formatJudgmentDeclaration(decl) {
+    if (!decl.judgmentStyle && !decl.stakesDefault && !decl.raw['revisable'])
+        return '';
+    const parts = [];
+    if (decl.judgmentStyle)
+        parts.push(`风格: ${decl.judgmentStyle}`);
+    if (decl.stakesDefault)
+        parts.push(`默认风险等级: ${decl.stakesDefault}`);
+    if (decl.raw['revisable'] === 'false')
+        parts.push('偏好不可回滚的决策 (谨慎)');
+    else if (decl.raw['revisable'] === 'true')
+        parts.push('偏好可回滚的决策');
+    return `[系统上下文] 判断风格声明 (来自 persona frontmatter, 与 judgeness 判断资产对应):\n  ${parts.join(' / ')}\n\n`;
+}
 const DEFAULT_MAX_CHARS = 4000;
 const SECTION_LABELS = {
     identity: 'Identity',
@@ -60,6 +131,9 @@ const OUTPUT_ORDER = ['identity', 'soul', 'project', 'user', 'agent', 'wiki'];
  *
  * 超 maxChars 时按比例截断: 每个字段都保留头部,
  * 保证 6 段标识都出现, 不砍段.
+ *
+ * 2026-08-03: 固定追加 INJECT 工作纪律段 (Context OS 读取协议 §4/§10).
+ *   纪律段不参与动态预算 — 即使没有 persona 文件也有纪律约束.
  */
 export function formatPersonaForSystemPrompt(docs, maxChars) {
     const cap = maxChars ?? DEFAULT_MAX_CHARS;
@@ -71,11 +145,20 @@ export function formatPersonaForSystemPrompt(docs, maxChars) {
             sections.push({ key, text: `## ${SECTION_LABELS[key]}\n${v}` });
         }
     }
-    if (sections.length === 0)
-        return '';
-    // 预算每段 (去掉 ## 标识和换行的固定开销)
+    // INJECT 工作纪律 (Context OS §4 最小读取集 + §10 工作规则, 精简 4 条)
+    const discipline = '## 工作纪律 (INJECT)\n' +
+        '1. 先看动态状态 (历史记忆 / 进行中的计划), 再按任务路由读取对应文档; 不读到的内容不假装知道.\n' +
+        '2. 区分: 已知事实 / 你的判断 / 需要用户确认的内容.\n' +
+        '3. 重要决策前列出: 选项 (含不做)、成本、收益、风险、信息缺口、回滚条件 — 决策可追溯.\n' +
+        '4. 对话收尾提取可复用的决策/知识/教训, 归档到唯一位置, 不制造重复文件.';
     const header = `# Persona (agentId=${docs.agentId})\n\n`;
-    const fixedOverhead = header.length + (sections.length - 1) * 2;
+    // 无 persona 文件 → 只输出纪律段
+    if (sections.length === 0) {
+        const solo = `${header}${discipline}`;
+        return solo.length > cap ? solo.slice(0, cap) : solo;
+    }
+    // 预算每段 (去掉 ## 标识和换行的固定开销; 纪律段固定, 动态段让出预算)
+    const fixedOverhead = header.length + discipline.length + (sections.length - 1) * 2;
     const perSectionBudget = Math.max(50, Math.floor((cap - fixedOverhead) / sections.length));
     const parts = [header.trim()];
     for (const sec of sections) {
@@ -85,7 +168,7 @@ export function formatPersonaForSystemPrompt(docs, maxChars) {
         }
         parts.push(body);
     }
-    let result = parts.join('\n\n');
+    let result = parts.join('\n\n') + '\n\n' + discipline;
     if (result.length > cap) {
         const truncateMarker = '\n... (截断)';
         result = result.substring(0, Math.max(0, cap - truncateMarker.length)) + truncateMarker;

package/dist/pi-ecosystem-mcp/index.js

@@ -4,15 +4,16 @@
  * Bridges MCP (Model Context Protocol) servers with Bolloon's tool system.
  * Based on the pi-mcp-adapter philosophy: on-demand tool loading with minimal token overhead.
  *
- * Key differences from Claude Code MCP:
- * - White-box design: every schema, parameter, and return value is visible
- * - Minimal primitives: only read, write, edit, bash under the hood
- * - No schema validation black boxes - interfaces are simple by design
+ * 2026-08-03 (验证修复): sendMcpRequest 从 simulated 占位 → 真实 stdio JSON-RPC 通信.
+ *   - 协议: initialize → notifications/initialized → tools/list → tools/call
+ *   - 请求/响应按 id 配对, 30s 超时, server 崩溃时 pending 全部 reject
+ *   - discoverMcpServers 修复重复读 mcpServers 键 (同一个键被读两遍)
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { spawn } from 'child_process';
 import { EventEmitter } from 'events';
+import * as readline from 'readline';
 // MCP adapter state
 let tools = new Map();
 let servers = new Map();
@@ -22,6 +23,8 @@ let toolCallLog = [];
 class McpEventEmitter extends EventEmitter {
 }
 const mcpEvents = new McpEventEmitter();
+const MCP_REQUEST_TIMEOUT_MS = 30_000;
+let mcpRequestSeq = 1;
 /**
  * Discover MCP servers from standard config locations
  */
@@ -37,24 +40,17 @@ export async function discoverMcpServers() {
         try {
             const content = await fs.readFile(loc, 'utf-8');
             const mcpJson = JSON.parse(content);
-            if (mcpJson.mcpServers) {
-                for (const [name, config] of Object.entries(mcpJson.mcpServers)) {
+            // 2026-08-03 fix: mcpServers 只读一次 (之前 if + if['mcpServers'] 重复读同一键)
+            const serversConfig = (mcpJson.mcpServers ?? mcpJson['mcpServers']);
+            if (serversConfig && typeof serversConfig === 'object') {
+                for (const [name, config] of Object.entries(serversConfig)) {
                     const serverConfig = config;
+                    if (!serverConfig || typeof serverConfig.command !== 'string')
+                        continue;
                     configs.push({
                         name,
                         command: serverConfig.command,
-                        args: serverConfig.args,
-                        env: serverConfig.env,
-                    });
-                }
-            }
-            if (mcpJson['mcpServers']) {
-                for (const [name, config] of Object.entries(mcpJson['mcpServers'])) {
-                    const serverConfig = config;
-                    configs.push({
-                        name,
-                        command: serverConfig.command,
-                        args: serverConfig.args,
+                        args: Array.isArray(serverConfig.args) ? serverConfig.args : undefined,
                         env: serverConfig.env,
                     });
                 }
@@ -64,7 +60,15 @@ export async function discoverMcpServers() {
             // File doesn't exist, skip
         }
     }
-    return configs;
+    // 去重 (同 name 同 command)
+    const seen = new Set();
+    return configs.filter((c) => {
+        const key = `${c.name}::${c.command}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
 }
 /**
  * Initialize the MCP adapter
@@ -76,15 +80,60 @@ export async function initializeMcpAdapter() {
     console.log(`[McpAdapter] Discovered ${discoveredServers.length} MCP servers`);
     for (const server of discoveredServers) {
         registerServer(server);
+        // 2026-08-03: 启动后立即握手 + 发现工具 (真实 stdio 协议)
+        await connectAndDiscover(server.name).catch((e) => {
+            console.warn(`[McpAdapter] connect ${server.name} 失败:`, e?.message?.slice(0, 120));
+        });
     }
     initialized = true;
     mcpEvents.emit('initialized');
 }
+/**
+ * 连接 MCP server + 握手 + 发现并注册工具 (2026-08-03)
+ * 协议序: startServer → initialize → notifications/initialized → tools/list
+ */
+export async function connectAndDiscover(serverName) {
+    const server = servers.get(serverName);
+    if (!server)
+        return [];
+    if (!server.running || !server.process) {
+        const started = await startServer(serverName);
+        if (!started)
+            return [];
+        // 等 server 就绪
+        await new Promise((r) => setTimeout(r, 400));
+    }
+    await sendMcpRequest(serverName, 'initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'bolloon', version: '0.3.27' },
+    });
+    await sendMcpRequest(serverName, 'notifications/initialized');
+    const result = await sendMcpRequest(serverName, 'tools/list');
+    const toolsList = Array.isArray(result?.tools) ? result.tools : [];
+    const discovered = [];
+    for (const t of toolsList) {
+        const tool = {
+            name: String(t.name || ''),
+            description: String(t.description || ''),
+            inputSchema: t.inputSchema || {},
+            serverName,
+        };
+        if (!tool.name)
+            continue;
+        discovered.push(tool);
+        registerTool(tool);
+    }
+    console.log(`[McpAdapter] ${serverName}: 发现 ${discovered.length} 个工具 (${discovered.map((t) => t.name).join(', ')})`);
+    return discovered;
+}
 /**
  * Register an MCP server configuration
  */
 export function registerServer(config) {
-    servers.set(config.name, { config, process: null, running: false });
+    if (servers.has(config.name))
+        return;
+    servers.set(config.name, { config, process: null, running: false, pending: new Map() });
     console.log(`[McpAdapter] Registered server: ${config.name}`);
 }
 /**
@@ -156,10 +205,12 @@ export async function executeTool(name, args) {
             toolCallLog = toolCallLog.slice(-50);
         }
         if (result && typeof result === 'object' && 'content' in result) {
-            return {
-                success: true,
-                content: result.content,
-            };
+            // 2026-08-03: 提取 content 数组里的文本 (agent 直接可用)
+            const content = result.content;
+            const text = Array.isArray(content)
+                ? content.map((c) => c?.text ?? '').filter(Boolean).join('\n')
+                : JSON.stringify(result);
+            return { success: true, content: [{ type: 'text', text }] };
         }
         return { success: true, content: [{ type: 'text', text: JSON.stringify(result) }] };
     }
@@ -170,25 +221,78 @@ export async function executeTool(name, args) {
     }
 }
 /**
- * Send MCP request to a server (simplified - uses stdin/stdout JSON-RPC)
+ * Send MCP request to a server via real stdio JSON-RPC (2026-08-03).
+ * - 写 JSON-RPC 行到 server stdin, 从 stdout 按 id 配对响应
+ * - 30s 超时; server 进程退出时挂起请求全部 reject
  */
 async function sendMcpRequest(serverName, method, params) {
     const server = servers.get(serverName);
     if (!server) {
         throw new Error(`Server not registered: ${serverName}`);
     }
-    // For now, return a placeholder - real implementation would use MCP protocol
-    // The actual protocol typically uses stdio or HTTP+streamableHTTP
-    console.log(`[McpAdapter] Would send ${method} to ${serverName}:`, params);
-    // Simulate successful response for development
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `[Simulated] Tool ${method} executed with params: ${JSON.stringify(params)}`,
-            },
-        ],
-    };
+    // 确保 server 进程在跑
+    if (!server.running || !server.process || !server.process.stdin?.writable) {
+        const started = await startServer(serverName);
+        if (!started)
+            throw new Error(`无法启动 MCP server: ${serverName}`);
+        // 等 500ms 让 server 就绪
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    const child = server.process;
+    if (!child.stdin?.writable)
+        throw new Error(`MCP server stdin 不可写: ${serverName}`);
+    const id = mcpRequestSeq++;
+    const isNotification = method.startsWith('notifications/');
+    // 通知 (notifications/*) 是 fire-and-forget: 无 id, server 不响应
+    const line = JSON.stringify(isNotification
+        ? { jsonrpc: '2.0', method, params: params ?? {} }
+        : { jsonrpc: '2.0', id, method, params: params ?? {} });
+    if (isNotification) {
+        child.stdin.write(line + '\n');
+        return undefined;
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            server.pending.delete(id);
+            reject(new Error(`MCP request timeout (${MCP_REQUEST_TIMEOUT_MS}ms): ${method}`));
+        }, MCP_REQUEST_TIMEOUT_MS);
+        server.pending.set(id, { resolve, reject, timer });
+        child.stdin.write(line + '\n');
+    });
+}
+/** 挂上 stdout 行读取器 (按 id 分发响应) */
+function attachStdoutReader(serverName, child) {
+    const server = servers.get(serverName);
+    if (!server)
+        return;
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            console.log(`[McpAdapter][${serverName}] non-JSON stdout:`, trimmed.slice(0, 200));
+            return;
+        }
+        // 服务端主动推送 (无 id) → 忽略
+        if (msg.id === undefined || msg.id === null)
+            return;
+        const entry = server.pending.get(msg.id);
+        if (!entry)
+            return;
+        clearTimeout(entry.timer);
+        server.pending.delete(msg.id);
+        if (msg.error) {
+            entry.reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+        }
+        else {
+            entry.resolve(msg.result);
+        }
+    });
 }
 /**
  * Start an MCP server process
@@ -215,16 +319,20 @@ export async function startServer(serverName) {
         });
         child.on('error', (err) => {
             console.error(`[McpAdapter][${serverName}] error:`, err);
+            rejectAllPending(server, `MCP server process error: ${err.message}`);
             server.running = false;
             server.process = null;
         });
         child.on('exit', (code) => {
             console.log(`[McpAdapter][${serverName}] exited with code:`, code);
+            rejectAllPending(server, `MCP server exited with code ${code}`);
             server.running = false;
             server.process = null;
         });
         server.process = child;
         server.running = true;
+        // 2026-08-03: 挂 stdout 行读取器, 按 id 分发 JSON-RPC 响应
+        attachStdoutReader(serverName, child);
         console.log(`[McpAdapter] Started server: ${serverName}`);
         return true;
     }
@@ -233,6 +341,14 @@ export async function startServer(serverName) {
         return false;
     }
 }
+/** server 退出时把挂起请求全部 reject, 避免调用方永远等待 */
+function rejectAllPending(server, reason) {
+    for (const [, entry] of server.pending) {
+        clearTimeout(entry.timer);
+        entry.reject(new Error(reason));
+    }
+    server.pending.clear();
+}
 /**
  * Stop an MCP server
  */

package/dist/security/tool-gate.js

@@ -46,6 +46,16 @@ const TOOL_WHITELIST = new Set([
     'create_skill', 'update_skill', 'list_skill_candidates', 'promote_skill',
     // 2026-08-02: plan/todo/review 工具 (plan-store.ts)
     'create_plan', 'update_plan', 'review_plan', 'list_plans',
+    // 2026-08-03: 决策协议工具 (decision-store.ts, Context OS §7 九要素)
+    'create_decision', 'decide_decision', 'rollback_decision', 'list_decisions',
+    // 2026-08-03: Context OS 资产层工具 (context-os.ts, 12+3 层文件夹体系)
+    'list_context_layers', 'write_context_asset', 'read_context_assets',
+    // 2026-08-03: MCP 工具 (pi-ecosystem-mcp, 真实 stdio JSON-RPC)
+    'mcp_list_tools', 'mcp_tool',
+    // 2026-08-03: DID 发布到 IPFS+IPNS (自动安装 Kubo)
+    'publish_did',
+    // 2026-08-02: 远端 channel 工具 (本地智能体 @ 远程交流)
+    'list_remote_channels', 'send_to_remote_channel',
 ]);
 export const gateWhitelist = { gate: 'whitelist', allowed: true };
 /**