ppxans-harness 2.6.0 → 3.2.0

package/skills/ppx-memory/scripts/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 "./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/skills/ppx-memory/scripts/l2.js

@@ -0,0 +1,146 @@
+// src/memory/l2.js - L2 场景记忆 (腾讯风格 scene extraction)
+// 把相关记忆归档成场景: { name, keywords, facts[], lastUpdated }
+// 零依赖: 用关键词聚类 + 时间窗聚合
+import path from "node:path";
+import { ensureDir, readJson, writeJson, logicalDay, withFileLock } from "./store.js";
+import { migrateData, writeSchema } from "./schema.js";
+
+// scenes.json 当前 schema 版本 (纯数组基线 = 1); 未来数据结构变更时 +1 并注册迁移
+export const SCENES_SCHEMA_VERSION = 1;
+
+// 中文简单分词: 提取有意义的词 (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, []);
+    // schema 版本迁移 (旁挂 .schema 文件; 数据文件保持纯数组)
+    const mig = migrateData({
+      file: this.file,
+      name: "scenes",
+      data: this.scenes,
+      currentVersion: SCENES_SCHEMA_VERSION,
+    });
+    this.scenes = mig.data;
+  }
+
+  // 关键词命中数最高的场景。命中数 0 不会成为候选, 故返回的 scene 非空 ⟺ 至少命中 1 个关键词。
+  _bestScene(tokens) {
+    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 { scene: best, score: bestScore };
+  }
+
+  // 把一条事实归入最匹配的场景 (或新建)
+  assign(fact) {
+    const tokens = tokenize(fact.content);
+    if (!tokens.length) return null;
+
+    let best = this._bestScene(tokens).scene;
+
+    if (best) {
+      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);
+      writeSchema(this.file, "scenes", SCENES_SCHEMA_VERSION);
+      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;
+    return this._bestScene(tokens).scene;
+  }
+
+  // 激活场景的上下文块 (人设 + 能力)
+  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);
+    writeSchema(this.file, "scenes", SCENES_SCHEMA_VERSION);
+  }); }
+}

package/skills/ppx-memory/scripts/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 "./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, ""); }
+}

package/skills/ppx-memory/scripts/memory-ticker.js

@@ -0,0 +1,238 @@
+// src/memory/memory-ticker.js - 记忆水位线 (参考 openhanako v4)
+// 架构: 会话事件日志 (SessionStore) 为唯一事实源; 今日视图由它派生
+// 不再独立维护 today.md 对话原文 (原 l0/session/today 三处重复, 已收敛到 session)
+// 今日视图 -> 滚动压缩 -> longterm.md (长期记忆)
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir, readText, writeText, readJson, writeJson, logicalDay } from "./store.js";
+
+const TURNS_PER_SUMMARY = 10;
+const COMPACT_THRESHOLD = 50;   // 今日事件超此条数触发滚动压缩
+const COMPACT_KEEP = 20;        // 压缩后保留的近期条数
+const COMPACT_MIN_INTERVAL_MS = 60000; // 压缩节流: 压缩后 60s 内不重复 (防每轮对话重复付 LLM 压缩成本, v1.0.7)
+
+// 派生今日视图行: 从 session 事件渲染 (role -> 中文说话人)
+function _renderLines(sessionStore, day) {
+  if (!sessionStore) return [];
+  return sessionStore.eventsByDay(day).map((r) => {
+    const who = r.role === "user" ? "用户" : "皮皮虾";
+    return `- [${new Date(r.timestamp).toISOString()}] ${who}: ${String(r.content).slice(0, 200)}`;
+  });
+}
+
+export class MemoryTicker {
+  constructor(dataDir, factStore, summarizer = null, sessionStore = null) {
+    this.summarizer = summarizer;
+    this.extractor = null; // P1#9: LLM 结构化提炼器 (agent 注入), 提取关键事实/偏好/待办
+    this.dir = path.join(dataDir, "memory");
+    ensureDir(this.dir);
+    ensureDir(path.join(this.dir, "daily"));
+    this.factStore = factStore;
+    this.sessionStore = sessionStore;   // 唯一事实源 (今日视图由它派生)
+    this.todayView = path.join(this.dir, "today.md"); // 兼容路径 (不再作为写入真相)
+    this.longtermMd = path.join(this.dir, "longterm.md");
+    this.stateFile = path.join(this.dir, "daily-state.json");
+    this.state = { day: null, turnCount: 0 };
+    this._lastCompactAt = 0; // 压缩节流时间戳 (v1.0.7)
+    this._loadState();
+    this._rollDay();
+  }
+
+  _loadState() {
+    this.state = readJson(this.stateFile, { day: null, turnCount: 0 });
+  }
+
+  _saveState() {
+    writeJson(this.stateFile, this.state);
+  }
+
+  _rollDay() {
+    const today = logicalDay();
+    if (this.state.day !== today) {
+      if (this.state.day) this._compileDaily();
+      this.state.day = today;
+      this._saveState();
+    }
+  }
+
+  // 跨天: 把上一日事件归档到 daily/ 并滚入 longterm (从 session 派生, 非 today.md)
+  _compileDaily() {
+    const day = this.state.day;
+    const lines = _renderLines(this.sessionStore, day);
+    const dailyFile = path.join(this.dir, "daily", `${day}.md`);
+    writeText(dailyFile, `# ${day}
+
+${lines.join("\n")}\n`);
+    if (lines.length) {
+      let longterm = readText(this.longtermMd) || "";
+      longterm += `\n## ${day}\n${lines.join("\n")}\n`;
+      writeText(this.longtermMd, longterm);
+    }
+  }
+
+  async recordTurn(user, assistant) {
+    this._rollDay();
+    this.state.turnCount += 1;
+    this._saveState();
+    // 对话原文已由 session 事件日志保存; 今日视图由 session 派生
+    if (this.state.turnCount % TURNS_PER_SUMMARY === 0) this._compileDaily_Rolling();
+    await this._compactIfNeeded();
+    // P1#9: 若配 LLM 提炼器且本次对话含高信号, 走结构化提炼; 否则退回启发式
+    if (this.extractor && _hasSignal(user, assistant)) {
+      try {
+        // 感知式提炼: 先检索与本次对话相关的已有记忆 (同主题 top 3), 喂给提炼器从源头去重
+        const related = String(user || "").trim()
+          ? this.factStore.query(user, { limit: 3 }).filter((f) => !(f.hits && f.hits > 5)) // 高命中已稳定, 不再重复提炼
+          : [];
+        const facts = await this.extractor(String(user || ""), String(assistant || ""), related);
+        if (facts && facts.length) {
+          // similarThreshold=0.6: LLM 提炼的字面变体 (同义不同词) 与已有事实语义相似时命中加分,
+          // 防「三件套」这类反复提炼的变体污染记忆库
+          for (const f of facts) this.factStore.add(f, { source: "extract", similarThreshold: 0.6 });
+          return;
+        }
+      } catch {}
+    }
+    if (user) this.factStore.addMemory(user);
+  }
+
+  // P1#9: 注入 LLM 结构化提炼器 (agent 调 setExtractor)
+  setExtractor(fn) { this.extractor = typeof fn === "function" ? fn : null; }
+
+  // 每 N 轮: 把今日新增事件滚动归档进 longterm (从 session 派生)
+  // v1.2.0 fix: 用游标(lastRolledDay/lastRolledSeq)只追加"本次滚动之后"的新事件,
+  // 不再每次把今日全文重复追加 —— 否则同一段对话会在 longterm 中反复出现, 加剧重复回话。
+  _compileDaily_Rolling() {
+    const today = logicalDay();
+    const st = this.state;
+    if (st.lastRolledDay !== today) { st.lastRolledDay = today; st.lastRolledSeq = 0; } // 跨天重置游标
+    const afterSeq = st.lastRolledSeq || 0;
+    const rows = [];
+    let maxSeq = afterSeq;
+    const dayEvents = this.sessionStore && typeof this.sessionStore.replayDay === "function"
+      ? this.sessionStore.replayDay(today)
+      : [];
+    for (const e of dayEvents) {
+      if (e.seq <= afterSeq) continue;
+      const who = e.type === "user/message" ? "用户" : "皮皮虾";
+      rows.push(`- [${new Date(e.ts).toISOString()}] ${who}: ${String(e.data?.content || "").slice(0, 200)}`);
+      if (e.seq > maxSeq) maxSeq = e.seq;
+    }
+    if (rows.length) {
+      let longterm = readText(this.longtermMd) || "";
+      longterm += `\n## ${today} (滚动)\n${rows.join("\n")}\n`;
+      writeText(this.longtermMd, longterm);
+    }
+    st.lastRolledSeq = maxSeq;
+    this._saveState();
+  }
+
+  // 滚动压缩: 今日事件超量时, 把最旧对话聚合压缩进 longterm, 只留近期
+  // v1.0.7 节流: 压缩后 COMPACT_MIN_INTERVAL_MS 内不重复, 防每轮对话都付 LLM 压缩成本
+  async _compactIfNeeded() {
+    const now = Date.now();
+    if (now - (this._lastCompactAt || 0) < COMPACT_MIN_INTERVAL_MS) return;
+    const lines = _renderLines(this.sessionStore, logicalDay());
+    if (lines.length < COMPACT_THRESHOLD) return;
+    const compactedLines = lines.slice(0, -COMPACT_KEEP);
+    const userMsgs = compactedLines
+      .filter((li) => li.indexOf("用户:") !== -1)
+      .map((li) => li.split("用户:")[1].trim())
+      .filter(Boolean);
+    let summary;
+    if (this.summarizer && compactedLines.length) {
+      try {
+        const raw = compactedLines.slice(0, 60).join("\n");
+        const s = await this.summarizer(raw);
+        summary = "[" + logicalDay() + " llm-summary] " + (s || "(空)");
+      } catch {
+        summary = "[" + logicalDay() + " thin] archived " + compactedLines.length + " lines (llm fail)";
+      }
+    } else if (userMsgs.length) {
+      summary = "[" + logicalDay() + " thin] " + userMsgs.length + " rounds archived: " + userMsgs.slice(0, 12).join(" | ") + (userMsgs.length > 12 ? " | ..." : "");
+    } else {
+      summary = "[" + logicalDay() + " thin] archived " + compactedLines.length + " lines";
+    }
+    let longterm = readText(this.longtermMd) || "";
+    longterm += "\n## " + logicalDay() + " (rollup)\n" + summary + "\n";
+    writeText(this.longtermMd, longterm);
+    this._lastCompactAt = now; // 节流: 压缩完成后记录, 60s 内不再压缩
+  }
+
+  context(userMsg) {
+    const todayCount = this.sessionStore ? _renderLines(this.sessionStore, logicalDay()).length : 0;
+    const rawLongterm = readText(this.longtermMd) || "";
+    const longterm = _longtermExcludingToday(rawLongterm, logicalDay()).slice(-3000);
+    const topFacts = this.factsTop(userMsg);
+    // v1.2.0 fix: 今日对话原文由会话历史(history)承载, 不再逐行重复注入到 system,
+    // 避免模型在 system 的"今日记忆"里看到与 history 相同的对话而重复回话。
+    const todayNote = todayCount
+      ? `今日已进行 ${todayCount} 轮对话（完整内容已随会话历史提供）。`
+      : "今日暂无对话。";
+    return `
+# 今日对话
+${todayNote}
+
+# 长期记忆 (最近)
+${longterm || "(暂无)"}
+
+# 关键事实
+${topFacts || "(暂无)"}
+`;
+  }
+
+  // 关键事实: 按当前问题语义检索优先, 不足 8 条用衰减分补齐 (去重)。
+  // 让每轮自动注入的记忆与当前问题相关, 而非纯衰减取 top (v0.8.1 语义注入)
+  factsTop(userMsg) {
+    try {
+      const q = String(userMsg || "").trim();
+      const semantic = q ? this.factStore.query(q, { limit: 8 }) : [];
+      const decay = this.factStore.query("", { limit: 8 });
+      const seen = new Set();
+      const merged = [];
+      for (const f of [...semantic, ...decay]) {
+        if (seen.has(f.id)) continue;
+        seen.add(f.id);
+        merged.push(f);
+        if (merged.length >= 8) break;
+      }
+      return merged.map((f) => `- [${f.score}] ${f.content}`).join("\n");
+    } catch { return ""; }
+  }
+
+  // 可观测: longterm 大小 + 今日事件数, 供 agent.stats() 聚合
+  stats() {
+    let longtermBytes = 0;
+    try { longtermBytes = fs.statSync(this.longtermMd).size; } catch {}
+    return {
+      longterm_bytes: longtermBytes,
+      events_today: _renderLines(this.sessionStore, logicalDay()).length,
+    };
+  }
+}
+
+// 读取长期记忆, 并剔除"今天"的段落 —— 当日对话已由会话历史(history)承载,
+// 若 longterm 里今天滚动块也注入, 会与 history 重复, 是"重复回话"的诱因。
+function _longtermExcludingToday(text, today) {
+  const out = [];
+  let inToday = false;
+  for (const l of String(text || "").split("\n")) {
+    const m = l.match(/^##\s+(\d{4}-\d{2}-\d{2})/);
+    if (m) { inToday = (m[1] === today); continue; }
+    if (!inToday) out.push(l);
+  }
+  return out.join("\n").trim();
+}
+
+// P1#9: 记忆信号预筛 - 命中关键词或长度信号才触发 LLM 提炼 (省成本)
+function _hasSignal(user, assistant) {
+  const u = String(user || "");
+  const a = String(assistant || "");
+  const text = (u + " " + a).slice(0, 500);
+  if (text.length < 8) return false;
+  const SIGNAL = /(我是|我喜欢|我讨厌|我记得|请记住|记住|偏好|习惯|目标是|我需要|我要|想买|喜欢|不喜欢|重要|关键|待办|计划|打算|希望|擅长|不擅长|生日|地址|电话|邮箱|账号|密码|股票|基金|仓位|止损|止盈|策略|工作|项目|公司|同事|老板|朋友|家人|对象|结婚|买房|买车|考试|学习)/;
+  const isGreeting = /^(你好|在吗|谢谢|好的|嗯|ok|hi|hello|再见|拜拜|哈喽)[!。？?]*$/i.test(u.trim());
+  // 收紧: 无信号关键词时, 仅对真正信息密集的长对话触发 LLM 提炼, 避免普通闲聊累积成本 [复审 P1#9]
+  return !isGreeting && (SIGNAL.test(text) || text.length > 200);
+}
+

package/skills/ppx-memory/scripts/pii.js

@@ -0,0 +1,42 @@
+// src/utils/pii.js - PII / 凭证检测与脱敏 (架构参考 openhanako pii-guard)
+const HARD_PATTERNS = [
+  { name: "api_key", regex: /\b(sk-[a-zA-Z0-9]{20,}|AKIA[A-Z0-9]{16}|gsk_[a-zA-Z0-9]{20,}|ghp_[a-zA-Z0-9]{36}|glpat-[a-zA-Z0-9_-]{20,}|xoxb-[a-zA-Z0-9-]+)\b/g },
+  // v1.0.8: 放宽 inline_secret 值域 (含 :/# 等) + 8 位起, 短密钥不漏检 (原 16+ 位且不含 :#)
+  // P0 (2026-09-15): key 后允许可选闭合引号 —— 原版只匹配 key=value / key: value,
+  //   JSON 序列化形式 "key":"value" (key 后先有闭合引号) 完全漏检, 已修。
+  { name: "inline_secret", regex: /\b(api[_-]?key|secret[_-]?key|access[_-]?token|auth[_-]?token|password|bearer)["']?\s*[:=]\s*["']?([a-zA-Z0-9_/+=\-.:#]{8,})["']?/gi },
+  { name: "private_key", regex: /-----BEGIN\s+(RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g },
+  { name: "credit_card", regex: /\b(?:\d{4}[- ]?){3}\d{4}\b/g },
+  { name: "id_card", regex: /\b\d{6}(?:19|20)\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])\d{3}[\dXx]\b/g },
+  { name: "ssn", regex: /\b\d{3}-\d{2}-\d{4}\b/g },
+  // v1.0.8: 邮箱 + 中国大陆手机号 (11 位, 1[3-9] 开头)
+  { name: "email", regex: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g },
+  { name: "phone", regex: /\b1[3-9]\d{9}\b/g },
+  // v1.6.0-dev: URL query 里的敏感参数值 (token/key/secret/sign 等) — 最常见的凭证泄漏渠道, 此前未覆盖
+  // 仅匹配参数名白名单, 避免误伤合法 URL 参数; 保留参数名, 只替换值
+  { name: "url_secret", regex: /([?&](?:token|key|secret|api[_-]?key|access[_-]?token|auth|sign|sig|password)=)[^&#\s"']*/gi, redact: (m, pre) => pre + "[REDACTED]" },
+];
+
+export function scrubPII(text) {
+  if (!text) return { cleaned: text, detected: [] };
+  const detected = [];
+  let cleaned = text;
+  for (const { name, regex, redact } of HARD_PATTERNS) {
+    regex.lastIndex = 0;
+    if (regex.test(cleaned)) {
+      detected.push(name);
+      regex.lastIndex = 0;
+      cleaned = cleaned.replace(regex, redact ? redact : "[REDACTED]");
+    }
+  }
+  return { cleaned, detected };
+}
+
+export function hasPII(text) {
+  if (!text) return false;
+  for (const { regex } of HARD_PATTERNS) {
+    regex.lastIndex = 0;
+    if (regex.test(text)) return true;
+  }
+  return false;
+}

package/skills/ppx-memory/scripts/schema.js

@@ -0,0 +1,80 @@
+// src/utils/schema.js - 数据文件 schema 版本 + 迁移钩子
+// 目标: 记忆数据文件 (facts.json / scenes.json) 保持纯数组格式不变 (现有读取者 healer/测试全部无感),
+//       版本号写在旁挂的 <file>.schema 小文件中; 数据结构升级时注册迁移函数, 启动自动迁移。
+// 设计:
+//   - 无 .schema 文件的历史数据一律视为 v1 (基线, 纯数组格式)
+//   - registerMigration(name, from, to, fn) 注册迁移链, 不允许跳级, 不允许覆盖
+//   - migrateData() 读当前版本 -> 沿迁移链推进 -> 原子写回数据 + 更新 .schema 文件
+//   - 崩溃安全: 迁移在原子写回后版本才推进, 中断重跑幂等
+import path from "node:path";
+import { atomicWrite, ensureDir, readJson } from "./store.js";
+
+// 基线版本: 无 .schema 文件 (历史纯数组格式) 一律视为 v1
+export const SCHEMA_BASE_VERSION = 1;
+
+// name -> Map<fromVersion, { to, fn }>
+const MIGRATIONS = new Map();
+
+// 注册迁移: from 版本 -> to 版本 (to 必须 > from)
+// fn(data, { from, to }) => 迁移后的 data
+export function registerMigration(name, from, to, fn) {
+  if (!Number.isInteger(from) || !Number.isInteger(to) || to <= from) {
+    throw new Error(`非法迁移版本: ${name} ${from}->${to}`);
+  }
+  if (typeof fn !== "function") throw new Error(`迁移函数缺失: ${name} v${from}`);
+  let chain = MIGRATIONS.get(name);
+  if (!chain) { chain = new Map(); MIGRATIONS.set(name, chain); }
+  if (chain.has(from)) throw new Error(`迁移冲突: ${name} v${from} 已注册`);
+  chain.set(from, { to, fn });
+  return { name, from, to };
+}
+
+function schemaFileOf(file) {
+  return file + ".schema";
+}
+
+// 读当前数据文件版本 (无 .schema 文件视为基线 v1)
+export function readSchema(file) {
+  const meta = readJson(schemaFileOf(file), null);
+  if (!meta || !Number.isInteger(meta.version)) return SCHEMA_BASE_VERSION;
+  return meta.version;
+}
+
+// 写版本 (原子)
+export function writeSchema(file, name, version) {
+  const p = schemaFileOf(file);
+  ensureDir(path.dirname(p));
+  atomicWrite(p, JSON.stringify({ name, version, updatedAt: new Date().toISOString() }, null, 2));
+}
+
+// 把数据文件迁移到 currentVersion: 沿注册链逐级推进, 无迁移函数则安全跳过 (版本直接标记到目标, 数据不动)。
+// 返回 { from(初始版本), to(最终版本), applied, data } —— applied 为实际执行的迁移步骤列表
+export function migrateData({ file, name, data, currentVersion, logger = null }) {
+  const chain = MIGRATIONS.get(name) || new Map();
+  const start = readSchema(file);
+  let from = start;
+  let d = data;
+  const applied = [];
+  let guard = 0;
+  while (from < currentVersion) {
+    if (++guard > 20) throw new Error(`迁移链疑似死循环: ${name} v${from}`);
+    const step = chain.get(from);
+    if (!step) {
+      // 没有迁移函数但仍落后于目标: 记录说明并直接标记版本 (数据保持原样)
+      if (logger) logger(`schema ${name}: v${from} -> v${currentVersion} 无迁移函数, 数据保持原样`);
+      applied.push({ from, to: currentVersion, note: "no-migration" });
+      from = currentVersion;
+      break;
+    }
+    if (step.to > currentVersion) throw new Error(`迁移越界: ${name} v${from}->v${step.to} 超过目标 v${currentVersion}`);
+    d = step.fn(d, { from, to: step.to });
+    applied.push({ from, to: step.to });
+    from = step.to;
+  }
+  if (applied.length) {
+    // 迁移产生新数据: 原子写回 (rename 覆盖, 崩溃安全), 版本随 .schema 文件推进
+    atomicWrite(file, JSON.stringify(d, null, 2));
+  }
+  writeSchema(file, name, from);
+  return { from: start, to: from, applied, data: d };
+}