dsh-prime-memory 0.26.14 → 0.26.15

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 更新日志（Changelog）
 
+## [0.26.15] — 2026-10-28
+
+> 真宿主验证（1197 条 L1 / 380 条 `work_method` 的真实库副本）发现 0.26.14 的**写放大**缺陷，本版修掉。单测没抱住它，因为夹具只有几条记录。
+
+### 修复
+
+- **证据整批落盘**：`absorbGroup` 原先逐条 `await appendEvidence()`，而每次调用都是一次全文件重写 → 首轮回灌 379 条证据 = 379 次落盘。新增 `SkillStore.appendEvidenceBatch(rows)`（整批一次 persist），生产者改走该入口。
+- **空跑不写盘**：对已存在候选原先无条件 `update({ steps })`，导致一轮回灌即使 `created=0 / appended=0` 仍把 sidecar 全量重写 240 次（实测 `rev` 从 1262 跳到 1742）。现在先 `sameSteps` 比对，未变则跳过。
+- **晋升时序修正**：`tryPromote` 改到证据**整批落盘之后**逐个判，否则 `sessionCount` 看不到本轮新会话。
+- 新增用例「空跑不写盘」（spy 断言 `update`/`appendEvidenceBatch` 零调用）；全量 **1859 例**/186 文件绿。
+- 功能面与 0.26.14 一致（生产者 + backfill + 诚实化），无配置变更、无默认行为变更。
+
 ## [0.26.14] — 2026-10-28
 
 > 修复 issue #15：「技能结晶」自上线以来**根本没有生产者**——`detectCandidates` 与 `SkillStore.create()` 在全仓**只有测试调用点**，所以 `skills.json` 永远不会被生成，看板恒为 0。用户打开 `skillsEnabled` 开关后拿到的是一个空盒子，而且不报错、不提示，只能翻源码才知道功能没接上。

package/dist/skills/producer.js

@@ -93,6 +93,15 @@ function titleOf(g) {
     const label = g.hall && g.hall !== 'general' ? `${g.hall} 流程` : g.sceneName ? `${g.sceneName} 流程` : '通用流程';
     return `技能：${label}`;
 }
+/** 两个 steps 数组逐字相等（用于跳过无变化的重写）。 */
+function sameSteps(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
 /**
  * 建一个技能生产者。
  *
@@ -116,15 +125,19 @@ export function createSkillProducer(deps) {
         errors: [],
     });
     /**
-     * 把一组视图落成「一个候选 + 若干证据」，并按需尝试晋升。
+     * 把一组视图落成「一个候选 + 若干证据」。
+     *
+     * 写入节奏（真机量测后调整）：本函数**不逐条落盘**——证据先攒进 `pending`
+     * 由调用方整批一次写，steps 只在真变化时才 `update`。否则一轮空跑也会把
+     * sidecar 全量重写几百次（`rev` 跳涨就是这么被发现的）。
      * 返回 false 表示应当中止外层循环（达 SKILLS_CAP）。
      */
-    const absorbGroup = async (g, runId, cfg, s) => {
+    const absorbGroup = async (g, runId, s, pending, seen, touched, at) => {
         const { steps, recordIds } = dedupe(g.views);
         if (steps.length === 0)
             return true;
-        let exists = skills.get(g.id) !== undefined;
-        if (!exists) {
+        const existing = skills.get(g.id);
+        if (existing === undefined) {
             try {
                 await skills.create({
                     id: g.id,
@@ -137,7 +150,6 @@ export function createSkillProducer(deps) {
                     evidenceRecordIds: recordIds,
                 });
                 s.created += 1;
-                exists = true;
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -152,11 +164,13 @@ export function createSkillProducer(deps) {
                     logger?.warn(`[memory] 技能候选创建失败(${g.id}): ${msg}`);
                     return true;
                 }
-                // 并发下另一轮刚建好：当作已存在，继续走证据路径
-                exists = true;
+                // 并发下另一轮刚建好：重新取一次，当作已存在继续走证据路径
+                const again = skills.get(g.id);
+                if (again && !sameSteps(again.steps, steps))
+                    await skills.update(g.id, { steps });
             }
         }
-        else {
+        else if (!sameSteps(existing.steps, steps)) {
             // 机器侧只重写 steps；body 是人编辑区，传进去就破坏了分列不变量。
             try {
                 await skills.update(g.id, { steps });
@@ -166,36 +180,39 @@ export function createSkillProducer(deps) {
             }
         }
         s.candidatesTouched += 1;
-        // 证据：sessionCount 的唯一来源。三元组去重，重复轮次不重复投。
-        const at = new Date().toISOString();
+        touched.push(g.id);
+        // 证据：sessionCount 的唯一来源。三元组去重（含本批内去重），重复轮次不重复投。
         for (const v of g.views) {
             if (v.sessionId === '')
                 continue;
-            if (skills.hasEvidence(g.id, v.sessionId, v.id))
+            const key = `${g.id}\u0000${v.sessionId}\u0000${v.id}`;
+            if (seen.has(key) || skills.hasEvidence(g.id, v.sessionId, v.id))
                 continue;
-            try {
-                await skills.appendEvidence({ skillId: g.id, runId, recordId: v.id, sessionId: v.sessionId, at, kind: EVIDENCE_KIND });
-                s.appended += 1;
-            }
-            catch (err) {
-                s.errors.push(`投证据失败: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        // 自动晋升：双阈同时满足才动（minEvidence 此前无人消费，这里让它真实生效）。
-        // 人工晋升走 skills-action，只卡 sessionCount——人审是人的判断，不重复机械门。
-        if (cfg.allowPromote && exists) {
-            if (skills.sessionCount(g.id) >= cfg.minSessions && skills.evidenceCount(g.id) >= cfg.minEvidence) {
-                if (await skills.tryPromote(g.id, cfg.minSessions, { allowPromote: true }))
-                    s.promoted += 1;
-            }
+            seen.add(key);
+            pending.push({ skillId: g.id, runId, recordId: v.id, sessionId: v.sessionId, at, kind: EVIDENCE_KIND });
         }
         return true;
     };
     const drainGroups = async (groups, runId, cfg, s) => {
+        const pending = [];
+        const seen = new Set();
+        const touched = [];
+        const at = new Date().toISOString();
         for (const g of groups) {
-            if (!(await absorbGroup(g, runId, cfg, s)))
+            if (!(await absorbGroup(g, runId, s, pending, seen, touched, at)))
                 return;
         }
+        // 整批一次落盘；晋升必须在证据落盘后判，否则 sessionCount 看不到本轮新会话。
+        if (pending.length > 0)
+            s.appended = await skills.appendEvidenceBatch(pending);
+        if (!cfg.allowPromote)
+            return;
+        for (const id of touched) {
+            if (skills.sessionCount(id) >= cfg.minSessions && skills.evidenceCount(id) >= cfg.minEvidence) {
+                if (await skills.tryPromote(id, cfg.minSessions, { allowPromote: true }))
+                    s.promoted += 1;
+            }
+        }
     };
     return {
         async ingestRound(records, sessionId, runId) {

package/dist/store/skill-store.d.ts

@@ -98,6 +98,15 @@ export declare class SkillStore {
     evidenceCount(skillId: string): number;
     /** 某技能的 distinct session 计数（晋升判据的唯一来源，与 LLM 判断解耦）。 */
     sessionCount(skillId: string): number;
+    /**
+     * 批量追加证据：**整批一次持久化**，返回实际入库条数。
+     *
+     * 为何需要：`appendEvidence` 每条都 `await persist()`，而 persist 是全文件重写。
+     * 真机量测（1197 条 L1 / 380 条 work_method）下首轮回灌要投 379 条证据，
+     * 逐条写 = 379 次全量落盘（对已长到几百 KB 的 sidecar 是百 MB 级写放大）。
+     * 生产者改走本入口；逐条版保留给单次工具调用。
+     */
+    appendEvidenceBatch(rows: readonly SkillEvidence[]): Promise<number>;
     /**
      * 晋升：candidate→active，仅当功能开且该技能 distinct-session ≥ minSessions。
      * 返回是否发生晋升。不批量、不依赖 LLM（可解释性结构保证，同 conflictFreeze"不自动裁决"哲学）。

package/dist/store/skill-store.js

@@ -269,6 +269,34 @@ export class SkillStore {
                 s.add(e.sessionId);
         return s.size;
     }
+    /**
+     * 批量追加证据：**整批一次持久化**，返回实际入库条数。
+     *
+     * 为何需要：`appendEvidence` 每条都 `await persist()`，而 persist 是全文件重写。
+     * 真机量测（1197 条 L1 / 380 条 work_method）下首轮回灌要投 379 条证据，
+     * 逐条写 = 379 次全量落盘（对已长到几百 KB 的 sidecar 是百 MB 级写放大）。
+     * 生产者改走本入口；逐条版保留给单次工具调用。
+     */
+    async appendEvidenceBatch(rows) {
+        this.ensureLoaded();
+        if (rows.length === 0)
+            return 0;
+        const known = new Set(this.skills.map((s) => s.id));
+        let added = 0;
+        for (const ev of rows) {
+            if (!ev || !known.has(ev.skillId) || !ev.sessionId || !ev.recordId)
+                continue;
+            this.evidence.push(ev);
+            added++;
+        }
+        if (added === 0)
+            return 0;
+        if (this.evidence.length > EVIDENCE_CAP)
+            this.evidence.splice(0, this.evidence.length - EVIDENCE_CAP);
+        this.rev++;
+        await this.persist();
+        return added;
+    }
     /**
      * 晋升：candidate→active，仅当功能开且该技能 distinct-session ≥ minSessions。
      * 返回是否发生晋升。不批量、不依赖 LLM（可解释性结构保证，同 conflictFreeze"不自动裁决"哲学）。

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.26.14",
+  "version": "0.26.15",
   "description": {
     "en": "Layered distilled memory plugin (L0 capture → L1 atomic memory → L2 scenes → L3 persona) with automatic recall injection before each model step.",
     "zh": "L0~L3 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.26.14",
+  "version": "0.26.15",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",