dsh-layered-memory 0.8.5 → 0.8.6

package/dist/store/recall-dedupe.js

@@ -0,0 +1,138 @@
+/**
+ * 召回去重存储：sessionId → 已注入 L1 记录 id 集合的持久化映射。
+ *
+ * 语义（2026-08-24 设计共识）：
+ * - 同会话内已注入过的记忆不再重复注入（模型上下文已持有，重复注入浪费 token）；
+ * - 压制粒度 = 记录 id——去重合并更新会换新 id，新内容天然解除压制重新注入；
+ * - compact/clear 事件重置（上下文被压缩/清空，注入内容已丢失）；resume 不重置；
+ * - 热路径（召回 pre-step）同步内存读取，mark/reset 写穿持久化（session-modes 同款：
+ *   串行化原子写 + 失败降级内存态），任何 I/O 失败绝不抛进召回路径。
+ */
+import * as path from 'node:path';
+import { errDetail } from '../util/filelog.js';
+import { atomicWriteJson, ensureDir, readJsonIfExists } from './io.js';
+/** 会话条目上限（按 updatedAt 淘汰最旧；防文件无限增长）。 */
+export const RECALL_DEDUPE_SESSION_CAP = 200;
+/** 单会话记录 id 上限（按插入序淘汰最旧；Set 迭代序即插入序）。 */
+export const RECALL_DEDUPE_IDS_CAP = 512;
+/** 条目过期清理（90 天未更新即丢弃，与 session-modes 同款量级）。 */
+const PRUNE_MS = 90 * 24 * 3600_000;
+export class RecallDedupeStore {
+    logger;
+    file;
+    entries = new Map();
+    persistFailed = false;
+    /** 串行化持久化写（避免并发原子写撞临时文件名）；init 链最前（先载入再落盘，防丢更新）。 */
+    writeChain;
+    constructor(dataDir, logger) {
+        this.logger = logger;
+        this.file = path.join(dataDir, 'recall-dedupe.json');
+        this.writeChain = this.init();
+    }
+    /** 载入持久化映射（合并进内存——构造与载入之间发生的 mark 不丢）；失败降级内存态。 */
+    async init() {
+        const data = await readJsonIfExists(this.file);
+        if (!data?.sessions || typeof data.sessions !== 'object')
+            return;
+        const now = Date.now();
+        let count = 0;
+        for (const [sid, entry] of Object.entries(data.sessions)) {
+            if (!Array.isArray(entry?.recordIds))
+                continue;
+            if (now - (entry.updatedAt ?? 0) > PRUNE_MS)
+                continue;
+            const existing = this.entries.get(sid);
+            if (existing) {
+                // 合并：构造后、载入完成前已发生的 mark（保留较大 updatedAt）
+                for (const id of entry.recordIds)
+                    existing.ids.add(id);
+                existing.updatedAt = Math.max(existing.updatedAt, entry.updatedAt ?? 0);
+            }
+            else {
+                this.entries.set(sid, { ids: new Set(entry.recordIds), updatedAt: entry.updatedAt ?? now });
+            }
+            count++;
+        }
+        if (count > 0)
+            this.logger?.info(`[memory] 召回去重记录载入 ${count} 个会话`);
+    }
+    /** 该会话的已注入集合（热路径同步读；未出现过的会话返回空集合，惰性建条）。 */
+    seen(sessionId) {
+        let entry = this.entries.get(sessionId);
+        if (!entry) {
+            entry = { ids: new Set(), updatedAt: 0 };
+            this.entries.set(sessionId, entry);
+        }
+        return entry.ids;
+    }
+    /** 标记本轮实际注入的记录 id（写穿；调用方保证只传模型真实看到的条目）。 */
+    mark(sessionId, recordIds) {
+        if (recordIds.length === 0)
+            return;
+        const ids = this.seen(sessionId);
+        for (const id of recordIds)
+            ids.add(id);
+        // 插入序淘汰最旧（Set 迭代序 = 插入序）
+        while (ids.size > RECALL_DEDUPE_IDS_CAP) {
+            const oldest = ids.values().next().value;
+            if (oldest === undefined)
+                break;
+            ids.delete(oldest);
+        }
+        const entry = this.entries.get(sessionId);
+        entry.updatedAt = Date.now();
+        this.writeChain = this.writeChain.then(() => this.persist());
+    }
+    /** 清空该会话的记录（compact/clear 后上下文已丢失，记忆需可重新注入）。 */
+    reset(sessionId) {
+        if (!this.entries.has(sessionId))
+            return;
+        this.entries.delete(sessionId);
+        this.writeChain = this.writeChain.then(() => this.persist());
+    }
+    /** 等待在途持久化写完成（测试/停机用）。 */
+    flush() {
+        return this.writeChain;
+    }
+    async persist() {
+        try {
+            await ensureDir(path.dirname(this.file));
+            await atomicWriteJson(this.file, this.serialize());
+            this.persistFailed = false;
+        }
+        catch (err) {
+            if (!this.persistFailed) {
+                this.persistFailed = true;
+                this.logger?.warn(`[memory] 召回去重持久化失败（降级内存态）: ${errDetail(err)}`);
+            }
+        }
+    }
+    serialize() {
+        const now = Date.now();
+        // 超期清理 + 条数上限（按 updatedAt 淘汰最旧）
+        for (const [sid, e] of this.entries) {
+            if (now - e.updatedAt > PRUNE_MS && e.updatedAt > 0)
+                this.entries.delete(sid);
+        }
+        while (this.entries.size > RECALL_DEDUPE_SESSION_CAP) {
+            let oldest;
+            let oldestAt = Infinity;
+            for (const [sid, e] of this.entries) {
+                if (e.updatedAt > 0 && e.updatedAt < oldestAt) {
+                    oldest = sid;
+                    oldestAt = e.updatedAt;
+                }
+            }
+            if (oldest === undefined)
+                break; // 只剩惰性空条目（updatedAt=0），不占文件体积可留待过期清理
+            this.entries.delete(oldest);
+        }
+        const sessions = {};
+        for (const [sid, e] of this.entries) {
+            if (e.ids.size === 0)
+                continue; // 空集合不落盘
+            sessions[sid] = { recordIds: [...e.ids], updatedAt: e.updatedAt };
+        }
+        return { version: 1, sessions };
+    }
+}

package/dist/store/runtime-installer.d.ts

@@ -60,8 +60,6 @@ export declare class RuntimeInstaller {
      * runNpm 起跑前复查即不再起新进程（否则回退的 npm 会跑到自然结束且无法再取消）。
      */
     cancel(): boolean;
-    /** 从 runtime 目录解析已安装的 transformers 模块（LocalEmbeddingService 用）。 */
-    resolveModule(): unknown;
     private pushLine;
     /** 跑一次 npm 子进程（采集尾行 + 超时 kill），返回退出码（null = 被杀死/启动失败）。 */
     private runNpm;

package/dist/store/runtime-installer.js

@@ -14,7 +14,6 @@
  * - 幂等：已装版本 == 目标版本直接就绪；版本漂移（插件升级换了钉死版本）重装覆盖。
  */
 import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -139,11 +138,6 @@ export class RuntimeInstaller {
         this.child?.kill();
         return true;
     }
-    /** 从 runtime 目录解析已安装的 transformers 模块（LocalEmbeddingService 用）。 */
-    resolveModule() {
-        const req = createRequire(path.join(this.runtimeDir, 'package.json'));
-        return req(RuntimeInstaller.packageName);
-    }
     pushLine(line) {
         const lines = this.progress.lastLines;
         lines.push(line.length > 300 ? line.slice(0, 300) + '…' : line);

package/dist/store/search-utils.d.ts

@@ -1,5 +1,22 @@
 /** 标准 RRF 常数（原论文值）；k 越大越偏向低排名项（分布更平滑）。 */
 export declare const RRF_K = 60;
+/** 衰减地板（#29 时效加权的安全边界）：老记忆最多损失一半排序分，永不沉底。
+ *  内部常量不进配置——它是安全机制不是调参旋钮。 */
+export declare const DECAY_FLOOR = 0.5;
+/**
+ * 时效衰减加权（#29，读路径专用）：score × max(FLOOR, 0.5^(Δ天/半衰期)) 后重排序。
+ *
+ * - Δ 按 updated_at（内容版本时间）起算，缺失/非法按最老 → 地板接管（零特判分支）；
+ * - 乘法保相关性主导：只在相关度相近的候选之间轮转名次（名额新鲜度），不淘汰不
+ *   硬过滤——score≈0 的新记忆乘什么都是 ≈0；hit 的原 score 字段不被改写（排序用
+ *   加权分，展示仍反映检索相关度）；
+ * - halfLifeDays ≤ 0 直接原样返回（开关关闭）；
+ * - 仅用于召回/工具检索；searchCandidates（去重候选）不得应用——写路径找同语义
+ *   旧记录要无视新旧，衰减会让去重漏检（同事实双记录）。
+ */
+export declare function applyDecayWeight<T extends {
+    score: number;
+}>(hits: T[], halfLifeDays: number, updatedAtOf: (hit: T) => number | undefined, now?: number): T[];
 /**
  * RRF 融合多个已排序列表：每项得分 = 各列表 1/(k + rank + 1) 之和。
  * 出现在多个列表的项得分累加，按得分降序返回（附 rrfScore）。

package/dist/store/search-utils.js

@@ -10,6 +10,35 @@
 import { tokenize } from '../util/text.js';
 /** 标准 RRF 常数（原论文值）；k 越大越偏向低排名项（分布更平滑）。 */
 export const RRF_K = 60;
+/** 衰减地板（#29 时效加权的安全边界）：老记忆最多损失一半排序分，永不沉底。
+ *  内部常量不进配置——它是安全机制不是调参旋钮。 */
+export const DECAY_FLOOR = 0.5;
+/**
+ * 时效衰减加权（#29，读路径专用）：score × max(FLOOR, 0.5^(Δ天/半衰期)) 后重排序。
+ *
+ * - Δ 按 updated_at（内容版本时间）起算，缺失/非法按最老 → 地板接管（零特判分支）；
+ * - 乘法保相关性主导：只在相关度相近的候选之间轮转名次（名额新鲜度），不淘汰不
+ *   硬过滤——score≈0 的新记忆乘什么都是 ≈0；hit 的原 score 字段不被改写（排序用
+ *   加权分，展示仍反映检索相关度）；
+ * - halfLifeDays ≤ 0 直接原样返回（开关关闭）；
+ * - 仅用于召回/工具检索；searchCandidates（去重候选）不得应用——写路径找同语义
+ *   旧记录要无视新旧，衰减会让去重漏检（同事实双记录）。
+ */
+export function applyDecayWeight(hits, halfLifeDays, updatedAtOf, now = Date.now()) {
+    if (!(halfLifeDays > 0) || hits.length === 0)
+        return hits;
+    const weight = (h) => {
+        const t = updatedAtOf(h);
+        if (t == null || !Number.isFinite(t))
+            return DECAY_FLOOR;
+        const days = Math.max(0, (now - t) / 86_400_000);
+        return Math.max(DECAY_FLOOR, 0.5 ** (days / halfLifeDays));
+    };
+    return hits
+        .map((h) => ({ h, weighted: h.score * weight(h) }))
+        .sort((a, b) => b.weighted - a.weighted)
+        .map((x) => x.h);
+}
 /**
  * RRF 融合多个已排序列表：每项得分 = 各列表 1/(k + rank + 1) 之和。
  * 出现在多个列表的项得分累加，按得分降序返回（附 rrfScore）。

package/dist/store/sqlite.js

@@ -670,12 +670,19 @@ export class MemoryDb {
     /** 事务内的单条写入体（upsertL1 / upsertL1Batch 共用；调用方负责 BEGIN/COMMIT）。 */
     upsertL1InTx(record, embedding) {
         const ts = timestampsToDb(record.timestamps);
+        // 绑定层字段兜底（取 schema 列默认）：旧版 JSONL 等外部数据缺字段时 undefined
+        // 无法绑定（node:sqlite 拒绝绑定），曾致旧版导入逐条全挂、每次启动无限重试（#28）。
+        // 主表与 FTS 两条语句共用同源归一化值；type 归一化后 familyForType 也不再收到 undefined。
+        const type = record.type ?? '';
+        const priority = record.priority ?? 50;
+        const sceneName = record.scene_name ?? '';
+        const family = record.family ?? familyForType(type);
         // 防御性 FTS 删除的前置点查（主键索引，微秒级）：record_id 在 FTS 表是 UNINDEXED，
         // 按 id DELETE 是 O(N) 全表扫描——导入/重建/重嵌等"全新增"路径曾为每条记录白付一次
         // 全扫（批量写整体 O(N²)）。只有主表已有该行（覆盖/合并）才可能有旧 FTS 行需要删。
         // 同批重复 id 也能正确处理：首条插入后，第二条的点查在同一事务内已见新行。
         const ftsExisted = this.ftsAvailable ? this.stmtL1Exists.get(record.id) !== undefined : false;
-        this.stmtUpsertL1.run(record.id, record.content, record.type, record.priority, record.scene_name, record.sessionId ?? 'default', record.version ?? 0, ts.str, ts.start, ts.end, toIso(record.createdAt), toIso(record.updatedAt), JSON.stringify(record.metadata ?? {}), record.family ?? familyForType(record.type));
+        this.stmtUpsertL1.run(record.id, record.content, type, priority, sceneName, record.sessionId ?? 'default', record.version ?? 0, ts.str, ts.start, ts.end, toIso(record.createdAt), toIso(record.updatedAt), JSON.stringify(record.metadata ?? {}), family);
         // vec0 不支持 ON CONFLICT → 先删后插；零向量跳过（cosine 未定义）
         if (this.stmtDeleteL1Vec && this.stmtInsertL1Vec) {
             this.stmtDeleteL1Vec.run(record.id);
@@ -688,7 +695,7 @@ export class MemoryDb {
         if (this.ftsAvailable) {
             if (ftsExisted)
                 this.stmtL1FtsDelete.run(record.id);
-            this.stmtL1FtsInsert.run(tokenizeForFts(record.content), record.content, record.id, record.type, record.priority, record.scene_name, record.sessionId ?? 'default', record.version ?? 0, ts.str, ts.start, ts.end, JSON.stringify(record.metadata ?? {}), record.family ?? familyForType(record.type));
+            this.stmtL1FtsInsert.run(tokenizeForFts(record.content), record.content, record.id, type, priority, sceneName, record.sessionId ?? 'default', record.version ?? 0, ts.str, ts.start, ts.end, JSON.stringify(record.metadata ?? {}), family);
         }
     }
     /** 批量删除 L1（元数据 + 向量 + FTS），返回删除条数。IN 按 ≤900 分块（避变量数上限）。 */
@@ -932,22 +939,29 @@ export class MemoryDb {
         try {
             this.db.exec('BEGIN');
             for (let i = 0; i < records.length; i++) {
-                const r = records[i];
+                const rec = records[i];
+                // 绑定层字段兜底（取 schema 列默认）：同 upsertL1InTx——外部数据缺字段时
+                // undefined 无法绑定（#28）；主表/向量/FTS 共用同源归一化值
+                const sessionId = rec.sessionId ?? 'default';
+                const role = rec.role ?? '';
+                const content = rec.content ?? '';
+                const recordedAt = rec.recordedAt ?? '';
+                const timestamp = rec.timestamp ?? 0;
                 // 同 upsertL1 的点查预判：全新增路径跳过 UNINDEXED 列的 FTS 全扫删除
-                const ftsExisted = this.ftsAvailable ? this.stmtL0Exists.get(r.id) !== undefined : false;
-                this.stmtUpsertL0.run(r.id, r.sessionId, r.role, r.content, r.recordedAt, r.timestamp);
+                const ftsExisted = this.ftsAvailable ? this.stmtL0Exists.get(rec.id) !== undefined : false;
+                this.stmtUpsertL0.run(rec.id, sessionId, role, content, recordedAt, timestamp);
                 if (this.stmtDeleteL0Vec && this.stmtInsertL0Vec) {
-                    this.stmtDeleteL0Vec.run(r.id);
+                    this.stmtDeleteL0Vec.run(rec.id);
                     const vec = embeddings?.[i];
                     if (vec && !isZeroVector(vec)) {
-                        this.stmtInsertL0Vec.run(r.id, vecToBuffer(vec), r.recordedAt);
+                        this.stmtInsertL0Vec.run(rec.id, vecToBuffer(vec), recordedAt);
                     }
                 }
                 if (this.ftsAvailable) {
                     // 同 upsertL1：FTS 失败冒泡触发整批回滚，禁止"删了没补"的索引空洞。
                     if (ftsExisted)
-                        this.stmtL0FtsDelete.run(r.id);
-                    this.stmtL0FtsInsert.run(tokenizeForFts(r.content), r.content, r.id, r.sessionId, r.role, r.recordedAt, r.timestamp);
+                        this.stmtL0FtsDelete.run(rec.id);
+                    this.stmtL0FtsInsert.run(tokenizeForFts(content), content, rec.id, sessionId, role, recordedAt, timestamp);
                 }
             }
             this.db.exec('COMMIT');

package/dist/util/recall-budget.d.ts

@@ -27,6 +27,6 @@ export declare function applyRecallBudget(lines: string[], limits: RecallBudgetL
  * resolve 为空结果（空数组）与超时（undefined）语义不同，调用方据此区分日志。
  */
 export declare function raceRecallTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | undefined>;
-/** 召回路径远程嵌入 fetch 的内层钳制（固定值）：给 FTS 降级留出总预算内的时间。
- *  仅作用于远程 HTTP 调用；本地推理不受钳制（进程内 CPU 推理无挂起风险）。 */
+/** 召回路径嵌入调用的内层钳制（固定值）：给 FTS 降级留出总预算内的时间。
+ *  远程作用于 HTTP fetch；本地作用于 worker 代理的等待（race 放弃、迟到回复丢弃）。 */
 export declare const RECALL_EMBED_CAP_MS = 3000;

package/dist/util/recall-budget.js

@@ -80,6 +80,6 @@ export async function raceRecallTimeout(promise, timeoutMs) {
             clearTimeout(timer);
     }
 }
-/** 召回路径远程嵌入 fetch 的内层钳制（固定值）：给 FTS 降级留出总预算内的时间。
- *  仅作用于远程 HTTP 调用；本地推理不受钳制（进程内 CPU 推理无挂起风险）。 */
+/** 召回路径嵌入调用的内层钳制（固定值）：给 FTS 降级留出总预算内的时间。
+ *  远程作用于 HTTP fetch；本地作用于 worker 代理的等待（race 放弃、迟到回复丢弃）。 */
 export const RECALL_EMBED_CAP_MS = 3_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",