ppxans-harness 2.4.0

package/src/memory/failure-episode.js

@@ -0,0 +1,99 @@
+// src/memory/failure-episode.js - 故障记忆 (P1⑥)
+// 吸收 ReLoop / Vial / Aegis 的"故障即知识"设计:
+//   每次失败存结构化 episode (错误类型/根因/修复/置信度), 下次相似故障检索历史辅助诊断, 自愈不再从零推理。
+// 与经验库 (Experience, L4) 互补: 经验库是"学到的教训", 本模块是"故障的结构化病历" (可检索、可回放)。
+// 纯代码可测, 检索用词法相似 (零依赖), 可升级 embedding。
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir, writeText } from "../utils/store.js";
+import { lexicalSimilarity } from "../evolve/playbook.js";
+
+export const FAILURE_CATEGORY = ["throttle", "network", "validation", "auth", "unknown"];
+
+export class FailureEpisodeStore {
+  constructor(dataDir, { maxEpisodes = 500 } = {}) {
+    this.dir = path.join(dataDir, "memory", "failures");
+    ensureDir(this.dir);
+    this.file = path.join(this.dir, "episodes.json");
+    this.maxEpisodes = maxEpisodes;
+    this._episodes = this._load();
+  }
+
+  _load() {
+    try {
+      if (fs.existsSync(this.file)) {
+        const d = JSON.parse(fs.readFileSync(this.file, "utf8"));
+        if (Array.isArray(d)) return d;
+      }
+    } catch {}
+    return [];
+  }
+
+  _save() {
+    writeText(this.file, JSON.stringify(this._episodes, null, 2));
+  }
+
+  // 记录一次失败 episode
+  // { tool, error, category, rootCause, fix, confidence, traceRef }
+  record(ep) {
+    const e = {
+      id: "fe" + Date.now().toString(36) + Math.random().toString(36).slice(2, 5),
+      tool: ep.tool || "unknown",
+      error: String(ep.error || "").slice(0, 500),
+      category: FAILURE_CATEGORY.includes(ep.category) ? ep.category : "unknown",
+      rootCause: String(ep.rootCause || "").slice(0, 500) || null,
+      fix: String(ep.fix || "").slice(0, 500) || null,
+      confidence: Number(ep.confidence) || 0,
+      traceRef: ep.traceRef || null,   // 事件日志引用 (trace.js 行号/seq)
+      hit: 0,                          // 被检索命中次数 (元学习信号)
+      ts: Date.now(),
+    };
+    this._episodes.unshift(e);
+    if (this._episodes.length > this.maxEpisodes) this._episodes = this._episodes.slice(0, this.maxEpisodes);
+    this._save();
+    return e;
+  }
+
+  // 相似故障检索: 按 错误文本 + 工具名 词法相似度排序, 返回 top N
+  search({ tool = null, error = "", limit = 3, minScore = 0.25 } = {}) {
+    const q = String(error || "");
+    const scored = this._episodes
+      .map((e) => {
+        let score = 0;
+        if (q) score = Math.max(score, lexicalSimilarity(e.error, q));
+        if (tool && e.tool === tool) score = Math.max(score, 0.5); // 同工具强信号
+        if (e.rootCause && q) score = Math.max(score, lexicalSimilarity(e.rootCause, q) * 0.8);
+        return { ...e, score };
+      })
+      .filter((e) => e.score >= minScore)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit);
+    // 命中计数 (元学习): 写回原 episode, 不只是副本
+    for (const s of scored) {
+      const orig = this._episodes.find((x) => x.id === s.id);
+      if (orig) { orig.hit++; s.hit = orig.hit; }
+    }
+    if (scored.length) this._save();
+    return scored;
+  }
+
+  // 统计: 按类别分布 / 命中率
+  stats() {
+    const byCat = {};
+    for (const e of this._episodes) byCat[e.category] = (byCat[e.category] || 0) + 1;
+    const withFix = this._episodes.filter((e) => e.fix).length;
+    const totalHit = this._episodes.reduce((a, e) => a + e.hit, 0);
+    return {
+      total: this._episodes.length,
+      byCategory: byCat,
+      withFix: withFix,
+      fixRate: this._episodes.length ? (withFix / this._episodes.length * 100).toFixed(1) + "%" : "0%",
+      totalHits: totalHit,
+    };
+  }
+
+  list(limit = 20) { return this._episodes.slice(0, limit); }
+  clear() { this._episodes = []; this._save(); }
+}
+
+export default FailureEpisodeStore;

package/src/memory/fork.js

@@ -0,0 +1,83 @@
+// src/memory/fork.js - 会话 fork 基线 (P2⑦)
+// 吸收 HanaAgent 的 fork baseline 设计思想:
+//   子代理 spawn 时携带记忆基线快照 (L1 facts + L3 persona + 经验精选), 子任务结束按结果 merge 或 discard。
+// 皮皮虾自研实现: 主 agent 记忆导出为子 dataDir 可读的快照文件, 子 agent 独立演进,
+//   结束后可选 merge 回主记忆 (去重) 或丢弃 (隔离)。纯代码, 无 LLM 参与 merge 决策。
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir, writeText, readText } from "../utils/store.js";
+import { lexicalSimilarity } from "../evolve/playbook.js";
+
+// 从主 agent 导出记忆快照到子 dataDir
+// 快照内容: L1 facts (top N) + L3 persona (若存在) + 全局经验精选 (top M)
+// 返回 { wrote: {facts, persona, experience}, path }
+export function exportMemorySnapshot({ agent, toDataDir, factsLimit = 50, experienceLimit = 10 } = {}) {
+  if (!agent) return { wrote: {}, path: null };
+  const snapDir = path.join(toDataDir, "memory", "snapshot");
+  ensureDir(snapDir);
+  const wrote = {};
+
+  // L1 facts: 取衰减分 top N (事实快照)
+  try {
+    if (agent.facts && typeof agent.facts.query === "function") {
+      const top = agent.facts.query("", { limit: factsLimit });
+      const lines = top.map((f) => `- [${Math.round(f.score * 100)}] ${f.content}`).join("\n") || "(无)";
+      writeText(path.join(snapDir, "facts.md"), `# L1 事实快照 (fork 基线)\n${lines}\n`);
+      wrote.facts = top.length;
+    }
+  } catch {}
+
+  // L3 persona: 主 agent 画像
+  try {
+    if (agent.personaStore && typeof agent.personaStore.read === "function") {
+      const p = agent.personaStore.read();
+      if (p) {
+        writeText(path.join(snapDir, "persona.md"), String(p));
+        wrote.persona = true;
+      }
+    }
+  } catch {}
+
+  // 全局经验精选
+  try {
+    if (agent.experience && typeof agent.experience.list === "function") {
+      const list = agent.experience.list({ limit: experienceLimit });
+      if (list && list.length) {
+        const lines = list.map((e) => `- ${e.lesson || e.content || ""}`).join("\n");
+        writeText(path.join(snapDir, "experience.md"), `# 经验快照 (fork 基线)\n${lines}\n`);
+        wrote.experience = list.length;
+      }
+    }
+  } catch {}
+
+  return { wrote, path: snapDir };
+}
+
+// 子任务完成后 merge 回主记忆 (按内容去重, 冲突保留主记忆)
+// 返回 { merged: n, skipped: n }
+export function mergeSnapshotBack({ agent, fromDataDir, dryRun = false } = {}) {
+  const snapDir = path.join(fromDataDir, "memory", "snapshot");
+  const factsFile = path.join(snapDir, "facts.md");
+  let merged = 0;
+  let skipped = 0;
+  if (!agent || !agent.facts || !fs.existsSync(factsFile)) return { merged: 0, skipped: 0 };
+  const text = readText(factsFile) || "";
+  const lines = text.split("\n").filter((l) => /^- \[/.test(l));
+  for (const l of lines) {
+    const content = l.replace(/^- \[\d+\]\s*/, "").trim();
+    if (!content) continue;
+    // 精确/高度词法相似才判定重复 (BM25 分数不可靠: 短查询常命中不相关事实)
+    const dup = (agent.facts.query(content, { limit: 3 }) || []).find((f) => lexicalSimilarity(f.content, content) > 0.8);
+    if (dup) { skipped++; continue; }
+    if (!dryRun) agent.facts.add(content, { source: "fork-merge", similarThreshold: 0.8 });
+    merged++;
+  }
+  return { merged, skipped };
+}
+
+// 便捷: 判断某 dataDir 是否带快照
+export function hasSnapshot(dataDir) {
+  return fs.existsSync(path.join(dataDir, "memory", "snapshot", "facts.md"));
+}
+
+export default { exportMemorySnapshot, mergeSnapshotBack, hasSnapshot };

package/src/memory/index.js

@@ -0,0 +1,7 @@
+// src/memory/index.js - 记忆系统统一出口 (v0.3 四层架构)
+export { FactStore } from "./fact-store.js";
+export { MemoryTicker } from "./memory-ticker.js";
+export { Experience } from "./experience.js";
+export { L0Recorder } from "./l0.js";
+export { SceneStore } from "./l2.js";
+export { PersonaStore } from "./l3.js";

package/src/memory/l0.js

@@ -0,0 +1,52 @@
+// src/memory/l0.js - L0 原始对话记录 (腾讯风格)
+// 架构: 会话事件日志 (SessionStore) 为唯一事实源, L0 是其只读派生视图
+// 不再独立维护 l0/*.jsonl -- 对话原文由 session 事件日志全量保存, 消除 today/l0/facts 三处重复
+// 过滤噪音: 短消息/命令/注入标签 (保留, 用于判断"是否值得记录")
+import path from "node:path";
+import { ensureDir, logicalDay } from "../utils/store.js";
+import { SessionStore, EVENTS } from "./session.js";
+
+// 短消息/命令/噪音过滤
+function shouldCapture(content) {
+  const c = String(content || "").trim();
+  if (!c) return false;
+  if (c.length < 2) return false;                       // 太短
+  if (/^(\/|!|\.)/.test(c)) return false;               // 命令
+  if (c.length < 3) return false;                           // 太短(含2字寒暄)
+  if (["你好","您好","在吗","哈喽","拜拜","再见","晚安","早上好","下午好","晚上好"].includes(c)) return false; // 纯寒暄
+  if (/\b(hi|hello|ok|thanks)\b/i.test(c) && c.length < 8) return false;
+  return true;
+}
+
+export class L0Recorder {
+  // 兼容两种构造: (sessionStore[, dataDir]) 或 (dataDir) -- 后者内部新建 SessionStore
+  constructor(sessionStoreOrDir, dataDir) {
+    if (sessionStoreOrDir && typeof sessionStoreOrDir.eventsByDay === "function") {
+      this.sessionStore = sessionStoreOrDir;
+      this.dir = dataDir ? path.join(dataDir, "memory", "l0") : null;
+    } else {
+      const dir = sessionStoreOrDir;
+      this.sessionStore = new SessionStore(dir);
+      this.dir = path.join(dir, "memory", "l0");
+    }
+    if (this.dir) { try { ensureDir(this.dir); } catch {} }
+  }
+
+  // 记录: 代理到 session 事件日志 (session 是唯一事实源, 不再独立写 JSONL)
+  record({ role, content, sessionKey = "default" } = {}) {
+    if (!shouldCapture(content)) return null;
+    const type = role === "assistant" ? EVENTS.ASSISTANT : EVENTS.USER;
+    return this.sessionStore.append(sessionKey, type, { content: String(content).slice(0, 4000) });
+  }
+
+  // 读取某天的对话 (从 session 事件按天派生, 最近 N 条)
+  read(day = logicalDay(), limit = 50) {
+    return this.sessionStore.eventsByDay(day)
+      .map((r) => ({ role: r.role, content: r.content, sessionKey: r.sessionKey, timestamp: r.timestamp }))
+      .slice(-limit);
+  }
+
+  count() {
+    return this.sessionStore.eventsByDay(logicalDay()).length;
+  }
+}

package/src/memory/l2.js

@@ -0,0 +1,131 @@
+// src/memory/l2.js - L2 场景记忆 (腾讯风格 scene extraction)
+// 把相关记忆归档成场景: { name, keywords, facts[], lastUpdated }
+// 零依赖: 用关键词聚类 + 时间窗聚合
+import path from "node:path";
+import { ensureDir, readJson, writeJson, logicalDay, withFileLock } from "../utils/store.js";
+
+// 中文简单分词: 提取有意义的词 (2字以上连续片段 + 已知高频概念)
+const STOP = new Set(["这个","那个","我们","你们","他们","什么","怎么","可以","一个","就是","知道","没有","如果","因为","所以","但是","然后","现在","今天","昨天","明天","已经","还有","所有","这样","那样","自己","的时候","一下","一点","一些","这些","那些","东西","事情","问题","觉得","应该","需要","开始","继续","大家","真的","只是","可能","不是","都是","一直","非常","其实","最后","主要","联系","关系"]);
+
+function tokenize(text) {
+  const clean = String(text || "").replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, " ");
+  const words = clean.split(/\s+/).filter(Boolean);
+  const cjk = clean.match(/[\u4e00-\u9fa5]{2,4}/g) || [];
+  return [...new Set([...words, ...cjk.map((w) => w.toLowerCase())].filter((w) => !STOP.has(w) && w.length >= 2))];
+}
+
+export class SceneStore {
+  constructor(dataDir) {
+    this.dir = path.join(dataDir, "memory", "l2");
+    ensureDir(this.dir);
+    this.file = path.join(this.dir, "scenes.json");
+    this.scenes = readJson(this.file, []);
+  }
+
+  // 把一条事实归入最匹配的场景 (或新建)
+  assign(fact) {
+    const tokens = tokenize(fact.content);
+    if (!tokens.length) return null;
+
+    // 找最匹配的场景
+    let best = null, bestScore = 0;
+    for (const s of this.scenes) {
+      let score = 0;
+      for (const t of tokens) if ((s.keywords || []).includes(t)) score++;
+      if (score > bestScore) { bestScore = score; best = s; }
+    }
+
+    if (best && bestScore >= 1) {
+      best.facts.push({ id: fact.id, content: fact.content, ts: fact.created });
+      if (best.facts.length > 50) best.facts = best.facts.slice(-50);
+      best.lastUpdated = logicalDay();
+      // 合并新关键词
+      for (const t of tokens) if (!best.keywords.includes(t)) best.keywords.push(t);
+      if (best.keywords.length > 30) best.keywords = best.keywords.slice(-30);
+    } else {
+      best = {
+        id: "s_" + Math.random().toString(36).slice(2, 8),
+        name: tokens.slice(0, 3).join("·"),
+        keywords: tokens.slice(0, 10),
+        facts: [{ id: fact.id, content: fact.content, ts: fact.created }],
+        mode: "auto",
+        description: tokens.slice(1, 4).join("、") || "自动场景",
+        canHelp: "基于该话题的对话与记忆提供帮助",
+        created: logicalDay(),
+        lastUpdated: logicalDay(),
+      };
+      this.scenes.push(best);
+    }
+    // v1.0.9: 写盘加文件锁 (防军团多进程共享 dataDir 时写交错)
+    return withFileLock(this.file, () => {
+      writeJson(this.file, this.scenes);
+      return best;
+    });
+  }
+
+  // 手动创建场景 (用户设定人设/能力, 类似灵魂文件)
+  create({ name, description, canHelp, keywords = [] }) {
+    const scene = {
+      id: "s_" + Math.random().toString(36).slice(2, 8),
+      name: String(name || "").slice(0, 50),
+      keywords: keywords.slice(0, 15),
+      facts: [],
+      mode: "manual",
+      description: String(description || "").slice(0, 300),
+      canHelp: String(canHelp || "").slice(0, 300),
+      created: logicalDay(),
+      lastUpdated: logicalDay(),
+    };
+    this.scenes.push(scene);
+    this._save();
+    return scene;
+  }
+
+  // 列出所有场景 (含介绍)
+  listWithDesc() {
+    return this.scenes.map((s) => ({
+      id: s.id, name: s.name, mode: s.mode || "auto",
+      description: s.description || "", canHelp: s.canHelp || "",
+      facts: (s.facts || []).length, lastUpdated: s.lastUpdated,
+    }));
+  }
+
+  // 按文本匹配激活场景 (关键词命中)
+  findMatch(text) {
+    const tokens = tokenize(text);
+    if (!tokens.length) return null;
+    let best = null, bestScore = 0;
+    for (const s of this.scenes) {
+      let score = 0;
+      for (const t of tokens) if ((s.keywords || []).includes(t)) score++;
+      if (score > bestScore) { bestScore = score; best = s; }
+    }
+    return bestScore >= 1 ? best : null;
+  }
+
+  // 激活场景的上下文块 (人设 + 能力)
+  activeContext(text) {
+    const s = this.findMatch(text);
+    if (!s) return "";
+    return [
+      `【当前场景:${s.name}】`,
+      s.description ? `场景介绍: ${s.description}` : "",
+      s.canHelp ? `你可以帮用户: ${s.canHelp}` : "",
+      s.mode === "manual" ? "(用户手动设定, 请遵循此场景行为)" : "",
+    ].filter(Boolean).join("\n");
+  }  // 按记忆 id 找回场景
+  findByFactId(id) {
+    return this.scenes.find((s) => s.facts.some((f) => f.id === id));
+  }
+
+  context(limit = 5) {
+    return this.scenes.slice(-limit).map((s) =>
+      `【场景:${s.name}】\n${s.facts.slice(-5).map((f) => `  - ${f.content}`).join("\n")}`
+    ).join("\n");
+  }
+
+  count() { return this.scenes.length; }
+
+  // v1.0.9: _save 加锁 (create/scene_describe 等写盘路径)
+  _save() { withFileLock(this.file, () => writeJson(this.file, this.scenes)); }
+}

package/src/memory/l3.js

@@ -0,0 +1,112 @@
+// src/memory/l3.js - L3 核心画像 (腾讯风格 persona generation)
+// 从记忆提炼: 用户画像 (user.persona.md) + agent 人格 (agent.persona.md)
+// 零依赖: 高频词统计 + 主题聚合, 输出结构化画像
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir, readText, writeText, logicalDay } from "../utils/store.js";
+
+const STOP = new Set(["这个","那个","我们","你们","他们","什么","怎么","可以","一个","就是","知道","没有","如果","因为","所以","但是","然后","现在","今天","昨天","明天","已经","还有","所有","这样","那样","自己","的东西","的事情","一下","一点","一些","这些","那些","东西","事情","问题","觉得","应该","需要","开始","继续","大家","真的","只是","可能","不是","都是","一直","非常","其实","最后","主要","联系","关系","喜欢","讨厌","不要","想要","认为"]);
+
+export class PersonaStore {
+  constructor(dataDir, { userName = "兄弟" } = {}) {
+    this.dir = path.join(dataDir, "memory", "l3");
+    ensureDir(this.dir);
+    this.userFile = path.join(this.dir, "user.persona.md");
+    this.agentFile = path.join(this.dir, "agent.persona.md");
+    this.userName = userName;
+  }
+
+  // 从一批事实提炼用户画像
+  buildUserPersona(facts, { force = false } = {}) {
+    if (!force && this._exists(this.userFile)) return this._read(this.userFile);
+    // 聚焦用户相关的记忆 (来源: 对话 / LLM提炼 / 主动记 / 手动 / 用户分享)
+    // 注: 事实的来源标记在 source 字段 (type 恒为 general), 之前按 type 过滤永远为空 -> 修正为按 source
+    const USER_SOURCES = ["conversation", "extract", "agent-self", "manual", "user-shared"];
+    const userFacts = facts.filter((f) => USER_SOURCES.includes(f.source) || USER_SOURCES.includes(f.type));
+    const interests = this._topTopics(userFacts);
+    // 记忆概要: 内容去重后取最近 10 条 (防 LLM 提炼变体/重复记忆稀释画像)
+    const uniq = this._uniqByContent(userFacts).slice(-10);
+    const md = `# ${this.userName} 的用户画像
+
+> 由皮皮虾 L3 画像引擎生成 | 更新: ${logicalDay()}
+
+## 关注主题
+${interests.length ? interests.map(([w, n]) => `- ${w} (出现${n}次)`).join("\n") : "- 暂无足够数据"}
+
+## 记忆概要
+${uniq.map((f) => `- ${f.content}`).join("\n") || "- 暂无"}
+
+## 画像版本
+- 生成时间: ${logicalDay()}
+- 数据来源: 对话记忆 + 用户主动分享
+`;
+    writeText(this.userFile, md);
+    return md;
+  }
+
+  // 提炼 agent 自身人格 (从经验/工具使用学习)
+  buildAgentPersona(lessons, { force = false } = {}) {
+    if (!force && this._exists(this.agentFile)) return this._read(this.agentFile);
+    // 学到的经验: 内容去重后取最近 10 条 (防重复经验污染自我画像)
+    const uniq = this._uniqByContent(lessons, (l) => l.lesson).slice(-10);
+    const md = `# 皮皮虾 自我画像
+
+> 从经验库自动学习 | 更新: ${logicalDay()}
+
+## 学到的经验
+${uniq.map((l) => `- ${l.lesson}`).join("\n") || "- 暂无"}
+
+## 能力画像
+- 工具: 文件操作 / 命令执行 / 搜索 / HTTP / 定时任务
+- 记忆: 四层架构 (L0对话→L1原子→L2场景→L3画像)
+- 自愈: 崩溃恢复 / 数据修复
+- 军团: 多进程并行协作
+`;
+    writeText(this.agentFile, md);
+    return md;
+  }
+
+  // 内容去重: 按归一化内容 (去空白折叠) 过滤, 保留首次出现的条目
+  _uniqByContent(items, pick = (x) => x.content) {
+    const seen = new Set();
+    const out = [];
+    for (const it of items || []) {
+      const key = String(pick(it) || "").trim().replace(/\s+/g, " ");
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      out.push(it);
+    }
+    return out;
+  }
+
+  // 读取已生成的画像 (供 agent._context 注入; 未生成返回 "")
+  userPersona() { return this._read(this.userFile); }
+  agentPersona() { return this._read(this.agentFile); }
+
+  // 可观测: L3 画像更新时间 (无文件返回 null), 供 agent.stats() 聚合
+  stats() {
+    return {
+      user_updated: this._mtime(this.userFile),
+      agent_updated: this._mtime(this.agentFile),
+    };
+  }
+
+  _mtime(f) {
+    try { return new Date(fs.statSync(f).mtime).toISOString().slice(0, 10); } catch { return null; }
+  }
+
+  _topTopics(facts) {
+    const freq = new Map();
+    for (const f of facts) {
+      const words = String(f.content).match(/[\u4e00-\u9fa5]{2,4}/g) || [];
+      for (const w of words) {
+        if (STOP.has(w)) continue;
+        freq.set(w, (freq.get(w) || 0) + 1);
+      }
+    }
+    return [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8);
+  }
+
+  _exists(f) { try { return fs.existsSync(f); } catch { return false; } }
+  _read(f) { return readText(f, ""); }
+}