ppxans-harness 2.6.0 → 3.2.0

package/src/mcp/http.js

@@ -7,6 +7,8 @@
 //   - 取消 = 关闭 SSE 流 (无需 notifications/cancelled)
 //   - Origin 校验防 DNS rebinding; 本地默认只绑 127.0.0.1
 import { McpServer, McpError, MCP_ERROR, MODERN_PROTOCOL_VERSION, SERVER_INFO_META_KEY } from "./server.js";
+import { readBody, sendJson, SSE_HEADERS } from "../utils/http.js";
+import { debug } from "../utils/logger.js";
 
 const MAX_BODY = 1024 * 1024; // 1MB
 
@@ -15,15 +17,7 @@ function sseMessage(obj) {
   return `event: message\ndata: ${JSON.stringify(obj)}\n\n`;
 }
 
-// 读取请求体
-async function readBody(req) {
-  let body = "";
-  for await (const chunk of req) {
-    body += chunk;
-    if (body.length > MAX_BODY) throw new McpError(MCP_ERROR.INVALID_REQUEST, "request too large");
-  }
-  return body;
-}
+// (readBody 收敛到 utils/http.js: 超限返回 null, 由下方改为抛 McpError 保持原语义)
 
 // ---- 传输错误 -> HTTP 状态码映射 (2026-07-28) ----
 function statusFor(err) {
@@ -54,8 +48,7 @@ export function createMcpHttpHandler(server, opts = {}) {
     try {
       // 1. 方法限制: 只收 POST
       if (req.method !== "POST") {
-        res.writeHead(405, { "Content-Type": "application/json", "Allow": "POST" });
-        res.end(JSON.stringify({ error: "method not allowed" }));
+        sendJson(res, 405, { error: "method not allowed" }, { headers: { "Allow": "POST" } });
         return;
       }
 
@@ -66,8 +59,7 @@ export function createMcpHttpHandler(server, opts = {}) {
           ? opts.allowedOrigins.includes(origin)
           : /^https?:\/\/(127\.0\.0\.1|localhost)(:\d+)?$/.test(origin);
         if (!allowed) {
-          res.writeHead(403, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32600, message: "origin not allowed" } }));
+          sendJson(res, 403, { jsonrpc: "2.0", error: { code: -32600, message: "origin not allowed" } });
           return;
         }
       }
@@ -79,15 +71,15 @@ export function createMcpHttpHandler(server, opts = {}) {
       // 4. 读 body + 解析
       let msg;
       try {
-        const body = await readBody(req);
+        const body = await readBody(req, { maxBytes: MAX_BODY });
+        if (body === null) throw new McpError(MCP_ERROR.INVALID_REQUEST, "request too large");
         msg = body ? JSON.parse(body) : {};
       } catch (e) {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        sendJson(res, 400, {
           jsonrpc: "2.0",
           id: null,
           error: { code: MCP_ERROR.PARSE_ERROR, message: `Parse error: ${e.message}` },
-        }));
+        });
         return;
       }
 
@@ -95,12 +87,11 @@ export function createMcpHttpHandler(server, opts = {}) {
       const headerVersion = req.headers["mcp-protocol-version"];
       const bodyVersion = msg && msg.params && msg.params._meta && msg.params._meta["io.modelcontextprotocol/protocolVersion"];
       if (bodyVersion && headerVersion && headerVersion !== bodyVersion) {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        sendJson(res, 400, {
           jsonrpc: "2.0",
           id: msg.id ?? null,
           error: { code: MCP_ERROR.HEADER_MISMATCH, message: "Header MCP-Protocol-Version does not match body _meta", data: { header: headerVersion, body: bodyVersion } },
-        }));
+        });
         return;
       }
       // 现代请求 (有 bodyVersion) 但缺 header: 允许 (兼容未带头的老客户端), 记录即可
@@ -115,8 +106,7 @@ export function createMcpHttpHandler(server, opts = {}) {
           // 通知失败仅记日志, 不影响 202 语义
           if (opts.onError) opts.onError(e);
         });
-        res.writeHead(202, { "Content-Type": "application/json" });
-        res.end();
+        sendJson(res, 202);
         return;
       }
 
@@ -127,12 +117,7 @@ export function createMcpHttpHandler(server, opts = {}) {
 
       if (wantsSSE) {
         // SSE 响应流: 进度通知 + 最终响应, 关闭流 = 取消
-        res.writeHead(200, {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          "Connection": "keep-alive",
-          "X-Accel-Buffering": "no",
-        });
+        res.writeHead(200, SSE_HEADERS);
         res.write(": keep-alive\n\n");
         const progressToken = msg.params && msg.params._meta && msg.params._meta.progressToken;
         const streamCtx = {
@@ -167,7 +152,7 @@ export function createMcpHttpHandler(server, opts = {}) {
           const err = e instanceof McpError ? e : new McpError(MCP_ERROR.INTERNAL_ERROR, e.message || "internal error");
           res.write(sseMessage({ jsonrpc: "2.0", id: msg.id, error: { code: err.code, message: err.message, ...(err.data ? { data: err.data } : {}) } }));
         } finally {
-          try { res.end(); } catch {}
+          try { res.end(); } catch (e) { debug(`[mcp/http] 已忽略异常: ${e && e.message ? e.message : e}`); }
         }
         return;
       }
@@ -175,23 +160,20 @@ export function createMcpHttpHandler(server, opts = {}) {
       // 8. 普通 JSON 响应
       try {
         const { result } = await server.handle(msg, {});
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ jsonrpc: "2.0", id: msg.id, result: result ?? {} }));
+        sendJson(res, 200, { jsonrpc: "2.0", id: msg.id, result: result ?? {} });
       } catch (e) {
         const err = e instanceof McpError ? e : new McpError(MCP_ERROR.INTERNAL_ERROR, e.message || "internal error");
-        res.writeHead(statusFor(err), { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        sendJson(res, statusFor(err), {
           jsonrpc: "2.0",
           id: msg.id ?? null,
           error: { code: err.code, message: err.message, ...(err.data ? { data: err.data } : {}) },
-        }));
+        });
       }
     } catch (e) {
       // 外层兜底 (不应发生)
       try {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32603, message: e.message || "internal error" } }));
-      } catch {}
+        sendJson(res, 500, { jsonrpc: "2.0", error: { code: -32603, message: e.message || "internal error" } });
+      } catch (e) { debug(`[mcp/http] 已忽略异常: ${e && e.message ? e.message : e}`); }
     }
   };
 }
@@ -209,6 +191,10 @@ export function createMcpEndpoint(agent, opts = {}) {
     authenticated: opts.authenticated,
     rateLimit: opts.rateLimit,
     allowedOrigins: opts.allowedOrigins,
+    // 2026-10-03 修复 (P2): 原工厂吞掉 skipOriginCheck —— channels/http.js 显式传
+    // skipOriginCheck: true (宿主 CORS 白名单已统一处理 Origin), 但工厂不转发 →
+    // handler 内部仍用默认回环正则二次校验, 契约失真 (宿主白名单形同虚设)。
+    skipOriginCheck: opts.skipOriginCheck,
     onError: opts.onError,
   });
   return { server, handler };

package/src/mcp/index.js

@@ -1,116 +1,116 @@
-// src/mcp/index.js - MCP 工具注册 (接入 MCP 工具生态)
-// 把 MCP 服务器的工具转换为皮皮虾 ToolCatalog 工具, 与内置工具同权。
-// servers: [
-//   { command, args, env, prefix }                         // stdio (本机)
-//   { url, headers, prefix, timeout }                      // HTTP Streamable (远程)
-// ]
-import { McpClient, extractToolResult, extractResourceText } from "./client.js";
-import { TOOL_ERROR_PREFIX } from "../tools/catalog.js";
-import { warn, info } from "../utils/logger.js";
-
-// v1.0.8: MCP 工具名清洗 (只留 \w.-, 截断) — 防恶意服务器注册非法工具名/注入
-export function sanitizeMcpName(name) {
-  return String(name || "").replace(/[^\w.-]/g, "_").slice(0, 64);
-}
-
-// P1⑦ (2026-09-15): MCP 命名空间隔离 —— 防工具名碰撞 (Hermes 生产数据: 51 工具服务器上
-//   幻觉工具名命中真实工具; cron job 本想调 kanban_list 结果执行了 list_goals)。
-//   强制 serverName__toolName 前缀 + 精确匹配短路。
-export function serverLabel(s) {
-  // 取服务器可读标识: 配置 name > 包名 (args 里 @scope/pkg 或 *.py) > command 首段 > url host
-  if (s && s.name) return sanitizeMcpName(s.name);
-  const fromArgs = (s && s.args || []).find((a) => /(?:^|\/)[@\w.-]+(?:@[\w.]+)?$/.test(a) && !a.startsWith("-"));
-  if (fromArgs) return sanitizeMcpName(fromArgs.split("/").pop());
-  if (s && s.command) return sanitizeMcpName(String(s.command).split(/[\\/\s]/).filter(Boolean).pop() || "mcp");
-  if (s && s.url) {
-    try {
-      const host = new URL(s.url).hostname.split(".").filter(Boolean);
-      // 取二级域: mcp.example.com → example; www.google.com → google
-      return sanitizeMcpName(host.length >= 2 ? host[host.length - 2] : host[0] || "mcp");
-    } catch {}
-  }
-  return "mcp";
-}
-
-export function namespacedMcpName(label, raw) {
-  const clean = sanitizeMcpName(raw);
-  return clean ? `${label}__${clean}` : label;
-}
-
-// v1.0.8: MCP 工具描述清洗 (单行化 + 截断) — 服务器描述直接进 LLM prompt, 防换行/长文本注入指令
-// P1⑦: 额外剔除危险 flag (--system/--dangerously 等命令行注入惯用手法)
-export function sanitizeMcpDescription(desc, name) {
-  let s = String(desc || "").replace(/\s+/g, " ").trim();
-  // 危险 flag 清洗: 描述里出现命令行注入惯用 flag 视为可疑, 剔除该片段
-  s = s.replace(/--(?:system|dangerously[-\w]*|yes|force|no[-\w]+|y)\b/g, "[flag]");
-  return s.slice(0, 200) || `MCP 工具: ${name}`;
-}
-
-// 连接所有 MCP 服务器, 列出工具并注册到 catalog。
-// 除 tools 外, 服务器声明 resources/prompts 能力时, 额外注册对应读写工具 (P2⑥)。
-// 返回 { count, clients, close } — close() 关闭全部连接 (调用方负责生命周期)
-export async function registerMcpTools(catalog, servers = []) {
-  const clients = [];
-  let count = 0;
-  for (const s of servers) {
-    if (!s) { warn("[mcp] 跳过无效服务器配置"); continue; }
-    if (!s.command && !s.url) { warn("[mcp] 跳过无效服务器配置 (缺 command/url)"); continue; }
-    const client = new McpClient(s);
-    try {
-      await client.connect();
-      const tools = await client.listTools();
-      // P1⑦: 命名空间强制前缀 (serverLabel) —— 默认开启, 可显式 prefix 覆盖/关闭
-      const label = serverLabel(s);
-      const ns = s.prefix != null ? s.prefix : `${label}__`;
-      for (const t of tools) {
-        if (!t || !t.name) continue;
-        const name = ns + sanitizeMcpName(t.name);
-        // P1⑦: 精确匹配短路 —— 注册时登记原始名 (供幻觉工具名防御: 无前缀名永不执行)
-        catalog.register({
-          name,
-          description: sanitizeMcpDescription(t.description, t.name),
-          parameters: t.inputSchema || { type: "object", properties: {} },
-          category: "mcp",
-          // isError 时加错误前缀, 让皮皮虾的自愈重试语义对 MCP 工具同样生效
-          execute: async (args) => {
-            const raw = await client.callToolRaw(t.name, args || {});
-            const { text, isError } = extractToolResult(raw);
-            return isError ? `${TOOL_ERROR_PREFIX} MCP 工具 ${t.name}: ${text}` : text;
-          },
-        });
-        count += 1;
-      }
-      count += registerResourceTools(catalog, client, s, ns);
-      clients.push(client);
-    } catch (e) {
-      warn(`[mcp] 服务器 ${s.command || s.url} 连接失败: ${e.message}`);
-      client.close();
-    }
-  }
-  if (count) info(`[mcp] 已注册 ${count} 个 MCP 工具`);
-  return { count, clients, close: () => clients.forEach((c) => c.close()) };
-}
-
-// 服务器声明 resources 能力时, 注册 list_resources / read_resource 两个工具 (让 LLM 可读远程资源)
-function registerResourceTools(catalog, client, s, ns = "") {
-  if (!client.capabilities?.resources) return 0;
-  const label = s.command || s.url || "MCP";
-  catalog.register({
-    name: ns + "list_resources",
-    description: `列出 MCP 服务器 ${label} 提供的资源 (URI 列表)`,
-    parameters: { type: "object", properties: {}, required: [] },
-    category: "mcp",
-    execute: async () => {
-      const res = await client.listResources();
-      return res.map((r) => `${r.uri || "?"}${r.name ? ` — ${r.name}` : ""}`).join("\n") || "(无资源)";
-    },
-  });
-  catalog.register({
-    name: ns + "read_resource",
-    description: `读取 MCP 服务器 ${label} 的资源内容 (按 uri)`,
-    parameters: { type: "object", properties: { uri: { type: "string", description: "资源 URI" } }, required: ["uri"] },
-    category: "mcp",
-    execute: async (args) => extractResourceText(await client.readResource((args || {}).uri)),
-  });
-  return 2;
-}
+// src/mcp/index.js - MCP 工具注册 (接入 MCP 工具生态)
+// 把 MCP 服务器的工具转换为皮皮虾 ToolCatalog 工具, 与内置工具同权。
+// servers: [
+//   { command, args, env, prefix }                         // stdio (本机)
+//   { url, headers, prefix, timeout }                      // HTTP Streamable (远程)
+// ]
+import { McpClient, extractToolResult, extractResourceText } from "./client.js";
+import { TOOL_ERROR_PREFIX } from "../tools/catalog.js";
+import { warn, info, debug } from "../utils/logger.js";
+
+// v1.0.8: MCP 工具名清洗 (只留 \w.-, 截断) — 防恶意服务器注册非法工具名/注入
+export function sanitizeMcpName(name) {
+  return String(name || "").replace(/[^\w.-]/g, "_").slice(0, 64);
+}
+
+// P1⑦ (2026-09-15): MCP 命名空间隔离 —— 防工具名碰撞 (Hermes 生产数据: 51 工具服务器上
+//   幻觉工具名命中真实工具; cron job 本想调 kanban_list 结果执行了 list_goals)。
+//   强制 serverName__toolName 前缀 + 精确匹配短路。
+export function serverLabel(s) {
+  // 取服务器可读标识: 配置 name > 包名 (args 里 @scope/pkg 或 *.py) > command 首段 > url host
+  if (s && s.name) return sanitizeMcpName(s.name);
+  const fromArgs = (s && s.args || []).find((a) => /(?:^|\/)[@\w.-]+(?:@[\w.]+)?$/.test(a) && !a.startsWith("-"));
+  if (fromArgs) return sanitizeMcpName(fromArgs.split("/").pop());
+  if (s && s.command) return sanitizeMcpName(String(s.command).split(/[\\/\s]/).filter(Boolean).pop() || "mcp");
+  if (s && s.url) {
+    try {
+      const host = new URL(s.url).hostname.split(".").filter(Boolean);
+      // 取二级域: mcp.example.com → example; www.google.com → google
+      return sanitizeMcpName(host.length >= 2 ? host[host.length - 2] : host[0] || "mcp");
+    } catch (e) { debug(`[mcp/index] 已忽略异常: ${e && e.message ? e.message : e}`); }
+  }
+  return "mcp";
+}
+
+export function namespacedMcpName(label, raw) {
+  const clean = sanitizeMcpName(raw);
+  return clean ? `${label}__${clean}` : label;
+}
+
+// v1.0.8: MCP 工具描述清洗 (单行化 + 截断) — 服务器描述直接进 LLM prompt, 防换行/长文本注入指令
+// P1⑦: 额外剔除危险 flag (--system/--dangerously 等命令行注入惯用手法)
+export function sanitizeMcpDescription(desc, name) {
+  let s = String(desc || "").replace(/\s+/g, " ").trim();
+  // 危险 flag 清洗: 描述里出现命令行注入惯用 flag 视为可疑, 剔除该片段
+  s = s.replace(/--(?:system|dangerously[-\w]*|yes|force|no[-\w]+|y)\b/g, "[flag]");
+  return s.slice(0, 200) || `MCP 工具: ${name}`;
+}
+
+// 连接所有 MCP 服务器, 列出工具并注册到 catalog。
+// 除 tools 外, 服务器声明 resources/prompts 能力时, 额外注册对应读写工具 (P2⑥)。
+// 返回 { count, clients, close } — close() 关闭全部连接 (调用方负责生命周期)
+export async function registerMcpTools(catalog, servers = []) {
+  const clients = [];
+  let count = 0;
+  for (const s of servers) {
+    if (!s) { warn("[mcp] 跳过无效服务器配置"); continue; }
+    if (!s.command && !s.url) { warn("[mcp] 跳过无效服务器配置 (缺 command/url)"); continue; }
+    const client = new McpClient(s);
+    try {
+      await client.connect();
+      const tools = await client.listTools();
+      // P1⑦: 命名空间强制前缀 (serverLabel) —— 默认开启, 可显式 prefix 覆盖/关闭
+      const label = serverLabel(s);
+      const ns = s.prefix != null ? s.prefix : `${label}__`;
+      for (const t of tools) {
+        if (!t || !t.name) continue;
+        const name = ns + sanitizeMcpName(t.name);
+        // P1⑦: 精确匹配短路 —— 注册时登记原始名 (供幻觉工具名防御: 无前缀名永不执行)
+        catalog.register({
+          name,
+          description: sanitizeMcpDescription(t.description, t.name),
+          parameters: t.inputSchema || { type: "object", properties: {} },
+          category: "mcp",
+          // isError 时加错误前缀, 让皮皮虾的自愈重试语义对 MCP 工具同样生效
+          execute: async (args) => {
+            const raw = await client.callToolRaw(t.name, args || {});
+            const { text, isError } = extractToolResult(raw);
+            return isError ? `${TOOL_ERROR_PREFIX} MCP 工具 ${t.name}: ${text}` : text;
+          },
+        });
+        count += 1;
+      }
+      count += registerResourceTools(catalog, client, s, ns);
+      clients.push(client);
+    } catch (e) {
+      warn(`[mcp] 服务器 ${s.command || s.url} 连接失败: ${e.message}`);
+      client.close();
+    }
+  }
+  if (count) info(`[mcp] 已注册 ${count} 个 MCP 工具`);
+  return { count, clients, close: () => clients.forEach((c) => c.close()) };
+}
+
+// 服务器声明 resources 能力时, 注册 list_resources / read_resource 两个工具 (让 LLM 可读远程资源)
+function registerResourceTools(catalog, client, s, ns = "") {
+  if (!client.capabilities?.resources) return 0;
+  const label = s.command || s.url || "MCP";
+  catalog.register({
+    name: ns + "list_resources",
+    description: `列出 MCP 服务器 ${label} 提供的资源 (URI 列表)`,
+    parameters: { type: "object", properties: {}, required: [] },
+    category: "mcp",
+    execute: async () => {
+      const res = await client.listResources();
+      return res.map((r) => `${r.uri || "?"}${r.name ? ` — ${r.name}` : ""}`).join("\n") || "(无资源)";
+    },
+  });
+  catalog.register({
+    name: ns + "read_resource",
+    description: `读取 MCP 服务器 ${label} 的资源内容 (按 uri)`,
+    parameters: { type: "object", properties: { uri: { type: "string", description: "资源 URI" } }, required: ["uri"] },
+    category: "mcp",
+    execute: async (args) => extractResourceText(await client.readResource((args || {}).uri)),
+  });
+  return 2;
+}

package/src/mcp/server.js

@@ -6,9 +6,18 @@
 //   - legacy 2025-06-18 及更早: initialize 握手 + capabilities 协商 (兼容存量 MCP 客户端)。
 // 传输无关: 仅做 JSON-RPC 分发, stdio/HTTP 传输由上层 (src/mcp/http.js 等) 接入。
 import { TOOL_ERROR_PREFIX } from "../tools/catalog.js";
-import { warn } from "../utils/logger.js";
+import { warn, debug } from "../utils/logger.js";
 import { sanitizeMcpName } from "./index.js";
 
+// 版本号统一读 package.json, 避免与发布版本漂移 (外部体检: 硬编码 2.5.0 导致 serverInfo 落后真实版本)
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+let PKG_VERSION = "0.0.0";
+try {
+  PKG_VERSION = JSON.parse(readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json"), "utf8")).version || "0.0.0";
+} catch (e) { debug(`[mcp/server] 已忽略异常: ${e && e.message ? e.message : e}`); } // 非标准安装位置时降级, 不影响启动
+
 // 协议版本常量 (与官方 schema/2026-07-28 对齐)
 export const MODERN_PROTOCOL_VERSION = "2026-07-28";  // 现代 era (每请求 _meta)
 export const LEGACY_PROTOCOL_VERSION = "2025-06-18";  // legacy era (initialize 握手) 最高支持版本
@@ -70,23 +79,26 @@ export class McpServer {
     this.agent = agent;
     this.serverInfo = {
       name: opts.name || agent?.config?.agent?.name || "ppxans-harness",
-      version: opts.version || "2.5.0",
+      version: opts.version || PKG_VERSION,
     };
     this.supportedVersions = opts.supportedVersions || SUPPORTED_VERSIONS;
     // 对话虚拟工具 (MCP 客户端驱动 agent 对话的入口, 不进 catalog 避免污染 LLM 工具列表)
+    // 两个对话工具入参完全一致 (message + sessionId), 共用一个 schema 工厂, 避免改一处漏一处;
+    // 每次调用返回新对象, 不共享引用 (防止下游按需改写 schema 时互相污染)。
+    const chatInputSchema = () => ({
+      type: "object",
+      properties: {
+        message: { type: "string", description: "用户消息" },
+        sessionId: { type: "string", description: "会话标识 (默认 default)" },
+      },
+      required: ["message"],
+    });
     const chatTools = [
       {
         name: "ppx.chat.send",
         title: "对话 (非流式)",
         description: "发送消息给皮皮虾 agent, 返回完整回复。内部会执行完整工具调用循环 (记忆/搜索/命令等)。sessionId 用于区分会话上下文, 默认 default。",
-        inputSchema: {
-          type: "object",
-          properties: {
-            message: { type: "string", description: "用户消息" },
-            sessionId: { type: "string", description: "会话标识 (默认 default)" },
-          },
-          required: ["message"],
-        },
+        inputSchema: chatInputSchema(),
         execute: async (args, ctx, agent) => {
           const reply = await agent.chat(String(args.message || ""), { sessionKey: args.sessionId || "default" });
           return { content: [{ type: "text", text: String(reply) }] };
@@ -96,14 +108,7 @@ export class McpServer {
         name: "ppx.chat.stream",
         title: "对话 (流式)",
         description: "发送消息给皮皮虾 agent, 流式返回回复 (SSE 进度通知)。内部会执行完整工具调用循环。sessionId 用于区分会话上下文, 默认 default。",
-        inputSchema: {
-          type: "object",
-          properties: {
-            message: { type: "string", description: "用户消息" },
-            sessionId: { type: "string", description: "会话标识 (默认 default)" },
-          },
-          required: ["message"],
-        },
+        inputSchema: chatInputSchema(),
         execute: async (args, ctx, agent) => {
           let full = "";
           const reply = await agent.chatStream(String(args.message || ""), {

package/src/mcp/tasks.js

@@ -2,9 +2,9 @@
 // 轻量任务工作区: 任务 = { id, title, description, status, steps[], result, createdAt, updatedAt }
 // 持久化到 <root>/data/tasks.json (原子写), 支持 create/list/get/update/step/delete/complete。
 // 供 MCP 工具 ppx.task.* 与 web 前端任务面板使用。
-import fs from "node:fs";
 import path from "node:path";
-import { ensureDir, atomicWrite } from "../utils/store.js";
+import { readJson, writeJson } from "../utils/store.js";
+import { shortId } from "../utils/id.js";
 
 const VALID_TASK_STATUS = new Set(["todo", "running", "done", "failed"]);
 const VALID_STEP_STATUS = new Set(["pending", "running", "done", "failed"]);
@@ -18,22 +18,17 @@ export class TaskBoard {
   }
 
   _load() {
-    try {
-      if (fs.existsSync(this.file)) {
-        const raw = JSON.parse(fs.readFileSync(this.file, "utf8"));
-        if (Array.isArray(raw.tasks)) {
-          for (const t of raw.tasks) {
-            if (t && t.id) this.tasks.set(t.id, this._normalize(t));
-          }
-        }
+    const raw = readJson(this.file, null); // 损坏则从空开始, 下次写入覆盖
+    if (raw && Array.isArray(raw.tasks)) {
+      for (const t of raw.tasks) {
+        if (t && t.id) this.tasks.set(t.id, this._normalize(t));
       }
-    } catch (e) { /* 损坏则从空开始, 下次写入覆盖 */ }
+    }
   }
 
   _save() {
     try {
-      ensureDir(path.dirname(this.file));
-      atomicWrite(this.file, JSON.stringify({ tasks: [...this.tasks.values()] }, null, 2));
+      writeJson(this.file, { tasks: [...this.tasks.values()] });
     } catch (e) { /* 持久化失败不阻断内存操作 */ }
   }
 
@@ -58,7 +53,7 @@ export class TaskBoard {
 
   create({ title, description = "", steps = [] } = {}) {
     if (!title) throw new Error("任务需 title");
-    const id = "t_" + Date.now().toString(36) + Math.random().toString(36).slice(2, 5);
+    const id = shortId("t_", 5);
     const t = this._normalize({
       id, title, description,
       steps: steps.map((s) => ({ title: String(s) })).filter((s) => s.title),

package/src/memory/asset-hub.js

@@ -5,9 +5,9 @@
 //   - 检索隔离: 私有资产仅 owner 可检索; 团队资产共享 (简化: 全局可见)
 // 皮皮虾自研实现, 构建在现有 facts (带 scope) 之上: 资产 = 一组带 scope 的 facts + 元数据登记。
 // 纯代码可测, 无 LLM。
-import fs from "node:fs";
 import path from "node:path";
-import { ensureDir, writeText, readText } from "../utils/store.js";
+import { ensureDir, readJson, writeJson } from "../utils/store.js";
+import { shortId } from "../utils/id.js";
 
 export const VISIBILITY = { PRIVATE: "private", TEAM: "team" };
 
@@ -26,22 +26,17 @@ export class AssetHub {
   }
 
   _load() {
-    try {
-      if (fs.existsSync(this.file)) {
-        const d = JSON.parse(fs.readFileSync(this.file, "utf8"));
-        if (Array.isArray(d)) return d;
-      }
-    } catch {}
-    return [];
+    const d = readJson(this.file, null);
+    return Array.isArray(d) ? d : [];
   }
 
-  _save() { writeText(this.file, JSON.stringify(this._assets, null, 2)); }
+  _save() { writeJson(this.file, this._assets); }
 
   // 登记一个资产 (关联到 facts scope)
   // { name, kind: 'document'|'skill'|'experience', scope, owner, visibility, source, description }
   register(asset) {
     if (!asset || !asset.name) throw new Error("资产需 name");
-    const id = "as" + Date.now().toString(36) + Math.random().toString(36).slice(2, 5);
+    const id = shortId("as", 5);
     const a = {
       id,
       name: asset.name,

package/src/memory/canvas.js

@@ -4,9 +4,8 @@
 //   细节按 node_id 从事件日志取 —— 上层存结构, 下层存证据, 完整 drill-down 路径。
 // 皮皮虾自研实现: 从 trace.js 的事件流 (turn/step 边界事件) 归纳画布, 非 LLM、纯代码、可测。
 // 触发条件: steps >= minSteps (默认 8) 或事件数超阈值时才开启, 防过度设计。
-import fs from "node:fs";
 import path from "node:path";
-import { ensureDir, writeText, logicalDay } from "../utils/store.js";
+import { ensureDir, writeText, readJson, logicalDay } from "../utils/store.js";
 
 export const CANVAS_DEFAULTS = { minSteps: 8, maxNodes: 30, maxEdges: 40 };
 
@@ -101,9 +100,7 @@ export class CanvasStore {
   }
 
   read(day = logicalDay()) {
-    const f = this._file(day);
-    if (!fs.existsSync(f)) return null;
-    try { return JSON.parse(fs.readFileSync(f, "utf8")); } catch { return null; }
+    return readJson(this._file(day), null);
   }
 
   // 从 trace 事件自动生成并保存 (若步骤数达标); 返回 null 表示未触发

package/src/memory/compaction.js

@@ -1,28 +1,28 @@
-// src/memory/compaction.js - 会话压缩层 (吸收 OpenClaw compaction 精华)
-// 设计要点:
-//  - 超阈值时用 LLM 把旧对话压缩成「结构化摘要」(固定格式), 替换旧历史, 防上下文失控
-//  - 摘要可迭代: 摘要作为 system 消息进入下一轮, 下次压缩时摘要+新对话一起再压
-//  - 固定格式: 目标/进展/关键决策/待办/关键上下文, 保证可预测、可续写
-
-export const COMPACTION_SYSTEM_PROMPT = `你是对话压缩器。把下面的对话历史压缩成一段结构化摘要，严格按以下格式输出（无内容的小节填「无」）：
-- 目标：用户想达成什么
-- 进展：已完成的关键步骤
-- 关键决策：已确定的重要决定/约定
-- 待办：尚未完成的事项
-- 关键上下文：后续对话必须知道的细节（数字/路径/偏好/约束）
-要求：简洁，≤300字，保留所有关键事实，不要客套，直接输出摘要。`;
-
-// 组装压缩请求消息 (system + 待压缩对话)
-export function buildCompactionMessages(transcript) {
-  return [
-    { role: "system", content: COMPACTION_SYSTEM_PROMPT },
-    { role: "user", content: String(transcript).slice(0, 8000) },
-  ];
-}
-
-// 把投影消息列表转成压缩用文本 (role → 中文标签)
-export function transcriptToText(messages) {
-  return messages
-    .map((m) => (m.role === "user" ? "用户" : m.role === "assistant" ? "助手" : m.role) + ": " + String(m.content ?? ""))
-    .join("\n");
-}
+// src/memory/compaction.js - 会话压缩层 (吸收 OpenClaw compaction 精华)
+// 设计要点:
+//  - 超阈值时用 LLM 把旧对话压缩成「结构化摘要」(固定格式), 替换旧历史, 防上下文失控
+//  - 摘要可迭代: 摘要作为 system 消息进入下一轮, 下次压缩时摘要+新对话一起再压
+//  - 固定格式: 目标/进展/关键决策/待办/关键上下文, 保证可预测、可续写
+
+export const COMPACTION_SYSTEM_PROMPT = `你是对话压缩器。把下面的对话历史压缩成一段结构化摘要，严格按以下格式输出（无内容的小节填「无」）：
+- 目标：用户想达成什么
+- 进展：已完成的关键步骤
+- 关键决策：已确定的重要决定/约定
+- 待办：尚未完成的事项
+- 关键上下文：后续对话必须知道的细节（数字/路径/偏好/约束）
+要求：简洁，≤300字，保留所有关键事实，不要客套，直接输出摘要。`;
+
+// 组装压缩请求消息 (system + 待压缩对话)
+export function buildCompactionMessages(transcript) {
+  return [
+    { role: "system", content: COMPACTION_SYSTEM_PROMPT },
+    { role: "user", content: String(transcript).slice(0, 8000) },
+  ];
+}
+
+// 把投影消息列表转成压缩用文本 (role → 中文标签)
+export function transcriptToText(messages) {
+  return messages
+    .map((m) => (m.role === "user" ? "用户" : m.role === "assistant" ? "助手" : m.role) + ": " + String(m.content ?? ""))
+    .join("\n");
+}