ppxans-harness 2.4.0

package/src/services/memory-service.js

@@ -0,0 +1,160 @@
+// src/services/memory-service.js - 记忆协调服务 (重构第二刀, 2026-09-14)
+// 目的: 把散在 PPXAgent 上的记忆升降级逻辑 (L1提炼/L2归档/L3画像/经验/检索)
+//       收敛为独立服务, agent 只保留薄委托 (公共 API 兼容, 外部调用点/测试不变)。
+// 设计 (对应方案「记忆升降级协调器」轻量版):
+//   - MemoryService 持有四层记忆的协调逻辑, 依赖全部注入 (llm 用 getLlm 闭包,
+//     因 reloadProviders 会热替换 agent.llm, 固定引用会过期)。
+//   - afterTurn() 是「升降级协调器」: 一轮对话落盘后, 依次触发 L2 场景归档、
+//     用户主动经验学习、L3 画像跨天刷新 —— 升降级策略集中在此, 可单独调参/替换。
+//   - 事件流 (tracer) 埋点保留, 行为与抽取前逐字节等价。
+import { info, warn } from "../utils/logger.js";
+import { logicalDay } from "../utils/store.js";
+
+// 辅助 LLM 调用短超时 (提炼/压缩/检索扩展): 模型不可用/网络不通时快速失败降级
+const AUX_LLM_TIMEOUT_MS = 10000;
+
+export class MemoryService {
+  // deps: { getLlm, facts, scenes, personaStore, experience, lifecycle, tracer }
+  constructor(deps) {
+    this.getLlm = deps.getLlm;           // () => llm (闭包, 实时取当前 provider)
+    this.facts = deps.facts;             // L1 事实库
+    this.scenes = deps.scenes;           // L2 场景
+    this.personaStore = deps.personaStore; // L3 画像
+    this.experience = deps.experience;   // 经验库
+    this.lifecycle = deps.lifecycle;     // ANS 生命周期 (进化计数)
+    this.tracer = deps.tracer;           // 结构化事件流
+    this._personaBuilt = null;           // L3 画像上次生成日期 (跨天刷新标记, 原 agent 字段)
+  }
+
+  _llm() { return this.getLlm ? this.getLlm() : null; }
+
+  // 辅助 LLM 调用前置健康探测: 模型不可用 (本地服务未运行/远端不可达) 时快速跳过
+  async _auxLlmReady() {
+    const llm = this._llm();
+    if (!llm) return false;
+    if (typeof llm.health !== "function") return true;
+    try { return await llm.health(); } catch { return false; }
+  }
+
+  // L1 提炼: 从一轮对话提取值得长期记忆的事实 (原 agent._extractMemory)
+  async extractMemory(user, assistant, existing = []) {
+    const llm = this._llm();
+    if (!llm) return [];
+    if (!(await this._auxLlmReady())) return []; // 模型不可用时跳过提炼 (退回启发式)
+    // 噪声治理: 显式跳过寒暄/无信息量/关于系统本身的元讨论
+    const sys = "你是记忆提炼器。从对话中提取值得长期记忆的关键事实、用户偏好、待办事项。只输出 JSON 数组, 每项是{content: 一句完整中文记忆}。没有值得记的返回 []。不要解释, 只输出 JSON。\n跳过以下内容: 1) 寒暄/问候/客套话; 2) 无信息量的闲聊; 3) 对助手/系统本身的元讨论与建议 (如任务描述方式、提示词建议等); 4) 已被现有记忆覆盖的内容。";
+    let userMsg = "用户: " + String(user).slice(0, 800) + "\n助手: " + String(assistant).slice(0, 800);
+    // 感知已有记忆: 若提炼结果与已有记忆含义相同/已被覆盖, 不要输出该条 (避免重复)
+    if (existing.length) {
+      userMsg += "\n\n【已有记忆】以下记忆已存在, 若你提炼的内容与其中任意一条含义相同或被其覆盖, 则不要输出该条 (避免重复):\n"
+        + existing.map((f, i) => `${i + 1}. ${f.content}`).join("\n");
+    }
+    const r = await llm.chat([
+      { role: "system", content: sys },
+      { role: "user", content: userMsg },
+    ], { timeoutMs: AUX_LLM_TIMEOUT_MS, retryMax: 0 });
+    const text = String(r.content || "").trim();
+    // 容忍模型把 JSON 包在 markdown 代码块里
+    const cleaned = text.replace(/```(?:json|JSON)?\s*/g, "").replace(/```/g, "").trim();
+    // 提取第一个最外层 JSON 数组 (贪婪匹配到最后一个 ], 容忍内容里的嵌套方括号)
+    const m = cleaned.match(/\[[\s\S]*\]/);
+    if (!m) { this.tracer?.event("memory/extract", { count: 0, reason: "no_json" }); return []; }
+    try {
+      const arr = JSON.parse(m[0]);
+      const out = Array.isArray(arr) ? arr.map((x) => String(x.content || x).trim()).filter(Boolean) : [];
+      this.tracer?.event("memory/extract", { count: out.length, existing: existing.length });
+      return out;
+    } catch { this.tracer?.event("memory/extract", { count: 0, reason: "parse_fail" }); return []; }
+  }
+
+  // L0 压缩: 用 LLM 把旧对话浓缩成语义摘要 (原 agent._summarizeMemory)
+  async summarizeMemory(raw) {
+    const llm = this._llm();
+    if (!llm) throw new Error("无 LLM");
+    if (!(await this._auxLlmReady())) throw new Error("LLM 不可用, 跳过辅助摘要");
+    const r = await llm.chat([
+      { role: "system", content: "你是记忆压缩器。把下面这段对话记录压缩成一段简洁的中文摘要(≤200字), 保留关键事实、用户偏好、进展和待办。不要客套, 直接输出摘要。" },
+      { role: "user", content: String(raw).slice(0, 4000) },
+    ], { timeoutMs: AUX_LLM_TIMEOUT_MS, retryMax: 0 });
+    this.tracer?.event("memory/summarize", { chars: String(raw).length, ok: true });
+    return r.content;
+  }
+
+  // 检索扩展: 把问题改写成多个词面变体, 补语义召回 (原 agent._expandQuery)
+  async expandQuery(q) {
+    const llm = this._llm();
+    if (!llm) return [];
+    if (!(await this._auxLlmReady())) return []; // 模型不可用时跳过扩展 (退回单查询)
+    const r = await llm.chat([
+      { role: "system", content: "你是查询扩展器。把用户的问题改写成 3 个语义相近但词面不同的检索短语(用于语义记忆检索), 每行一个, 不要序号、不要解释。" },
+      { role: "user", content: String(q).slice(0, 300) },
+    ], { timeoutMs: AUX_LLM_TIMEOUT_MS, retryMax: 0 });
+    return String(r.content || "")
+      .split(/\n+/)
+      .map((s) => s.replace(/^[\d\.\-、)）]\s*/, "").trim())
+      .filter((s) => s && s !== String(q).trim())
+      .slice(0, 3);
+  }
+
+  // L1 检索: 原始查询 + LLM 扩展变体做 RRF 融合; 无 LLM 时退化为单查询 (原 agent._memoryQuery)
+  async query(q, { limit = 5, scope = null } = {}) {
+    // 有 embedder 时走 dense 语义检索 (与 BM25 RRF 融合), 否则 LLM 扩展 + RRF
+    let hits;
+    if (this.facts.embedder) {
+      hits = this.facts.querySemantic(q, { limit, scope });
+    } else {
+      const variants = [q];
+      const llm = this._llm();
+      if (llm) {
+        try { variants.push(...(await this.expandQuery(q))); } catch { /* LLM 失败静默降级 */ }
+      }
+      hits = variants.length === 1 ? this.facts.query(q, { limit, scope }) : this.facts.queryMulti(variants, { limit, scope });
+    }
+    this.tracer?.event("memory/query", { q: String(q).slice(0, 80), hits: Array.isArray(hits) ? hits.length : 0, scope: scope || null });
+    return hits;
+  }
+
+  // L3 画像刷新: 跨天触发 (原 agent._maybeRefreshPersona, 状态 _personaBuilt 移入本服务)
+  refreshPersona() {
+    const today = logicalDay();
+    if (this._personaBuilt === today) return;
+    this._personaBuilt = today;
+    try {
+      this.personaStore.buildUserPersona(this.facts.list(), { force: true });
+      this.personaStore.buildAgentPersona(this.experience.lessons, { force: true });
+      this.tracer?.event("memory/persona", { ok: true });
+    } catch (e) {
+      warn("L3 画像生成失败:", e.message);
+      this.tracer?.event("memory/persona", { ok: false }, { error: e?.message });
+    }
+  }
+
+  // L2 场景归档: 从新记忆里找需要归档的 (原 agent._archiveScenes)
+  archiveScenes() {
+    const recent = this.facts.query("", { limit: 5 });
+    let assigned = 0;
+    for (const f of recent) {
+      if (!this.scenes.findByFactId(f.id)) { this.scenes.assign(f); assigned++; }
+    }
+    if (assigned > 0) this.tracer?.event("memory/scene_assign", { assigned });
+  }
+
+  // 用户主动经验学习: 「经验交给皮皮虾: xxx」指令 (原 agent._learnFromTurn)
+  learnFromTurn(userMsg, reply) {
+    const m = String(userMsg).match(/经验交给皮皮虾[:：]\s*(.+)/i);
+    if (m) {
+      this.experience.learn({ task: "用户主动分享", lesson: m[1], tags: ["user-shared"] });
+      if (this.lifecycle) this.lifecycle.evolve(); // 生命周期: 进化计数 (落盘)
+      this.tracer?.event("memory/learn", { lesson: m[1].slice(0, 120), source: "user-shared" });
+      info(`学到经验: ${m[1]}`);
+    }
+  }
+
+  // 升降级协调器: 一轮对话落盘后统一触发 L2 归档 + 经验学习 + L3 画像刷新
+  // (原 agent.chat persist 块里散落的三个调用, 收敛于此)
+  afterTurn(userMsg, reply) {
+    this.archiveScenes();
+    this.learnFromTurn(userMsg, reply);
+    this.refreshPersona();
+  }
+}

package/src/skills/loader.js

@@ -0,0 +1,150 @@
+// src/skills/loader.js - Skill Catalog + Loader
+// 参考 deepseek-harness 的 skill package(catalog + loader): 可枚举、可发现、可加载的技能注册表
+// 扫描 <skillsDir>/*/SKILL.md, 解析 frontmatter(name/description), 提供 list/get/loadAll
+import fs from "node:fs";
+import path from "node:path";
+
+// 解析 SKILL.md 顶部的 --- frontmatter ---
+// 支持简单 `key: value` 和 YAML 折叠块（`>` / `|`），保证多行 description 可被解析。
+export function parseFrontmatter(md) {
+  const m = md.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return {};
+  const meta = {};
+  const lines = m[1].split(/\r?\n/);
+  let key = null;
+  let block = null;
+  let blockLines = [];
+  const flush = () => {
+    if (key && block) {
+      meta[key] = block === ">"
+        ? blockLines.join(" ").replace(/\s+/g, " ").trim()
+        : blockLines.join("\n").trim();
+    }
+    key = null;
+    block = null;
+    blockLines = [];
+  };
+  for (const line of lines) {
+    const mm = line.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
+    if (mm) {
+      flush();
+      key = mm[1];
+      const val = mm[2].trim();
+      if (val === ">" || val === "|") {
+        block = val;
+      } else {
+        meta[key] = val;
+        key = null;
+      }
+    } else if (block && key) {
+      blockLines.push(line.trim());
+    }
+  }
+  flush();
+  return meta;
+}
+
+// 解析 SKILL.md 正文章节: "## 标题" -> 内容
+// 供按需加载 (渐进式披露): agent 可只读「反合理化」「验证」等特定段, 不用整篇读入
+export function parseSections(md) {
+  const sections = {};
+  const lines = String(md || "").split(/\r?\n/);
+  let cur = null;
+  for (const line of lines) {
+    const m = line.match(/^##\s+(.+)$/);
+    if (m) { cur = m[1].trim(); sections[cur] = ""; continue; }
+    if (cur) sections[cur] += line + "\n";
+  }
+  for (const k of Object.keys(sections)) sections[k] = sections[k].trim();
+  return sections;
+}
+
+export class SkillLoader {
+  constructor(skillsDir) {
+    this.dir = skillsDir;
+    // 技能使用追踪 (source: Hermes "skill self-improves during use")
+    this.usageFile = path.join(skillsDir, ".usage.json");
+    this._usage = this._readUsage();
+  }
+
+  _scan() {
+    if (!fs.existsSync(this.dir)) return {};
+    const out = {};
+    for (const entry of fs.readdirSync(this.dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillMd = path.join(this.dir, entry.name, "SKILL.md");
+      if (!fs.existsSync(skillMd)) continue;
+      const raw = fs.readFileSync(skillMd, "utf8");
+      const meta = parseFrontmatter(raw);
+      out[entry.name] = {
+        id: entry.name,
+        name: meta.name || entry.name,
+        description: meta.description || "",
+        dir: path.join(this.dir, entry.name),
+        path: skillMd,
+      };
+    }
+    return out;
+  }
+
+  // 可枚举: 全部技能
+  list() {
+    return Object.values(this._scan());
+  }
+
+  // 可发现: 按 id 查
+  get(id) {
+    return this._scan()[id] || null;
+  }
+
+  has(id) {
+    return !!this._scan()[id];
+  }
+
+  // 读取某个技能的完整 SKILL.md 内容
+  read(id) {
+    const s = this.get(id);
+    if (!s) return null;
+    return fs.readFileSync(s.path, "utf8");
+  }
+
+  // 按需读取某个技能的指定章节 (渐进式披露: 只读「反合理化」「验证」等段, 省 token)
+  readSection(id, section) {
+    const raw = this.read(id);
+    if (raw === null) return null;
+    const sections = parseSections(raw);
+    return sections[section] ?? null;
+  }
+
+  _readUsage() {
+    try { if (fs.existsSync(this.usageFile)) { const d = JSON.parse(fs.readFileSync(this.usageFile, "utf8")); if (d && typeof d === "object") return d; } } catch {}
+    return {};
+  }
+
+  _saveUsage() {
+    try { fs.writeFileSync(this.usageFile, JSON.stringify(this._usage, null, 2), "utf8"); } catch {}
+  }
+
+  // 记录一次技能使用 (load_skill 时调用)
+  trackUse(id) {
+    this._usage = this._readUsage();
+    const u = this._usage[id] || { uses: 0, lastUsed: null };
+    u.uses = (u.uses || 0) + 1;
+    u.lastUsed = new Date().toISOString();
+    this._usage[id] = u;
+    this._saveUsage();
+    return u;
+  }
+
+  // 某技能使用统计
+  useOf(id) { const u = this._readUsage()[id]; return u ? { uses: u.uses || 0, lastUsed: u.lastUsed || null } : { uses: 0, lastUsed: null }; }
+
+  // 全部技能使用统计
+  usageAll() { return this._readUsage(); }
+
+  // 重置某技能使用计数 (用中自进化升级完成后调用, 防连跑)
+  resetUse(id) {
+    this._usage = this._readUsage();
+    if (this._usage[id]) { this._usage[id].uses = 0; this._usage[id].lastUpgraded = new Date().toISOString(); this._saveUsage(); }
+  }
+}

package/src/skills/verify.js

@@ -0,0 +1,100 @@
+// src/skills/verify.js - 技能入库前确定性验证闸门
+// 背景 (DeepSeek-Harness 自进化四拼图之「可靠验证」):
+//   refineSkill 由 LLM 提炼技能后直接 create_skill 落盘, 无独立验收环节 —
+//   「完成是自报的, 没有独立验收者」。这会让半成品/幻觉技能污染 skills/。
+//   本模块提供确定性验收 (不依赖 LLM, 静态可测, 缺一即拒):
+//   - 结构验收: SKILL.md 必须含 ## 流程 + ## 验证
+//   - 落地接地: 内容必须真实引用提炼它的高频工具, 且该工具确有 ≥minFreq 条近期成功轨迹
+//   - held-out 回归: (P0② Self-Harness) 若提供 heldOutTraces, 要求接地工具在未见过的子集也有背书, 防过拟合
+// 用法: verifySkill({ name, content, hotTools, okTraces, minFreq, heldOutTraces })
+//   -> { ok: boolean, reason?: string, matchedTool?, traceCount?, heldOutCount? }
+
+// 结构验收: 验收必需段落 (create_skill 契约为 流程/反合理化/验证; 至少 流程+验证 缺一不可)
+export function requiredSections(content) {
+  const c = String(content || "");
+  const need = ["## 流程", "## 验证"];
+  const missing = need.filter((s) => !c.includes(s));
+  return {
+    ok: missing.length === 0,
+    missing,
+    hasFlow: c.includes("## 流程"),
+    hasVerify: c.includes("## 验证"),
+  };
+}
+
+// 落地接地: 技能内容是否真实基于提炼它的高频工具 (反幻觉)
+export function groundedInTools(content, hotTools = []) {
+  const c = String(content || "");
+  const names = (Array.isArray(hotTools) ? hotTools : []).filter(Boolean);
+  if (names.length === 0) return { ok: false, reason: "无高频工具可核对" };
+  const hit = names.find((t) => c.toLowerCase().includes(String(t).toLowerCase()));
+  return { ok: !!hit, matchedTool: hit || null, hotTools: names.slice(0, 5) };
+}
+
+// 轨迹接地: 该工具确有 ≥minFreq 条近期成功轨迹
+export function traceBacked(tool, okTraces = [], minFreq = 2) {
+  const arr = Array.isArray(okTraces) ? okTraces : [];
+  if (!tool) return { ok: false, reason: "无工具名" };
+  const n = arr.filter((t) => t && String(t.tool) === tool).length;
+  return { ok: n >= minFreq, count: n, minFreq, tool };
+}
+
+// held-out 回归闸门 (Self-Harness: 候选改动必须在 held-out 子集也不退化才合并)
+// 用途: refineSkill 提炼的技能若只在训练轨迹接地、在未见过的 held-out 轨迹里不接地 = 过拟合 → 拒
+export function verifyHeldOut({ tool, heldOutTraces = [], minFreq = 2 } = {}) {
+  const need = Math.max(1, Math.floor(minFreq / 2));
+  if (!tool) return { ok: false, reason: "无工具名", need };
+  const n = (Array.isArray(heldOutTraces) ? heldOutTraces : []).filter((t) => t && String(t.tool) === tool).length;
+  return { ok: n >= need, count: n, need, tool };
+}
+
+// 总闸门
+export function verifySkill({ name, content, hotTools, okTraces, minFreq = 2, heldOutTraces } = {}) {
+  // 1. 结构验收
+  const s = requiredSections(content);
+  if (!s.ok) {
+    return { ok: false, reason: `技能缺必需段落: ${s.missing.join(", ")} (SKILL.md 契约要求 ## 流程 + ## 验证)` };
+  }
+  // 内容太短 (只够段落标题没实质步骤) 也拒
+  const body = String(content || "").replace(/##\s*\S+/g, "").trim();
+  if (body.length < 20) {
+    return { ok: false, reason: "技能内容太短, 缺实质步骤/检查点" };
+  }
+  // 2. 落地接地: 内容引用高频工具
+  const g = groundedInTools(content, hotTools);
+  if (!g.ok) {
+    return { ok: false, reason: `技能内容未引用提炼它的高频工具 (${g.hotTools.join(", ")})` };
+  }
+  // 3. 轨迹接地: 该工具有足够近期成功轨迹背书
+  const tb = traceBacked(g.matchedTool, okTraces, minFreq);
+  if (!tb.ok) {
+    return { ok: false, reason: `工具 ${g.matchedTool} 成功轨迹不足 (${tb.count}/${tb.minFreq})` };
+  }
+  // 4. held-out 回归: 若提供, 要求接地工具在 held-out 子集也有 ≥ceil(minFreq/2) 条成功轨迹背书 (防过拟合训练集)
+  if (heldOutTraces && Array.isArray(heldOutTraces)) {
+    const ho = verifyHeldOut({ tool: g.matchedTool, heldOutTraces, minFreq });
+    if (!ho.ok) {
+      return { ok: false, reason: `工具 ${g.matchedTool} held-out 回归轨迹不足 (${ho.count}/${ho.need}), 疑似过拟合训练集` };
+    }
+  }
+  return { ok: true, matchedTool: g.matchedTool, traceCount: tb.count, heldOutCount: (heldOutTraces && Array.isArray(heldOutTraces)) ? traceBacked(g.matchedTool, heldOutTraces, 1).count : null };
+}
+
+// 技能升级专用验收 (用中自进化): 不重新做 grounding (创建时已接地验证),
+// 重点防止退化: 缺段落 / 正文缩水 / 变空。返回 { ok, reason, changed }
+export function verifyUpgradeSkill({ content, prevContent }) {
+  const c = String(content || "").replace(/^---[\s\S]*?---\s*/, ""); // 剥 frontmatter (skills.read 返回 ---meta--- 全文)
+  const p = String(prevContent || "").replace(/^---[\s\S]*?---\s*/, "");
+  // 1. 结构验收 (必须仍含 流程+验证)
+  const s = requiredSections(c);
+  if (!s.ok) return { ok: false, reason: "升级版缺必需段落: " + s.missing.join(", ") };
+  // 2. 正文不缩水 (去段落标题后比旧版短 = 退化)
+  const bodyNow = c.replace(/##\s*\S+/g, "").trim();
+  const bodyPrev = p.replace(/##\s*\S+/g, "").trim();
+  if (bodyNow.length < 20) return { ok: false, reason: "升级版内容太短" };
+  if (bodyPrev.length && bodyNow.length < bodyPrev.length * 0.6) {
+    return { ok: false, reason: "升级版正文缩水 (" + bodyNow.length + "<" + Math.ceil(bodyPrev.length * 0.6) + "), 疑似退化" };
+  }
+  const changed = bodyNow !== bodyPrev;
+  return { ok: true, changed };
+}