dsh-layered-memory 0.7.0 → 0.7.1

package/dist/store/l0.js

@@ -154,17 +154,20 @@ export class L0Store {
                 opts?.onProgress?.(done, total);
                 continue;
             }
+            const pending = [];
             chunk.forEach((c, j) => {
                 if (isZeroVector(vecs[j])) {
                     skipped++;
                     skippedNow.push(c.id);
                     return;
                 }
-                if (this.db.updateL0Vec(c.id, vecs[j], ''))
-                    written++;
-                else
-                    failed++;
+                pending.push({ id: c.id, embedding: vecs[j] });
             });
+            if (pending.length > 0) {
+                const ok = this.db.updateL0VecBatch(pending, '');
+                written += ok;
+                failed += pending.length - ok;
+            }
             done += chunk.length;
             opts?.onProgress?.(done, total);
         }

package/dist/store/l1.js

@@ -221,17 +221,20 @@ export class L1Store {
                 opts?.onProgress?.(done, total);
                 continue;
             }
+            const pending = [];
             chunk.forEach((c, j) => {
                 if (isZeroVector(vecs[j])) {
                     skipped++;
                     skippedNow.push(c.id);
                     return;
                 }
-                if (this.db.updateL1Vec(c.id, vecs[j]))
-                    written++;
-                else
-                    failed++;
+                pending.push({ id: c.id, embedding: vecs[j] });
             });
+            if (pending.length > 0) {
+                const ok = this.db.updateL1VecBatch(pending);
+                written += ok;
+                failed += pending.length - ok;
+            }
             done += chunk.length;
             opts?.onProgress?.(done, total);
         }

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

@@ -28,14 +28,17 @@ export declare class RuntimeInstaller {
     private readonly target;
     private readonly logger?;
     private readonly spawnImpl;
+    /** 随包 lockfile 路径（测试可注入；默认取 dist 根下构建期拷入的资产）。 */
+    private readonly lockfileSource;
     private progress;
     private child;
     private current;
-    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。 */
+    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。每次 spawn 独立计时。 */
     private static INSTALL_TIMEOUT_MS;
     constructor(dataDir: string, targetVersion: string, opts?: {
         logger?: MemoryLogger;
         spawnImpl?: SpawnImpl;
+        lockfileSource?: string;
     });
     /** 包内模块名（与钉死版本一起构成安装目标）。 */
     static packageName: string;
@@ -56,5 +59,7 @@ export declare class RuntimeInstaller {
     /** 从 runtime 目录解析已安装的 transformers 模块（LocalEmbeddingService 用）。 */
     resolveModule(): unknown;
     private pushLine;
+    /** 跑一次 npm 子进程（采集尾行 + 超时 kill），返回退出码（null = 被杀死/启动失败）。 */
+    private runNpm;
     private installOnce;
 }

package/dist/store/runtime-installer.js

@@ -4,7 +4,11 @@
  * 插件 npm 包本体不带重依赖，不用本地嵌入的用户零成本。
  *
  * - 安装位置：数据目录 runtime/（自带 package.json 锚定，防 npm 向上层目录逃逸安装）；
- * - 子进程 npm install --ignore-scripts --no-audit --no-fund，钉死精确版本；
+ * - 子进程 npm ci --ignore-scripts --no-audit --no-fund，钉死精确版本 + 随包 lockfile
+ *   （resources/runtime-package-lock.json，构建期拷入 dist/）锁定完整传递依赖树——
+ *   纯 install 只锁直接依赖的精确版本，传递依赖按 semver 浮动解析，registry 端
+ *   后续发布/投毒会随安装时间漂移；lockfile 把树冻结在作者侧。ci 失败（lock 与
+ *   package.json 漂移等）自动回退 npm install 精确版本（可用性优先，树不再受锁）；
  * - 进度（用户硬性要求：不能傻等）：npm 非交互模式无百分比 API，采用不确定进度——
  *   已耗时 + 子进程 stdout/stderr 尾行实时流出 + 可 kill；
  * - 幂等：已装版本 == 目标版本直接就绪；版本漂移（插件升级换了钉死版本）重装覆盖。
@@ -13,6 +17,7 @@ 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';
 /** 钉死的 transformers.js 版本（D8：精确版本，升级插件时在此变更并重装运行时）。 */
 export const PINNED_TRANSFORMERS_VERSION = '4.2.0';
 export class RuntimeInstaller {
@@ -20,15 +25,19 @@ export class RuntimeInstaller {
     target;
     logger;
     spawnImpl;
+    /** 随包 lockfile 路径（测试可注入；默认取 dist 根下构建期拷入的资产）。 */
+    lockfileSource;
     progress;
     child = null;
     current = null;
-    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。 */
+    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。每次 spawn 独立计时。 */
     static INSTALL_TIMEOUT_MS = 10 * 60_000;
     constructor(dataDir, targetVersion, opts) {
         this.runtimeDir = path.join(dataDir, 'runtime');
         this.target = targetVersion;
         this.logger = opts?.logger;
+        this.lockfileSource =
+            opts?.lockfileSource ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'runtime-package-lock.json');
         this.spawnImpl =
             opts?.spawnImpl ??
                 ((command, args, cwd) => {
@@ -127,41 +136,71 @@ export class RuntimeInstaller {
         if (lines.length > 5)
             lines.splice(0, lines.length - 5);
     }
+    /** 跑一次 npm 子进程（采集尾行 + 超时 kill），返回退出码（null = 被杀死/启动失败）。 */
+    async runNpm(args) {
+        const child = this.spawnImpl('npm', args, this.runtimeDir);
+        this.child = child;
+        child.onStdout((l) => this.pushLine(l));
+        child.onStderr((l) => this.pushLine(l));
+        const timeout = setTimeout(() => {
+            this.pushLine('安装超时（10 分钟），终止子进程');
+            child.kill();
+        }, RuntimeInstaller.INSTALL_TIMEOUT_MS);
+        const code = await child.exited;
+        clearTimeout(timeout);
+        this.child = null;
+        return code;
+    }
     async installOnce() {
-        // 锚定 package.json：没有它 npm 会向上层目录找最近的 package.json 安装（逃逸事故）
+        // 锚定 package.json（带精确依赖）：没有它 npm 会向上层目录找最近的 package.json 安装（逃逸事故）；
+        // npm ci 还要求它与 lockfile 根条目一致——每次安装都写规范化形状，覆盖历史遗留/被 npm 改写的副本。
         await fs.mkdir(this.runtimeDir, { recursive: true });
-        const manifestPath = path.join(this.runtimeDir, 'package.json');
-        try {
-            await fs.access(manifestPath);
-        }
-        catch {
-            await fs.writeFile(manifestPath, JSON.stringify({ name: 'dsh-memory-runtime', private: true }, null, 2));
-        }
+        const manifest = {
+            name: 'dsh-memory-runtime',
+            private: true,
+            dependencies: { [RuntimeInstaller.packageName]: this.target },
+        };
+        await fs.writeFile(path.join(this.runtimeDir, 'package.json'), JSON.stringify(manifest, null, 2));
         this.progress = {
             phase: 'installing',
             targetVersion: this.target,
             installedVersion: await this.installedVersion(),
             startedAt: Date.now(),
             elapsedMs: 0,
-            lastLines: [`npm install ${RuntimeInstaller.packageName}@${this.target}（--ignore-scripts）`],
+            lastLines: [],
         };
-        const child = this.spawnImpl('npm', ['install', '--ignore-scripts', '--no-audit', '--no-fund', '--loglevel', 'notice', `${RuntimeInstaller.packageName}@${this.target}`], this.runtimeDir);
-        this.child = child;
-        child.onStdout((l) => this.pushLine(l));
-        child.onStderr((l) => this.pushLine(l));
-        const timeout = setTimeout(() => {
-            this.pushLine('安装超时（10 分钟），终止子进程');
-            child.kill();
-        }, RuntimeInstaller.INSTALL_TIMEOUT_MS);
         this.logger?.info(`[memory] 运行时安装开始: ${RuntimeInstaller.packageName}@${this.target} → ${this.runtimeDir}`);
-        const code = await new Promise((resolve) => {
-            void child.exited.then((c) => {
-                clearTimeout(timeout);
-                resolve(c);
-            });
-        });
+        // 首选 npm ci + 随包 lockfile（传递依赖树冻结在作者侧）；lockfile 资产缺失（npm 包被裁剪等）
+        // 或 ci 失败（lock 与锚定版本漂移等）回退 npm install 精确版本——可用性优先。
+        let code = null;
+        let usedCi = false;
+        try {
+            const lock = await fs.readFile(this.lockfileSource, 'utf8');
+            await fs.writeFile(path.join(this.runtimeDir, 'package-lock.json'), lock);
+            this.pushLine(`npm ci（随包 lockfile 锁定依赖树，@${this.target}，--ignore-scripts）`);
+            usedCi = true;
+            code = await this.runNpm(['ci', '--ignore-scripts', '--no-audit', '--no-fund', '--loglevel', 'notice']);
+        }
+        catch {
+            /* 无随包 lockfile，直接走 install 回退 */
+        }
+        if (!usedCi || code !== 0) {
+            if (usedCi) {
+                this.pushLine('npm ci 失败（lockfile 与钉死版本漂移？），回退 npm install');
+                this.logger?.warn('[memory] 运行时 npm ci 失败，回退 npm install（传递依赖不再受随包 lockfile 锁定）');
+            }
+            this.pushLine(`npm install ${RuntimeInstaller.packageName}@${this.target}（--ignore-scripts）`);
+            code = await this.runNpm([
+                'install',
+                '--ignore-scripts',
+                '--no-audit',
+                '--no-fund',
+                '--loglevel',
+                'notice',
+                `${RuntimeInstaller.packageName}@${this.target}`,
+            ]);
+        }
         this.progress.elapsedMs = Date.now() - this.progress.startedAt;
-        this.child = null;
         const version = await this.installedVersion();
         this.progress.installedVersion = version;
         if (this.progress.phase === 'cancelled') {

package/dist/store/sqlite.d.ts

@@ -176,6 +176,21 @@ export declare class MemoryDb {
     /** 只更新向量行（重嵌入用）。 */
     updateL1Vec(id: string, embedding: Float32Array): boolean;
     updateL0Vec(id: string, embedding: Float32Array, recordedAt: string): boolean;
+    /**
+     * 批量更新 L1 向量行（重嵌入热路径）：单事务写入整批，替代逐条裸写——
+     * 逐条每行一次隐式事务，批量场景（万级记录重嵌）开销集中在 fsync 上。
+     * 整批失败回退逐条：好行照常入库，坏行只丢自身（向量行 id 寻址，无顺序依赖）。
+     * 返回成功写入的行数（零向量行防御性跳过、不计入）。
+     */
+    updateL1VecBatch(items: Array<{
+        id: string;
+        embedding: Float32Array;
+    }>): number;
+    /** L0 版 updateL1VecBatch（语义同：单事务 + 失败回退逐条）。recordedAt 整批统一。 */
+    updateL0VecBatch(items: Array<{
+        id: string;
+        embedding: Float32Array;
+    }>, recordedAt: string): number;
     close(): void;
 }
 /** 全零向量（cosine 未定义，不可入向量表）。reindex 侧用它区分"不可嵌入"与"写入失败"。 */

package/dist/store/sqlite.js

@@ -72,9 +72,12 @@ export class MemoryDb {
                 mkdirSync(dbDir, { recursive: true });
             const { DatabaseSync: DbSync } = require('node:sqlite');
             this.db = new DbSync(dbPath, { allowExtension: true });
-            // 并发读优化 + 有界内存（照搬官方 PRAGMA 组合）
+            // 并发读优化 + 有界内存（照搬官方 PRAGMA 组合，synchronous 为本仓新增：
+            // WAL 下官方推荐 NORMAL——批量写从"每事务一次 fsync"降为"每 checkpoint 一次"，
+            // 重嵌入/导入提速明显；代价仅是断电时丢最后若干已提交事务（只丢不损，无损坏风险））
             this.db.exec('PRAGMA busy_timeout = 5000');
             this.db.exec('PRAGMA journal_mode = WAL');
+            this.db.exec('PRAGMA synchronous = NORMAL');
             this.db.exec('PRAGMA cache_size = -65536');
             this.db.exec('PRAGMA mmap_size = 134217728');
             this.db.exec('PRAGMA wal_autocheckpoint = 1000');
@@ -1179,6 +1182,85 @@ export class MemoryDb {
             return false;
         }
     }
+    /**
+     * 批量更新 L1 向量行（重嵌入热路径）：单事务写入整批，替代逐条裸写——
+     * 逐条每行一次隐式事务，批量场景（万级记录重嵌）开销集中在 fsync 上。
+     * 整批失败回退逐条：好行照常入库，坏行只丢自身（向量行 id 寻址，无顺序依赖）。
+     * 返回成功写入的行数（零向量行防御性跳过、不计入）。
+     */
+    updateL1VecBatch(items) {
+        if (this.degraded || !this.stmtDeleteL1Vec || !this.stmtInsertL1Vec || items.length === 0)
+            return 0;
+        try {
+            this.db.exec('BEGIN');
+            try {
+                let written = 0;
+                for (const it of items) {
+                    if (isZeroVector(it.embedding))
+                        continue;
+                    this.stmtDeleteL1Vec.run(it.id);
+                    this.stmtInsertL1Vec.run(it.id, vecToBuffer(it.embedding), new Date().toISOString());
+                    written++;
+                }
+                this.db.exec('COMMIT');
+                return written;
+            }
+            catch (err) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch {
+                    /* ignore */
+                }
+                throw err;
+            }
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} L1 向量批量写入失败，回退逐条: ${err instanceof Error ? err.message : String(err)}`);
+            let ok = 0;
+            for (const it of items)
+                if (this.updateL1Vec(it.id, it.embedding))
+                    ok++;
+            return ok;
+        }
+    }
+    /** L0 版 updateL1VecBatch（语义同：单事务 + 失败回退逐条）。recordedAt 整批统一。 */
+    updateL0VecBatch(items, recordedAt) {
+        if (this.degraded || !this.stmtDeleteL0Vec || !this.stmtInsertL0Vec || items.length === 0)
+            return 0;
+        try {
+            this.db.exec('BEGIN');
+            try {
+                let written = 0;
+                for (const it of items) {
+                    if (isZeroVector(it.embedding))
+                        continue;
+                    this.stmtDeleteL0Vec.run(it.id);
+                    this.stmtInsertL0Vec.run(it.id, vecToBuffer(it.embedding), recordedAt);
+                    written++;
+                }
+                this.db.exec('COMMIT');
+                return written;
+            }
+            catch (err) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch {
+                    /* ignore */
+                }
+                throw err;
+            }
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} L0 向量批量写入失败，回退逐条: ${err instanceof Error ? err.message : String(err)}`);
+            let ok = 0;
+            for (const it of items)
+                if (this.updateL0Vec(it.id, it.embedding, recordedAt))
+                    ok++;
+            return ok;
+        }
+    }
     close() {
         try {
             this.db.close();

package/package.json

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