ppxans-harness 2.4.0

package/src/seam/shell.js

@@ -0,0 +1,55 @@
+// src/seam/shell.js - Shell 能力 seam (吸收 dsh Service|Provider|Consumer 三层)
+// Service Definition: 命令执行能力, 接口 = exec(cmd, opts) -> Promise<{stdout, stderr, code, ok}>
+//   - Service: "shell" 这个能力 (key = "shell")
+//   - Provider: LocalShellProvider (本地 execFile, 默认) | 未来 SandboxShellProvider (Docker/MicroVM)
+//   - Consumer: run_command / code_act 工具, 通过 ctx.consume("shell") 获取实现, 换 provider 即换执行环境
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+// 信号死亡可读化 (吸收 Hermes: 裸退出码 -> 人类可读说明)
+// 负码/信号(子进程语义)确定性描述; shell 的 128+signum 约定用"通常"措辞
+const SIGNAL_NOTES = {
+  SIGKILL: "通常内存耗尽(OOM)被内核强杀, 或显式 kill -9",
+  SIGTERM: "正常终止请求(可能超时被强杀)",
+  SIGSEGV: "段错误(访问非法内存)",
+  SIGABRT: "abort 异常终止",
+  SIGINT: "Ctrl+C 中断",
+  SIGPIPE: "管道断裂(读取端提前关闭)",
+  SIGBUS: "总线错误",
+  SIGFPE: "浮点异常",
+  SIGUSR1: "用户自定义信号 1",
+  SIGQUIT: "键盘退出信号",
+};
+function signalNote(sig) {
+  if (!sig) return "";
+  const extra = SIGNAL_NOTES[sig] ? " — " + SIGNAL_NOTES[sig] : "";
+  return ` (进程被信号 ${sig} 终止${extra})`;
+}
+
+// 默认本地 shell provider: 在本机 shell 直接执行命令
+// 约定: 永不 throw, 错误编码进返回值 (code != 0 或 ok=false), 与 LLM 重试内核的"失败编码进结果"一致
+export class LocalShellProvider {
+  async exec(cmd, { cwd, timeoutMs = 30000, maxBuffer = 1024 * 1024, env = null } = {}) {
+    const isWin = process.platform === "win32";
+    try {
+      const { stdout, stderr } = await execFileP(isWin ? "cmd.exe" : "/bin/sh", [isWin ? "/c" : "-c", cmd], {
+        cwd,
+        timeout: timeoutMs,
+        maxBuffer,
+        env: env || undefined,
+        windowsHide: true,
+      });
+      return { stdout: stdout || "", stderr: stderr || "", code: 0, ok: true };
+    } catch (e) {
+      const sig = e && e.signal;
+      return {
+        stdout: "",
+        stderr: String(e && e.message || e) + signalNote(sig),
+        code: typeof e.code === "number" ? e.code : (sig ? -1 : 1),
+        ok: false,
+      };
+    }
+  }
+}

package/src/selfheal/evolve.js

@@ -0,0 +1,68 @@
+// src/selfheal/evolve.js - 自进化引擎
+// 职责: 闭合「记录轨迹 → 提炼教训 → 注入上下文」的自进化闭环。
+// 背景: refine()(失败→经验) 和 refineSkill()(成功→技能) 方法早已在 agent 上定义,
+//   但全仓库没有任何触发点 → 皮皮虾天天记录工具轨迹却从不"停下来学"。
+//   本引擎就是那个自动触发点: 每 N 次工具调用后, 异步提炼失败教训 + 沉淀重复成功技能。
+// 约束: 异步 fire-and-forget, 绝不阻塞当前对话; 无 LLM 时安全跳过;
+//   节流 (minIntervalMs) 防止高频提炼爆 LLM 成本; 可配置关闭 (agent.evolve.enabled=false)。
+import { info, warn } from "../utils/logger.js";
+
+export class EvolutionEngine {
+  constructor(agent, config = {}) {
+    this.agent = agent;
+    this.enabled = config.enabled !== false;
+    this.everyCalls = Number(config.every_calls) || 20;       // 每 N 次工具调用触发一次提炼
+    this.minIntervalMs = Number(config.min_interval_ms) || 30000; // 两次提炼最小间隔
+    this.upgradeUses = Number(config.upgrade_uses) || 3;      // 技能用满 N 次自动升级 (用中自进化)
+    this._calls = 0;
+    this._lastAt = 0;
+  }
+
+  // 每轮对话收尾调用 (幂等, 轻量, 同步返回)
+  tick() {
+    if (!this.enabled) return;
+    const a = this.agent;
+    if (!a || !a.llm) return;                 // 无 LLM: 无法提炼
+    if (typeof a.refine !== "function") return;
+    this._calls++;
+    if (this._calls < this.everyCalls) return;
+    if (Date.now() - this._lastAt < this.minIntervalMs) return;
+    this._calls = 0;
+    this._lastAt = Date.now();
+    this._run();                              // fire-and-forget, 不 await
+  }
+
+  async _run() {
+    const a = this.agent;
+    try {
+      const traces = (typeof a.traces?.read === "function") ? a.traces.read(undefined, 50) : [];
+      const failed = traces.filter((t) => !t.ok);
+      const okCalls = traces.filter((t) => t.ok);
+      // 失败 → 提炼经验 (至少 2 条失败轨迹才有得教)
+      if (failed.length >= 2) {
+        const r = await a.refine({ limit: 20 });
+        if (r && r.distilled > 0) info(`[evolve] 失败→经验: ${String(r.lesson || "").slice(0, 120)}`);
+      }
+      // 重复成功 → 沉淀技能 (至少 3 条成功轨迹才有得沉淀)
+      if (okCalls.length >= 3) {
+        const r = await a.refineSkill({ limit: 50, minFreq: 2 });
+        if (r && r.created > 0) info(`[evolve] 成功→技能: ${r.name}`);
+      }
+      // 用中自进化: 扫描高频技能 (uses >= upgradeUses) 触发升级
+      if (typeof a.upgradeSkill === "function" && a.skills && typeof a.skills.usageAll === "function") {
+        try {
+          const usage = a.skills.usageAll() || {};
+          const ripe = Object.entries(usage).filter(([, u]) => (u && (u.uses || 0)) >= this.upgradeUses);
+          for (const [sid] of ripe) {
+            const r = await a.upgradeSkill(sid, { minUses: this.upgradeUses });
+            if (r && r.upgraded > 0) info(`[evolve] 用中升级技能: ${r.name}`);
+          }
+        } catch (e) {
+          warn(`[evolve] 技能升级失败: ${String(e?.message || e).slice(0, 120)}`);
+        }
+      }
+    } catch (e) {
+      warn(`[evolve] 提炼失败 (不影响当前对话): ${String(e?.message || e).slice(0, 160)}`);
+    }
+  }
+}

package/src/selfheal/healer.js

@@ -0,0 +1,167 @@
+// src/selfheal/healer.js - 自愈引擎
+// 1. 启动检查: 修复缺失目录/损坏JSON/权限
+// 2. 崩溃恢复: 检测上次异常退出, 清理残留
+// 3. 数据一致性: 校验记忆文件
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir, readJson } from "../utils/store.js";
+import { info, warn, error } from "../utils/logger.js";
+
+export class Healer {
+  constructor(rootDir) {
+    this.root = rootDir;
+    this.dataDir = path.join(rootDir, "data");
+    this.integrity = path.join(this.dataDir, "integrity.json");
+  }
+
+  // 启动体检: 返回修复清单
+  runStartupChecks() {
+    const fixes = [];
+    ensureDir(this.dataDir);
+    for (const sub of ["memory", "memory/daily", "experience", "sessions", "logs"]) {
+      const d = path.join(this.dataDir, sub);
+      if (!fs.existsSync(d)) { fs.mkdirSync(d, { recursive: true }); fixes.push(`created dir: ${sub}`); }
+    }
+    // 校验关键 JSON 可解析
+    const facts = path.join(this.dataDir, "memory", "facts.json");
+    if (fs.existsSync(facts)) {
+      const parsed = readJson(facts, null);
+      if (parsed === null) {
+        // 损坏: 备份后重建
+        const bak = facts + ".corrupt-" + Date.now();
+        fs.renameSync(facts, bak);
+        fs.writeFileSync(facts, "[]", "utf8");
+        fixes.push(`facts.json corrupt -> backed up to ${path.basename(bak)}, reset`);
+      }
+    }
+    return fixes;
+  }
+
+  // 崩溃恢复: 检查上次是否干净退出
+  checkCrash() {
+    const state = readJson(this.integrity, { clean: true, pid: null });
+    const result = { crashed: false, detail: null };
+    if (state.clean === false) {
+      result.crashed = true;
+      result.detail = `上次进程 (pid=${state.pid}) 未干净退出, 可能残留临时文件`;
+      this._cleanupTmp();
+    }
+    return result;
+  }
+
+  _cleanupTmp() {
+    const walk = (dir) => {
+      if (!fs.existsSync(dir)) return;
+      for (const f of fs.readdirSync(dir)) {
+        const p = path.join(dir, f);
+        let st;
+        try { st = fs.statSync(p); } catch { continue; } // 并发删除竞态容错
+        if (st.isDirectory()) walk(p);
+        else if (f.endsWith(".tmp")) { try { fs.unlinkSync(p); } catch {} info(`cleaned tmp: ${f}`); }
+      }
+    };
+walk(this.dataDir);
+  }
+
+  markDirty() {
+    ensureDir(this.dataDir);
+    fs.writeFileSync(this.integrity, JSON.stringify({ clean: false, pid: process.pid, ts: Date.now() }), "utf8");
+  }
+
+  markClean() {
+    ensureDir(this.dataDir);
+    fs.writeFileSync(this.integrity, JSON.stringify({ clean: true, pid: process.pid, ts: Date.now() }), "utf8");
+  }
+
+  // 清理历史 corrupt 备份: 保留最近 N 个, 更早自动删除 (默认保留 2)
+  cleanupCorruptBackups(keep = 2) {
+    const files = [];
+    const walk = (d) => {
+      if (!fs.existsSync(d)) return;
+      for (const f of fs.readdirSync(d)) {
+        const p = path.join(d, f);
+        let st;
+        try { st = fs.statSync(p); } catch { continue; }
+        if (st.isDirectory()) walk(p);
+        else if (f.includes(".corrupt-")) files.push({ p, mtime: st.mtimeMs });
+      }
+    };
+    walk(this.dataDir);
+    files.sort((a, b) => b.mtime - a.mtime);
+    const removed = [];
+    for (const f of files.slice(keep)) {
+      try { fs.unlinkSync(f.p); removed.push(path.basename(f.p)); }
+      catch (e) { warn("清理损坏备份失败: " + f.p + ": " + e.message); }
+    }
+    if (removed.length) info("selfheal: 清理旧 corrupt 备份 " + removed.length + " 个: " + removed.join(", "));
+    return removed;
+  }
+
+  // 清理历史手动备份目录 (memory-backup-*): 保留最近 N 个, 更早自动删除 (默认保留 2)
+  // 手动全量备份目录不在 corrupt 备份机制内, 若无清理会持续累积磁盘占用
+  cleanupStaleBackupDirs(keep = 2) {
+    if (!fs.existsSync(this.dataDir)) return [];
+    const dirs = [];
+    for (const f of fs.readdirSync(this.dataDir)) {
+      if (!f.startsWith("memory-backup-")) continue;
+      const p = path.join(this.dataDir, f);
+      let st;
+      try { st = fs.statSync(p); } catch { continue; }
+      if (!st.isDirectory()) continue;
+      dirs.push({ p, mtime: st.mtimeMs });
+    }
+    dirs.sort((a, b) => b.mtime - a.mtime);
+    const removed = [];
+    for (const d of dirs.slice(keep)) {
+      try { fs.rmSync(d.p, { recursive: true, force: true }); removed.push(path.basename(d.p)); }
+      catch (e) { warn("清理过期备份目录失败: " + d.p + ": " + e.message); }
+    }
+    if (removed.length) info("selfheal: 清理旧手动备份目录 " + removed.length + " 个: " + removed.join(", "));
+    return removed;
+  }
+
+  // 清理历史 .bak-* 文件 (去重/迁移等一次性工具留下的手动备份): 保留最近 N 个, 更早自动删除 (默认保留 2)
+  // 覆盖 facts.json.bak-* / lessons.json.bak-* 等, 防手动备份文件在 data/ 内无限累积
+  cleanupStaleBakFiles(keep = 2) {
+    if (!fs.existsSync(this.dataDir)) return [];
+    const files = [];
+    const walk = (d) => {
+      if (!fs.existsSync(d)) return;
+      for (const f of fs.readdirSync(d)) {
+        const p = path.join(d, f);
+        let st;
+        try { st = fs.statSync(p); } catch { continue; }
+        if (st.isDirectory()) walk(p);
+        else if (f.includes(".bak-") && !f.endsWith(".lock")) files.push({ p, mtime: st.mtimeMs });
+      }
+    };
+    walk(this.dataDir);
+    files.sort((a, b) => b.mtime - a.mtime);
+    const removed = [];
+    for (const f of files.slice(keep)) {
+      try { fs.unlinkSync(f.p); removed.push(path.basename(f.p)); }
+      catch (e) { warn("清理过期备份文件失败: " + f.p + ": " + e.message); }
+    }
+    if (removed.length) info("selfheal: 清理旧 .bak-* 备份文件 " + removed.length + " 个: " + removed.join(", "));
+    return removed;
+  }
+  
+  // 完整自愈入口
+  heal() {
+    const fixes = this.runStartupChecks();
+    const crash = this.checkCrash();
+    // 清理历史 corrupt 备份 (保留最近 2 个, 更早自动删除) — 之前漏调用导致 corrupt 持续累积
+    const cleanedCorrupt = this.cleanupCorruptBackups(2);
+    // 清理历史手动备份目录 (保留最近 2 个)
+    const cleanedBackupDirs = this.cleanupStaleBackupDirs(2);
+    // 清理历史 .bak-* 文件 (保留最近 2 个)
+    const cleanedBakFiles = this.cleanupStaleBakFiles(2);
+    // 崩溃残留清理后主动翻回 clean: 自愈闭环 - 清了毒就要"宣布痊愈", 否则下次启动还误报崩溃
+    if (crash.crashed) { this.markClean(); info("selfheal: 崩溃残留已清理, 状态置回 clean"); }
+    const report = { fixes, crashed: crash.crashed, crashDetail: crash.detail, cleanedCorrupt, cleanedBackupDirs, cleanedBakFiles };
+    if (fixes.length) info(`selfheal: 修复 ${fixes.length} 项: ${fixes.join("; ")}`);
+    else info("selfheal: 无异常");
+    if (crash.crashed) warn(`selfheal: 检测到崩溃残留 -> ${crash.detail}`);
+    return report;
+  }
+}

package/src/selfheal/run.js

@@ -0,0 +1,9 @@
+// src/selfheal/run.js - 自愈命令行入口
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Healer } from "./healer.js";
+
+const root = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const healer = new Healer(root);
+const report = healer.heal();
+console.log(JSON.stringify(report, null, 2));

package/src/server.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// src/server.js - 皮皮虾 HTTP 服务入口
+// 提供: /health, /message (HTTP通道), /feishu/webhook, /wechat/webhook
+// 通道统一走 ChannelManager 注册表: connect + webhook 挂载由各通道 mount() 完成
+import { ensureUTF8Console } from "./utils/winutf8.js";
+import { PPXAgent } from "./agent/index.js";
+import { ChannelManager } from "./channels/index.js";
+
+ensureUTF8Console();
+export async function startServer({ root = process.cwd(), port = 8899, host = "127.0.0.1", config = {}, llm = null } = {}) {
+    const agent = new PPXAgent({ root });
+  if (llm) {
+    // 测试注入 stub LLM, 避免依赖真实网络; 同步把 allProviders 替换为同源 stub,
+    // 让 /api/providers/test 等"按 id 取客户端"的路径也能命中 stub
+    agent.llm = llm;
+    if (Array.isArray(agent.allProviders)) agent.allProviders = [llm];
+  }
+
+  // 统一走注册表: HTTP 通道始终启动 (port/host 参数覆盖配置), 其余按 config.channels
+  // 基础配置来自 agent.config (config/ppx.json 加载的), 调用方传入的 config.channels 只做覆盖
+  const baseChannels = agent.config.channels || {};
+  const channelsCfg = { ...baseChannels, ...((config.channels) || {}) };
+  channelsCfg.http = { ...(channelsCfg.http || {}), enabled: true, port, host }; // port/host 参数最高优先级
+  const manager = new ChannelManager(agent, channelsCfg);
+  await manager.start();
+
+  // 主动提醒 → 广播到所有已启用通道 (agent.proactive.enabled 才接; 默认关不打扰)
+  if (agent.config.agent?.proactive?.enabled) {
+    agent.startProactiveTicker((payload) => manager.broadcast(payload.text));
+  }
+
+  const server = manager.httpServer;
+  return {
+    agent,
+    server,
+    http: manager.get("http"),
+    feishu: manager.get("feishu"),
+    wechat: manager.get("wechat"),
+    manager,
+  };
+}
+
+// CLI 启动公共逻辑: 供 bin/ppx-serve 与 src/server.js 直接运行共用
+export async function runServer({ root = process.cwd(), port = Number(process.env.PPX_PORT || 8899) } = {}) {
+  const { agent, server, manager } = await startServer({ root, port });
+  console.log(`皮皮虾 服务已启动: http://127.0.0.1:${port}`);
+  console.log(`  /health   健康检查`);
+  console.log(`  /message  HTTP 对话通道 (POST {message})`);
+  console.log(`  通道: ${manager.list().filter((c) => c.enabled).map((c) => c.name).join(", ") || "(无)"}`);
+  console.log(`  工具: ${agent.tools.list().join(", ")}`);
+  console.log("  Ctrl+C 退出");
+  process.on("SIGINT", () => { agent.shutdown(); process.exit(0); });
+  return { agent, server, manager };
+}
+
+// 直接运行 (node src/server.js, scripts/start-web.js)
+const _entry = (process.argv[1] || "").replace(/\\/g, "/");
+if (_entry.endsWith("src/server.js")) {
+  await runServer({ root: process.cwd() });
+}

package/src/services/learning-service.js

@@ -0,0 +1,177 @@
+// src/services/learning-service.js - 自我学习服务 (重构第二刀, 2026-09-14)
+// 目的: 把 PPXAgent 上的自我进化闭环 (失败→经验 refine / 成功→技能 refineSkill /
+//       使用中进化 upgradeSkill) 抽为独立服务, agent 只保留薄委托。
+// 设计:
+//   - 依赖全部注入: llm (getLlm 闭包, 实时取当前 provider) / traces (工具轨迹) /
+//     skills (技能加载器) / experience (经验库) / lifecycle (进化计数) /
+//     auditor (验证账本) / tracer (事件流) / toolNames (工具名清单, 接地防幻觉) /
+//     runTool (create_skill 工具调用, 由 agent 提供 agent 上下文)。
+//   - 验证闸门 (verifyLesson / verifySkill / verifyUpgradeSkill) 保持不动:
+//     经验/技能必须过确定性闸门才写回, 不信任模型自评。
+import { TOOL_ERROR_PREFIX } from "../tools/index.js";
+import { info, warn } from "../utils/logger.js";
+import { Auditor, verifyLesson, heldOutSplit } from "../audit/verifier.js";
+import { verifySkill, verifyUpgradeSkill } from "../skills/verify.js";
+
+// 辅助 LLM 调用短超时 (经验/技能提炼): 模型不可用/网络不通时快速失败降级
+const AUX_LLM_TIMEOUT_MS = 10000;
+
+export class LearningService {
+  // deps: { getLlm, traces, skills, experience, lifecycle, auditor, tracer, toolNames, runTool }
+  constructor(deps) {
+    this.getLlm = deps.getLlm;           // () => llm
+    this.traces = deps.traces;           // 工具调用轨迹 (Traces)
+    this.skills = deps.skills;           // SkillLoader
+    this.experience = deps.experience;   // 经验库
+    this.lifecycle = deps.lifecycle;     // ANS 生命周期
+    this.auditor = deps.auditor;         // Auditor (验证账本)
+    this.tracer = deps.tracer;           // 结构化事件流
+    this.toolNames = deps.toolNames;     // () => string[], 工具名清单 (verifyLesson 接地)
+    this.runTool = deps.runTool;         // (name, args) => Promise<string>, create_skill 调用
+    if (!(this.auditor instanceof Auditor)) {
+      // 兼容: 外部可能传普通对象 (测试/轻量装配), 不强求 Auditor 实例
+    }
+  }
+
+  _llm() { return this.getLlm ? this.getLlm() : null; }
+
+  // 失败→经验: 回放近期失败轨迹, LLM 提炼经验教训进经验库 (原 agent.refine)
+  async refine({ limit = 20 } = {}) {
+    const llm = this._llm();
+    if (!llm) return { distilled: 0, reason: "无 LLM" };
+    const failed = this.traces.read(undefined, limit).filter((t) => !t.ok);
+    if (failed.length < 2) return { distilled: 0, reason: "失败轨迹不足" };
+    const summary = failed
+      .map((t) => `工具 ${t.tool}: ${String(t.error || t.result || "").slice(0, 160)}`)
+      .join("\n");
+    let lesson;
+    try {
+      const r = await llm.chat([
+        { role: "system", content: "你是经验提炼器。从失败的工具调用轨迹中提炼一条可复用的经验教训, 一句话说清: 什么场景、为什么失败、下次怎么做。只输出这一句话, 不要解释。" },
+        { role: "user", content: summary.slice(0, 2000) },
+      ], { timeoutMs: AUX_LLM_TIMEOUT_MS, retryMax: 0 });
+      lesson = String(r.content || "").trim();
+    } catch { lesson = ""; }
+    if (!lesson) return { distilled: 0, reason: "LLM 未产出经验" };
+    // Auditor: 经验必须过确定性验证闸门才写回经验库 (不信任模型自评)
+    // 接地防幻觉(点名工具须有失败轨迹背书) + 可操作动词 + 单句精炼
+    const knownTools = this.toolNames ? this.toolNames() : [];
+    const g = await this.auditor.gate(
+      "lesson",
+      { lesson, failedTraces: failed, knownTools },
+      verifyLesson,
+      (p) => {
+        this.experience.learn({ task: "自动提炼", lesson: p.lesson, tags: ["auto-refine"] });
+        if (this.lifecycle) this.lifecycle.evolve(); // 生命周期: 进化计数 (落盘)
+      }
+    );
+    if (!g.committed) {
+      warn(`[refine] 经验被验证闸门拒绝 (${g.reason}): ${lesson.slice(0, 80)}`);
+      return { distilled: 0, rejected: true, reason: g.reason, lesson };
+    }
+    info(`[refine] 学到经验: ${lesson}`);
+    this.tracer?.event("learning/refine", { lesson: lesson.slice(0, 120) });
+    return { distilled: 1, lesson };
+  }
+
+  // 成功→技能: 从成功轨迹自动提炼可复用 Skill (原 agent.refineSkill)
+  // 轨迹 → 高频成功工具模式 → LLM 提炼 → create_skill 落盘 skills/<name>/SKILL.md
+  // 与 refine() (失败→经验) 互补, 形成「失败学教训 + 成功沉淀技能」完整闭环
+  async refineSkill({ limit = 50, minFreq = 2 } = {}) {
+    const llm = this._llm();
+    if (!llm) return { created: 0, reason: "无 LLM" };
+    const ok = this.traces.read(undefined, limit).filter((t) => t.ok);
+    if (ok.length < minFreq) return { created: 0, reason: "成功轨迹不足" };
+    // 找高频成功工具 (出现 >= minFreq 次)
+    const freq = {};
+    for (const t of ok) freq[t.tool] = (freq[t.tool] || 0) + 1;
+    const hot = Object.entries(freq).filter(([, n]) => n >= minFreq).map(([t]) => t);
+    if (!hot.length) return { created: 0, reason: "无重复成功工具模式" };
+    // 用 LLM 提炼 skill (name/description/content)
+    const summary = ok.slice(-20).map((t) => `工具 ${t.tool}: ${String(t.result || "").slice(0, 80)}`).join("\n");
+    let skill;
+    try {
+      const r = await llm.chat([
+        { role: "system", content: "你是技能提炼器。根据成功的工具调用轨迹, 提炼一个可复用技能。只输出 JSON: {\"name\":\"技能名(仅字母数字横线)\",\"description\":\"一句话说明\",\"content\":\"SKILL正文, 含 ## 流程(逐步工作流) 和 ## 验证(完成后必须提供的证据)\"}。不要解释, 只输出 JSON。" },
+        { role: "user", content: `高频工具: ${hot.join(", ")}\n成功轨迹:\n${summary.slice(0, 2000)}` },
+      ], { timeoutMs: AUX_LLM_TIMEOUT_MS, retryMax: 0 });
+      const text = String(r.content || "").trim().replace(/```(?:json|JSON)?\s*/g, "").replace(/```/g, "").trim();
+      const m = text.match(/\{[\s\S]*\}/);
+      if (!m) return { created: 0, reason: "LLM 未产出有效 JSON" };
+      skill = JSON.parse(m[0]);
+    } catch { return { created: 0, reason: "LLM 提炼失败" }; }
+    if (!skill || !skill.content) return { created: 0, reason: "Skill 字段缺失" };
+    // name 归一化: 仅字母/数字/横线, 非法字符剔除, 空则兜底
+    const name = String(skill.name || "").replace(/[^a-zA-Z0-9-]/g, "").toLowerCase() || ("auto-" + Date.now().toString(36));
+
+    // self-evolution "reliable verification": gate before persist (no LLM)
+    // -> structure (## Process + ## Verify) + grounded (content references hot tool, trace-backed)
+    // held-out 回归: 样本够多时切出未见过的 held-out 子集, 要求接地工具在那也有背书, 防过拟合
+    const { heldOut } = heldOutSplit(ok, { ratio: 0.4, minTotal: 6 });
+    const v = verifySkill({
+      name,
+      content: String(skill.content || ""),
+      hotTools: hot,
+      okTraces: ok,
+      minFreq,
+      heldOutTraces: heldOut.length ? heldOut : undefined,
+    });
+    if (!v.ok) {
+      warn("[refineSkill] skill rejected by verify gate: " + name + " - " + v.reason);
+      return { created: 0, reason: v.reason, rejected: true, name };
+    }
+    const res = await this.runTool("create_skill", {
+      name,
+      description: String(skill.description || "自动提炼的技能"),
+      content: String(skill.content),
+    });
+    if (res.startsWith(TOOL_ERROR_PREFIX)) return { created: 0, reason: res };
+    if (this.auditor) this.auditor.record("skill_created", { lesson: `创建技能 ${name}` }); // 已过 verifySkill 闸门, 只记账
+    info(`[refineSkill] 生成技能: ${name}`);
+    this.tracer?.event("learning/refine_skill", { name });
+    return { created: 1, name };
+  }
+
+  // 使用中进化: 技能用满 minUses 次后, 读当前内容 + 相关成功轨迹,
+  // LLM 改进 SKILL.md, 过 verifyUpgradeSkill 闸门(防退化) 后写回, 重置计数防连跑 (原 agent.upgradeSkill)
+  async upgradeSkill(id, { minUses = 3, limit = 40 } = {}) {
+    try {
+      const llm = this._llm();
+      if (!llm) return { upgraded: 0, reason: "无 LLM" };
+      if (!this.skills || typeof this.skills.read !== "function") return { upgraded: 0, reason: "无 skills加载器" };
+      const need = this.skills.get(id);
+      if (!need) return { upgraded: 0, reason: "未知技能: " + id };
+      const used = this.skills.useOf ? this.skills.useOf(id) : { uses: 0 };
+      if ((used.uses || 0) < minUses) return { upgraded: 0, reason: "使用不足", uses: used.uses, need: minUses, name: id };
+      const prev = this.skills.read(id);
+      if (prev === null) return { upgraded: 0, reason: "读取失败", name: id };
+      const ok = this.traces && typeof this.traces.read === "function" ? this.traces.read(undefined, limit).filter((t) => t.ok) : [];
+      const sample = ok.slice(-15).map((t) => "工具 " + t.tool + ": " + String(t.result || "").slice(0, 120)).join("\n");
+      let upgraded;
+      try {
+        const r = await llm.chat([
+          { role: "system", content: "你是技能升级器。下面是一个已存在的技能全文 + 最近的成功工具轨迹。你的任务: 基于这些实际经验改进这个技能, 补充它的“## 流程”工作步骤/检查点和“## 反合理化”建议, 切勿删除“## 验证”段。只输出改进后的 SKILL.md 正文 (frontmatter 不用重复), 不要解释。" },
+          { role: "user", content: "当前技能 (保留效果, 改进不足):\n\n" + String(prev).slice(0, 3000) + "\n\n最近成功轨迹:\n" + String(sample).slice(0, 2000) },
+        ], { timeoutMs: AUX_LLM_TIMEOUT_MS, retryMax: 0 });
+        upgraded = String(r.content || "").trim().replace(/```(?:md|markdown)?\s*/g, "").replace(/```/g, "").trim();
+      } catch {
+        return { upgraded: 0, reason: "LLM 升级失败", name: id };
+      }
+      if (!upgraded) return { upgraded: 0, reason: "空升级结果", name: id };
+      const v = verifyUpgradeSkill({ content: upgraded, prevContent: prev });
+      if (!v.ok) {
+        warn("[upgradeSkill] 被升级闸门拦截: " + id + " - " + v.reason);
+        return { upgraded: 0, reason: v.reason, rejected: true, name: id };
+      }
+      const w = await this.runTool("create_skill", { name: id, description: (need.description || ""), content: upgraded });
+      if (typeof w === "string" && w.startsWith(TOOL_ERROR_PREFIX)) return { upgraded: 0, reason: w, name: id };
+      if (this.skills.resetUse) this.skills.resetUse(id);
+      info("[upgradeSkill] 升级技能: " + id + " (uses=" + used.uses + ")");
+      this.tracer?.event("learning/upgrade_skill", { id, uses: used.uses });
+      return { upgraded: 1, name: id, changed: v.changed, uses: used.uses };
+    } catch (e) {
+      warn("[upgradeSkill] 失败: " + String(e?.message || e).slice(0, 120));
+      return { upgraded: 0, reason: String(e?.message || e).slice(0, 120), name: id };
+    }
+  }
+}

package/src/services/memory-health.js

@@ -0,0 +1,99 @@
+// src/services/memory-health.js - 记忆管线健康监控 (P1⑤)
+// 吸收 HanaAgent (openhanako) 的记忆管线健康监控设计:
+//   healthy / degraded / unhealthy 三态 + 分步失败计数 + 降级策略。
+// 皮皮虾自研实现: 监控记忆管线各步 (滚动归档 roll / 压缩 compact / LLM 提炼 extract),
+//   通过 wrap() 包裹原方法统计成败; 不健康时给出降级建议 (只写不压, 防上下文污染)。
+// 纯代码可测, 不依赖 LLM。
+export const HEALTH = { HEALTHY: "healthy", DEGRADED: "degraded", UNHEALTHY: "unhealthy" };
+
+export class MemoryHealthMonitor {
+  constructor({ degradeAfter = 3, windowMs = 5 * 60 * 1000 } = {}) {
+    this.degradeAfter = degradeAfter;   // 连续失败多少次进入 degraded
+    this.windowMs = windowMs;           // 统计窗口 (默认 5 分钟)
+    this.steps = new Map();             // stepName -> { ok, fail, lastError, lastAt, fails: [] }
+    this.degraded = false;              // 降级开关 (只写不压)
+  }
+
+  _step(name) {
+    if (!this.steps.has(name)) {
+      this.steps.set(name, { ok: 0, fail: 0, lastError: null, lastAt: 0, fails: [] });
+    }
+    return this.steps.get(name);
+  }
+
+  // 记录一步成功/失败
+  record(name, { ok = true, error = null } = {}) {
+    const s = this._step(name);
+    const now = Date.now();
+    s.ok += ok ? 1 : 0;
+    s.lastAt = now;
+    if (!ok) {
+      s.fail++;
+      s.lastError = error || "unknown";
+      s.fails.push(now);
+      // 滑动窗口裁剪
+      s.fails = s.fails.filter((t) => now - t < this.windowMs);
+    } else {
+      s.fails = [];
+    }
+    this._recompute();
+    return s;
+  }
+
+  // 连续失败 -> degraded (滑动窗口内失败数 >= degradeAfter)
+  _recompute() {
+    const now = Date.now();
+    let worst = 0;
+    for (const s of this.steps.values()) {
+      const recent = s.fails.filter((t) => now - t < this.windowMs).length;
+      if (recent > worst) worst = recent;
+    }
+    this.degraded = worst >= this.degradeAfter;
+    return this.degraded;
+  }
+
+  // 包装原方法: 自动统计成败; ok 判定可自定义 (默认不抛错即成功)
+  wrap(name, fn, { isOk = null } = {}) {
+    return async (...args) => {
+      try {
+        const r = await fn(...args);
+        const good = isOk ? isOk(r) : true;
+        this.record(name, { ok: good });
+        return r;
+      } catch (e) {
+        this.record(name, { ok: false, error: e?.message || String(e) });
+        throw e;
+      }
+    };
+  }
+
+  // 状态汇总
+  status() {
+    const now = Date.now();
+    const stepList = [...this.steps.entries()].map(([name, s]) => ({
+      name,
+      ok: s.ok,
+      fail: s.fail,
+      lastError: s.lastError,
+      recentFails: s.fails.filter((t) => now - t < this.windowMs).length,
+    }));
+    const totalFail = stepList.reduce((a, s) => a + s.fail, 0);
+    const overall = this.degraded
+      ? HEALTH.DEGRADED
+      : (totalFail === 0 ? HEALTH.HEALTHY : HEALTH.HEALTHY);
+    return { overall, degraded: this.degraded, steps: stepList, updatedAt: now };
+  }
+
+  // 降级建议 (供 memory ticker / agent 消费)
+  advice() {
+    if (!this.degraded) return { action: "normal" };
+    return {
+      action: "degrade",
+      reason: "记忆管线连续失败, 建议降级为只写不压",
+      // 只写不压: 跳过 LLM 压缩/提炼, 仅保留原始会话写入
+      skip: ["compact", "extract"],
+    };
+  }
+}
+
+export default MemoryHealthMonitor;