dsh-layered-memory 0.8.2 → 0.8.3

package/dist/store/l0.js

@@ -90,9 +90,14 @@ export class L0Store {
         for (const [day, list] of byDay) {
             await appendJsonl(path.join(this.dir, `${day}.jsonl`), list);
         }
-        // 检索引擎：DB + 向量（嵌入失败只跳过向量，不影响元数据/FTS，backfill 补齐）
+        // 检索引擎：DB + 向量（嵌入失败只跳过向量，不影响元数据/FTS，backfill 补齐）。
+        // 双写失败闭环：JSONL 事实源已先行追加，DB 缺行 = 这些消息检索不可见
+        // （conversation_search / 蒸馏背景参考都查不到）——升 error 并给自愈指引。
         const vecs = await this.helper.batch(records.map((r) => r.content));
-        this.db.upsertL0Batch(records, vecs);
+        if (!this.db.upsertL0Batch(records, vecs)) {
+            this.logger?.error(`[memory] L0 检索库批量写入失败（${records.length} 条，JSONL 事实源完好），` +
+                '这些消息暂不可检索；可在设置页运行「重建记忆」修复');
+        }
     }
     /** 今日已捕获消息数（SQL 计数，不再读整文件）。 */
     async countToday() {

package/dist/store/l1.js

@@ -43,23 +43,25 @@ export class L1Store {
         try {
             const records = await readJsonl(this.legacyFile);
             const valid = records.filter((r) => r && typeof r.id === 'string' && r.content);
+            const badCount = records.length - valid.length;
             let n = 0;
             if (valid.length > 0 && this.db.upsertL1Batch(valid))
                 n = valid.length;
-            // 只有确实导入成功（或文件为空）才改名，避免把未入库的数据改名带走
-            if (n === records.length) {
+            // 只有确实导入成功才改名，避免把未入库的数据改名带走；判据按 valid 数——
+            // 坏行已在读取时过滤，按 records.length 判会让混入坏行的文件迁移永不完成
+            if (n === valid.length) {
                 const renamed = await fs
                     .rename(this.legacyFile, `${this.legacyFile}.imported`)
                     .then(() => true, () => false);
                 if (renamed) {
-                    this.logger?.info(`[memory] 旧版 L1 数据已导入检索库 ${n} 条（l1/records.jsonl → .imported）`);
+                    this.logger?.info(`[memory] 旧版 L1 数据已导入检索库 ${n} 条${badCount > 0 ? `（另丢弃 ${badCount} 条坏行）` : ''}（l1/records.jsonl → .imported）`);
                 }
                 else {
                     this.logger?.warn('[memory] 旧版 L1 导入完成但改名失败，下次启动会重复导入（upsert 幂等，无害）');
                 }
             }
             else {
-                this.logger?.warn(`[memory] 旧版 L1 导入不完整（${n}/${records.length}），保留原文件下次重试`);
+                this.logger?.warn(`[memory] 旧版 L1 导入不完整（${n}/${valid.length}），保留原文件下次重试`);
             }
         }
         catch (err) {
@@ -96,15 +98,23 @@ export class L1Store {
             await appendJsonl(path.join(this.recordsDir, `${day}.jsonl`), list);
         }
         const vecs = await this.helper.batch(records.map((r) => r.content));
-        // 单事务批量写：逐条开事务在 WAL FULL 下每条一次 fsync
-        this.db.upsertL1Batch(records, vecs);
+        // 单事务批量写：逐条开事务在 WAL FULL 下每条一次 fsync。
+        // 双写失败闭环：JSONL 事实源已先行追加，DB 缺行 = 这批记忆检索不可见、
+        // 去重候选缺失（重复记忆会累积）。upsert 内部已有逐条 warn，这里升 error
+        // 并给出自愈指引——检索库可由"重建记忆"从事实源全量重导修复。
+        if (!this.db.upsertL1Batch(records, vecs)) {
+            this.logger?.error(`[memory] L1 检索库批量写入失败（${records.length} 条，JSONL 事实源完好），` +
+                '这批记忆暂不可检索；可在设置页运行「重建记忆」修复');
+        }
     }
     /** 去重 update/merge 产出的记录：只更新检索库（JSONL 事实源不改写，官方语义）。 */
     async upsert(record) {
         if (!record.family)
             record.family = familyForType(record.type);
         const vec = (await this.helper.batch([record.content]))[0];
-        this.db.upsertL1(record, vec);
+        if (!this.db.upsertL1(record, vec)) {
+            this.logger?.error(`[memory] L1 检索库写入失败 id=${record.id}（JSONL 事实源完好），该记忆暂不可检索，重建可修复`);
+        }
     }
     /** 活切换嵌入源：同步换底层服务（嵌入源三态切换用）。 */
     setEmbeddingService(svc) {

package/dist/store/local-embedding.d.ts

@@ -43,7 +43,9 @@ export declare class LocalEmbeddingService implements EmbeddingService {
     private readonly entry;
     private readonly loader;
     private readonly logger?;
-    constructor(entry: CatalogEntry, modelDir: string, loader: ModuleLoader, logger?: MemoryLogger);
+    /** 输入截断（与远程路径同源的 embedding.maxInputChars 配置，缺省 5000）。 */
+    private readonly maxInputChars;
+    constructor(entry: CatalogEntry, modelDir: string, loader: ModuleLoader, logger?: MemoryLogger, maxInputChars?: number);
     getDimensions(): number;
     getProviderInfo(): EmbeddingProviderInfo;
     isReady(): boolean;

package/dist/store/local-embedding.js

@@ -7,11 +7,14 @@ export class LocalEmbeddingService {
     entry;
     loader;
     logger;
-    constructor(entry, modelDir, loader, logger) {
+    /** 输入截断（与远程路径同源的 embedding.maxInputChars 配置，缺省 5000）。 */
+    maxInputChars;
+    constructor(entry, modelDir, loader, logger, maxInputChars) {
         this.entry = entry;
         this.modelDir = modelDir;
         this.loader = loader;
         this.logger = logger;
+        this.maxInputChars = maxInputChars && maxInputChars > 0 ? maxInputChars : 5000;
     }
     getDimensions() {
         return this.entry.dims;
@@ -59,7 +62,7 @@ export class LocalEmbeddingService {
         const out = [];
         // CPU 推理逐条最稳（ORT session 内部并行），量级为本插件写入/重嵌批（≤16）没问题
         for (const text of texts) {
-            const result = await this.extractor([text.slice(0, 5000)], { pooling: this.entry.pooling, normalize: true });
+            const result = await this.extractor([text.slice(0, this.maxInputChars)], { pooling: this.entry.pooling, normalize: true });
             out.push(new Float32Array(result[0].data));
         }
         return out;

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

@@ -54,12 +54,19 @@ export declare class RuntimeInstaller {
      * 返回是否就绪（失败/取消返回 false 并在 progress.error 说明原因）。
      */
     ensure(): Promise<boolean>;
-    /** 取消安装（kill 子进程；node_modules 残留无害，npm 幂等重装）。 */
+    /**
+     * 取消安装（kill 子进程；node_modules 残留无害，npm 幂等重装）。
+     * 间隙兼容：ci 退出到回退 install 起跑之间 child 为 null——此时也置取消态，
+     * runNpm 起跑前复查即不再起新进程（否则回退的 npm 会跑到自然结束且无法再取消）。
+     */
     cancel(): boolean;
     /** 从 runtime 目录解析已安装的 transformers 模块（LocalEmbeddingService 用）。 */
     resolveModule(): unknown;
     private pushLine;
     /** 跑一次 npm 子进程（采集尾行 + 超时 kill），返回退出码（null = 被杀死/启动失败）。 */
     private runNpm;
+    /** 取消态判定。独立方法而非内联比较：cancel() 在 await 期间跨方法置位
+     *  phase，TS 的属性流分析不跟踪这种突变，内联比较会被窄化误报"无重叠"。 */
+    private wasCancelled;
     private installOnce;
 }

package/dist/store/runtime-installer.js

@@ -54,7 +54,17 @@ export class RuntimeInstaller {
                         onStderr(cb) {
                             child.stderr?.on('data', (d) => String(d).split(/\r?\n/).forEach((l) => l && cb(l)));
                         },
-                        kill: () => child.kill(),
+                        // Windows shell:true 下 child 只是 cmd.exe，npm/node 孙进程不随 child.kill()
+                        // 终止（超时与取消都会"表面停止"）——taskkill /T 按进程树杀；启动失败回退裸 kill
+                        kill: () => {
+                            if (process.platform === 'win32' && child.pid !== undefined) {
+                                const tk = spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { windowsHide: true });
+                                tk.on('error', () => child.kill());
+                            }
+                            else {
+                                child.kill();
+                            }
+                        },
                         // 'error'（如 ENOENT：PATH 无 npm）只发 error 不发 close——不监听会永挂
                         exited: new Promise((resolve) => {
                             child.on('close', (code) => resolve(code));
@@ -117,12 +127,16 @@ export class RuntimeInstaller {
             this.current = null;
         }
     }
-    /** 取消安装（kill 子进程；node_modules 残留无害，npm 幂等重装）。 */
+    /**
+     * 取消安装（kill 子进程；node_modules 残留无害，npm 幂等重装）。
+     * 间隙兼容：ci 退出到回退 install 起跑之间 child 为 null——此时也置取消态，
+     * runNpm 起跑前复查即不再起新进程（否则回退的 npm 会跑到自然结束且无法再取消）。
+     */
     cancel() {
-        if (this.progress.phase !== 'installing' || !this.child)
+        if (this.progress.phase !== 'installing')
             return false;
         this.progress.phase = 'cancelled';
-        this.child.kill();
+        this.child?.kill();
         return true;
     }
     /** 从 runtime 目录解析已安装的 transformers 模块（LocalEmbeddingService 用）。 */
@@ -138,6 +152,9 @@ export class RuntimeInstaller {
     }
     /** 跑一次 npm 子进程（采集尾行 + 超时 kill），返回退出码（null = 被杀死/启动失败）。 */
     async runNpm(args) {
+        // 起跑前复查取消：cancel() 在上一进程退出与本进程 spawn 之间的间隙置位时，不再起新进程
+        if (this.progress.phase === 'cancelled')
+            return null;
         const child = this.spawnImpl('npm', args, this.runtimeDir);
         this.child = child;
         child.onStdout((l) => this.pushLine(l));
@@ -151,6 +168,11 @@ export class RuntimeInstaller {
         this.child = null;
         return code;
     }
+    /** 取消态判定。独立方法而非内联比较：cancel() 在 await 期间跨方法置位
+     *  phase，TS 的属性流分析不跟踪这种突变，内联比较会被窄化误报"无重叠"。 */
+    wasCancelled() {
+        return this.progress.phase === 'cancelled';
+    }
     async installOnce() {
         // 锚定 package.json（带精确依赖）：没有它 npm 会向上层目录找最近的 package.json 安装（逃逸事故）；
         // npm ci 还要求它与 lockfile 根条目一致——每次安装都写规范化形状，覆盖历史遗留/被 npm 改写的副本。
@@ -184,6 +206,13 @@ export class RuntimeInstaller {
         catch {
             /* 无随包 lockfile，直接走 install 回退 */
         }
+        // ci 阶段被取消（退出码 null）不得落入回退分支——那是"ci 失败"语义，会让
+        // 取消后再白跑一次最长 10 分钟的 install
+        if (this.wasCancelled()) {
+            this.progress.elapsedMs = Date.now() - this.progress.startedAt;
+            this.logger?.warn('[memory] 运行时安装已取消（残留无害，重装幂等）');
+            return false;
+        }
         if (!usedCi || code !== 0) {
             if (usedCi) {
                 this.pushLine('npm ci 失败（lockfile 与钉死版本漂移？），回退 npm install');
@@ -203,7 +232,7 @@ export class RuntimeInstaller {
         this.progress.elapsedMs = Date.now() - this.progress.startedAt;
         const version = await this.installedVersion();
         this.progress.installedVersion = version;
-        if (this.progress.phase === 'cancelled') {
+        if (this.wasCancelled()) {
             this.logger?.warn('[memory] 运行时安装已取消（残留无害，重装幂等）');
             return false;
         }

package/dist/store/scenes.d.ts

@@ -19,5 +19,6 @@ export declare class SceneStore {
     /** 场景导航索引（召回注入用）。 */
     navigation(): Promise<string>;
 }
-/** 文件名归一化：只允许字母数字 CJK - _ .，以 .md 结尾，去空格/标点。 */
+/** 文件名归一化：只允许字母数字 CJK - _ .，以 .md 结尾，去空格/标点。
+ *  超长名截断到 120 字符（ENAMETOOLONG 防御）；Windows 保留设备名加前缀 _ 避让。 */
 export declare function sanitizeFilename(name: string): string;

package/dist/store/scenes.js

@@ -134,7 +134,10 @@ function parseMeta(content, name) {
     }
     return s;
 }
-/** 文件名归一化：只允许字母数字 CJK - _ .，以 .md 结尾，去空格/标点。 */
+/** Windows 保留设备名（CON.md 等带扩展形态同样命中设备语义，须整体避开）。 */
+const RESERVED_NAME_RE = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
+/** 文件名归一化：只允许字母数字 CJK - _ .，以 .md 结尾，去空格/标点。
+ *  超长名截断到 120 字符（ENAMETOOLONG 防御）；Windows 保留设备名加前缀 _ 避让。 */
 export function sanitizeFilename(name) {
     let n = name.trim();
     if (!n.toLowerCase().endsWith('.md'))
@@ -144,6 +147,12 @@ export function sanitizeFilename(name) {
         .replace(/-{2,}/g, '-')
         .replace(/-+\.md$/i, '.md')
         .replace(/^-+|-+$/g, '');
+    let stem = n.slice(0, -3);
+    if (stem.length > 120)
+        stem = stem.slice(0, 120).replace(/[-._]+$/, '');
+    if (RESERVED_NAME_RE.test(stem))
+        stem = `_${stem}`;
+    n = `${stem}.md`;
     if (!n || !/^[\w\u3400-\u9fff\uf900-\ufaff.\-_]+\.md$/i.test(n))
         return '';
     return n;

package/dist/store/sqlite.js

@@ -864,7 +864,7 @@ export class MemoryDb {
     // ============================
     /** FTS5 BM25 检索（family 缺省不过滤）。失败返回空数组（调用方降级）。 */
     searchL1Fts(query, limit, family) {
-        if (this.degraded || !this.ftsAvailable)
+        if (this.degraded || !this.ftsAvailable || limit <= 0)
             return [];
         const ftsQuery = buildFtsQuery(query);
         if (!ftsQuery)
@@ -890,7 +890,7 @@ export class MemoryDb {
     }
     /** vec0 余弦 KNN 检索（score = 1 - cosine distance；family 过滤走过度召回 + 回查过滤，vec0 无法 WHERE）。失败返回空数组。 */
     searchL1Vector(embedding, topK, family) {
-        if (this.degraded || !this.stmtSearchL1Vec)
+        if (this.degraded || !this.stmtSearchL1Vec || topK <= 0)
             return [];
         try {
             // 过度召回补偿遗留零向量；带族过滤时再放大（不命中本族的行会被丢弃）
@@ -1077,7 +1077,7 @@ export class MemoryDb {
     // L0 检索
     // ============================
     searchL0Fts(query, limit) {
-        if (this.degraded || !this.ftsAvailable)
+        if (this.degraded || !this.ftsAvailable || limit <= 0)
             return [];
         const ftsQuery = buildFtsQuery(query);
         if (!ftsQuery)

package/dist/tools/index.js

@@ -3,10 +3,20 @@ const OFF_NOTICE = '本会话的记忆档位为"关闭"：该会话对记忆系
 export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
     if (!cfg.tools)
         return;
-    /** 调用会话的检索族（auto → undefined 不过滤；off → null 表示整体禁用）。 */
+    /**
+     * 调用会话的检索族（auto → undefined 不过滤；off → null 表示整体禁用）。
+     * fail-open：exec.agent 缺失（宿主调用路径未带 agent 标识）按全族检索放行——
+     * 档位隔离依赖宿主正确传递 exec.agent.id，缺失只告警一次不拒绝工具调用。
+     */
+    let warnedNoAgent = false;
     const familyOfCaller = (agentId) => {
-        if (agentId === undefined)
+        if (agentId === undefined) {
+            if (!warnedNoAgent) {
+                warnedNoAgent = true;
+                logger.warn('[memory] 工具调用缺少 agent 标识（exec.agent 未传递），档位过滤退化为全族检索');
+            }
             return undefined;
+        }
         const mode = modes.get(agentId);
         if (mode === 'off')
             return null;

package/package.json

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