ppxans-harness 2.4.0

package/src/memory/canvas.js

@@ -0,0 +1,131 @@
+// src/memory/canvas.js - 符号画布记忆 (P2⑥)
+// 吸收 TencentDB-Agent-Memory 的"符号化记忆"设计思想:
+//   长任务上下文只放轻量 Mermaid 状态图 (节点=步骤, 边=状态转移, node_id=事件 seq),
+//   细节按 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";
+
+export const CANVAS_DEFAULTS = { minSteps: 8, maxNodes: 30, maxEdges: 40 };
+
+// ---- 从 trace 事件行归纳状态图 (纯函数) ----
+// lines: trace.js 事件原始行 (已 JSON.parse 的数组)
+// 返回 { nodes: [{id,label,kind}], edges: [{from,to,label}], startedAt, endedAt, steps }
+export function buildCanvasFromEvents(events = [], opts = {}) {
+  const { maxNodes = CANVAS_DEFAULTS.maxNodes, maxEdges = CANVAS_DEFAULTS.maxEdges } = opts;
+  const nodes = [];
+  const edges = [];
+  const nodeById = new Map();
+  let steps = 0;
+  let startedAt = null;
+  let endedAt = null;
+  let lastNodeId = null;
+
+  const ensureNode = (id, label, kind) => {
+    if (nodeById.has(id)) return nodeById.get(id);
+    const n = { id, label: String(label || id).slice(0, 60), kind: kind || "step" };
+    nodes.push(n);
+    nodeById.set(id, n);
+    return n;
+  };
+
+  const addEdge = (from, to, label) => {
+    if (edges.length >= maxEdges) return;
+    edges.push({ from, to, label: String(label || "").slice(0, 40) });
+  };
+
+  for (const ev of events) {
+    if (!ev || !ev.evt) continue;
+    const seq = ev.seq != null ? "evt-" + ev.seq : null;
+    if (ev.evt === "turn/start") {
+      startedAt = ev.ts || startedAt;
+      const n = ensureNode(seq || "turn-start", "任务开始", "boundary");
+      lastNodeId = n.id;
+    } else if (ev.evt === "turn/end") {
+      endedAt = ev.ts || endedAt || new Date().toISOString();
+      const n = ensureNode(seq || "turn-end", ev.ok ? "任务完成" : "任务中断", "boundary");
+      if (lastNodeId) addEdge(lastNodeId, n.id, "");
+      lastNodeId = n.id;
+    } else if (ev.evt === "step/start") {
+      steps++;
+      const n = ensureNode(seq || "step-" + steps, `步骤 ${ev.round != null ? ev.round : steps}`, "step");
+      if (lastNodeId && lastNodeId !== n.id) addEdge(lastNodeId, n.id, "");
+      lastNodeId = n.id;
+    } else if (ev.evt === "step/end") {
+      const n = ensureNode(seq || "step-end-" + steps, `步骤结束 (${ev.ok ? "成功" : "失败"})`, ev.ok ? "ok" : "fail");
+      if (lastNodeId && lastNodeId !== n.id) addEdge(lastNodeId, n.id, ev.tool || "");
+      lastNodeId = n.id;
+    } else if (ev.evt === "tool/call" && ev.tool) {
+      const n = ensureNode(seq || "tool-" + steps + "-" + ev.tool, `${ev.tool}`, "tool");
+      if (lastNodeId && lastNodeId !== n.id) addEdge(lastNodeId, n.id, ev.ok === false ? "失败" : "");
+      lastNodeId = n.id;
+    }
+    if (nodes.length > maxNodes) break;
+  }
+  return { nodes, edges, steps, startedAt, endedAt };
+}
+
+// ---- Mermaid 渲染 ----
+export function toMermaid(canvas) {
+  const lines = ["graph LR"];
+  for (const n of canvas.nodes) {
+    const cls = n.kind === "boundary" ? ":::" + n.kind : (n.kind === "fail" ? ":::" + n.kind : "");
+    lines.push(`  ${n.id}["${escapeLabel(n.label)}"]${cls}`);
+  }
+  for (const e of canvas.edges) {
+    lines.push(`  ${e.from} -->|${escapeLabel(e.label)}| ${e.to}`);
+  }
+  return lines.join("\n");
+}
+
+function escapeLabel(s) {
+  return String(s || "").replace(/["[\]]/g, "").slice(0, 50);
+}
+
+// ---- 画布存储 (按天, 增量追加) ----
+export class CanvasStore {
+  constructor(dataDir) {
+    this.dir = path.join(dataDir, "memory", "canvas");
+    ensureDir(this.dir);
+  }
+
+  _file(day = logicalDay()) { return path.join(this.dir, `${day}.json`); }
+
+  // 保存某天画布 (整体覆盖当天, 画布是归纳视图非 append-only)
+  save(canvas, { day = logicalDay() } = {}) {
+    const payload = { day, updatedAt: Date.now(), ...canvas };
+    writeText(this._file(day), JSON.stringify(payload, null, 2));
+    return payload;
+  }
+
+  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; }
+  }
+
+  // 从 trace 事件自动生成并保存 (若步骤数达标); 返回 null 表示未触发
+  async captureFromEvents(events, { minSteps = CANVAS_DEFAULTS.minSteps } = {}) {
+    const canvas = buildCanvasFromEvents(events);
+    if (canvas.steps < minSteps) return null;
+    return this.save(canvas);
+  }
+}
+
+// ---- 上下文注入片段: 只有画布 + 最近细节, 省 token ----
+export function renderCanvasContext(canvas, { detailLines = 3 } = {}) {
+  if (!canvas || !canvas.nodes || !canvas.nodes.length) return "";
+  const mermaid = toMermaid(canvas);
+  const tail = canvas.nodes.slice(-detailLines).map((n) => `- ${n.id}: ${n.label}`).join("\n");
+  return `\n# 任务画布 (符号化)
+${mermaid}
+
+最近节点: 
+${tail}
+(需细节时用 node_id 取事件日志原文)
+`;
+}
+
+export default CanvasStore;

package/src/memory/compaction.js

@@ -0,0 +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");
+}

package/src/memory/experience.js

@@ -0,0 +1,122 @@
+// src/memory/experience.js - 经验库 (自学习)
+// 从每次任务结果中提炼经验, 供后续任务参考 (参考 openhanako experience)
+// 跨 agent 共享: 支持全局经验目录 (globalDataDir), 写入用文件锁防并发覆盖
+// v1.0.7: 同义经验相似合并 (bigram overlap, 词序/措辞变体命中合并而非新增)
+import path from "node:path";
+import { ensureDir, readJson, writeJson, nowISO, withFileLock } from "../utils/store.js";
+
+// 同义合并阈值: 经验 lesson 的 bigram overlap 达到此值视为同一条
+// 用真实生产变体校准: 同义改写 0.50-0.55, 相关但不同 0.29, 不相关 0.0 → 0.5 能抓同义不误伤
+const SIM_THRESHOLD = 0.5;
+
+// bigram 集合 (去空白, 中文按字符)
+function _bigrams(s) {
+  const chars = Array.from(String(s).replace(/\s+/g, ""));
+  const out = new Set();
+  for (let i = 0; i < chars.length - 1; i++) out.add(chars[i] + chars[i + 1]);
+  return out;
+}
+
+// overlap 系数: 交集 / 较短者 bigram 数 (对词序变化容忍, 与 FactStore._overlap 同思路)
+export function lessonOverlap(a, b) {
+  const A = _bigrams(a), B = _bigrams(b);
+  if (!A.size || !B.size) return 0;
+  let inter = 0;
+  for (const x of A) if (B.has(x)) inter++;
+  return inter / Math.min(A.size, B.size);
+}
+
+// 模板句判定: 去掉数字后完全相同 (如 "A 经验教训 0" vs "A 经验教训 1")
+// 这类"仅编号不同"的条目是不同内容, 不参与同义合并 (防误伤)
+function _isTemplateLike(a, b) {
+  return String(a).replace(/\d+/g, "#") === String(b).replace(/\d+/g, "#");
+}
+
+export class Experience {
+  constructor(dataDir) {
+    this.dir = path.join(dataDir, "experience");
+    ensureDir(this.dir);
+    this.file = path.join(this.dir, "lessons.json");
+    this.lessons = readJson(this.file, []);
+  }
+
+  learn({ task, outcome, lesson, tags = [] }) {
+    const entry = {
+      id: "e_" + Math.random().toString(36).slice(2, 10),
+      task: String(task || "").slice(0, 300),
+      outcome: String(outcome || "").slice(0, 300),
+      lesson: String(lesson || "").slice(0, 500),
+      tags,
+      ts: nowISO(),
+      uses: 0,
+    };
+    if (!entry.lesson || entry.lesson.length < 5) return null;
+    // 内容去重: 同一 lesson 已存在则命中加分 (uses+1) 而非新增, 防高频学习路径写放大
+    // 归一化: 去首尾空白 + 折叠连续空白 (与 FactStore._norm 同策略)
+    const normKey = String(lesson).trim().replace(/\s+/g, " ");
+    // 锁内读-改-写: 防止多 agent 共享经验库时并发覆盖
+    return withFileLock(this.file, () => {
+      this.lessons = readJson(this.file, []);
+      const existing = this.lessons.find((l) => String(l.lesson || "").trim().replace(/\s+/g, " ") === normKey);
+      if (existing) {
+        existing.uses += 1;
+        existing.ts = nowISO(); // 刷新时间, 让近期命中经验排到 context 前面
+        writeJson(this.file, this.lessons);
+        return existing;
+      }
+      // 同义合并 (v1.0.7): 措辞/词序不同的变体 (逃过精确去重) 语义相似时合并, 防同义经验堆积
+      // 排除"仅编号不同"的模板句 (如 A 经验教训 0/1 → 视为不同条目)
+      const similar = this.lessons.find((l) => {
+        const la = String(l.lesson || "");
+        if (_isTemplateLike(la, entry.lesson)) return false;
+        return lessonOverlap(la, entry.lesson) >= SIM_THRESHOLD;
+      });
+      if (similar) {
+        similar.uses += 1;
+        similar.ts = nowISO();
+        writeJson(this.file, this.lessons);
+        return similar;
+      }
+      this.lessons.push(entry);
+      this._prune();
+      writeJson(this.file, this.lessons);
+      return entry;
+    });
+  }
+
+  recall(taskDesc) {
+    const q = String(taskDesc || "").toLowerCase();
+    const scored = this.lessons
+      .map((l) => {
+        let s = 0;
+        const hay = (l.lesson + " " + l.task + " " + l.tags.join(" ")).toLowerCase();
+        if (q && hay.includes(q)) s += 10;
+        if (l.uses > 0) s += Math.min(l.uses, 5);
+        return { ...l, score: s };
+      })
+      .filter((l) => l.score > 0)
+      .sort((a, b) => b.score - a.score);
+    return scored.slice(0, 5);
+  }
+
+  use(id) {
+    withFileLock(this.file, () => {
+      this.lessons = readJson(this.file, []);
+      const l = this.lessons.find((x) => x.id === id);
+      if (l) { l.uses += 1; writeJson(this.file, this.lessons); }
+    });
+  }
+
+  _prune() {
+    // 最多保留 200 条
+    if (this.lessons.length > 200) {
+      this.lessons.sort((a, b) => b.uses - a.uses);
+      this.lessons = this.lessons.slice(0, 200);
+    }
+  }
+
+  context() {
+    const recent = [...this.lessons].sort((a, b) => new Date(b.ts) - new Date(a.ts)).slice(0, 5);
+    return recent.map((l) => `- 经验: ${l.lesson}`).join("\n") || "(暂无经验)";
+  }
+}