dsh-prime-memory 0.25.0 → 0.26.1

package/dist/wing-backfill.js

@@ -5,19 +5,51 @@ import { parseJsonLogged } from './llm.js';
 import { isWingId, normTags } from './metadata-validators.js';
 import { yieldLoop } from './util/yield.js';
 /** 单次任务处理上限默认值(可被 cfg.backfill.maxRecords 覆盖;分批触发,可重复执行)。 */
-const DEFAULT_MAX_RECORDS = 300;
+const DEFAULT_MAX_RECORDS = 40;
 /** 墙钟预算默认值 ms(可被 cfg.backfill.timeBudgetMs 覆盖):超时剩留待再次触发。 */
-const DEFAULT_TIME_BUDGET_MS = 120_000;
-/** 每块条数(一次 LLM 调用判定的记录数)。 */
-const CHUNK = 20;
-const state = { running: false, updated: 0, failed: 0 };
+const DEFAULT_TIME_BUDGET_MS = 1_800_000;
+/** 单次 LLM 请求默认超时(可被 cfg.backfill.callTimeoutMs 覆盖)。 */
+const DEFAULT_CALL_TIMEOUT_MS = 240_000;
+const state = { running: false, updated: 0, failed: 0, cancelled: false };
+/**
+ * 人工中止信号。置位后：①不再取新记录；②在飞的那条先拿**宽限**(cancelGraceMs)
+ * 自然收工；③**宽限到期强杀**在飞请求——没有③的话「中止」最坏要等满 callTimeoutMs。
+ */
+let abortRequested = false;
+/** 本轮在飞请求的强杀器（start 入口新建）。 */
+let runAbort = null;
+/** 中止宽限计时器（一次性）。 */
+let graceTimer = null;
+/** 本轮生效的中止宽限（启动时从 cfg 读定，已钳位）。 */
+let graceMs = 15_000;
+/**
+ * 中止宽限钳位。**硬界 30s**（用户定：中止必须在 30s 内强停）——无论 YAML 写了多少，
+ * 都不会超过这个值；未配置/非法取默认 15s。
+ */
+function clampGraceMs(raw) {
+    const n = typeof raw === 'number' && Number.isFinite(raw) ? Math.round(raw) : 15_000;
+    return Math.min(30_000, Math.max(0, n));
+}
+/** 请求中止本轮（空闲时无副作用）；返回后中止是**有界**的：最多等 graceMs(≤30s)。 */
+export function cancelWingBackfill() {
+    if (!state.running)
+        return { cancelled: false, running: false };
+    abortRequested = true;
+    if (graceTimer === null) {
+        graceTimer = setTimeout(() => {
+            graceTimer = null;
+            if (state.running)
+                runAbort?.abort();
+        }, Math.max(0, graceMs));
+    }
+    return { cancelled: true, running: true };
+}
 export function wingBackfillState() {
     return { ...state };
 }
-const SYSTEM_PROMPT = '你是记忆库的 Wing 标注器。给你若干条记忆(带 id),为每条判断其内容属于哪个 Wing,输出 JSON 数组:' +
-    '[{"id":"<原id>","wing":"<域id>"}]。wing 只能从给定候选列表中选,且必须是列表里的原文 id;' +
-    '列表外的值一律无效(会被丢弃)。横跨多域或确实无法归入任何角时选 general。' +
-    '注意 id 必须原样照抄,不要改写、截断或改用序号。只输出 JSON,不要多余文字。';
+const SYSTEM_PROMPT = '你是记忆库的 Wing 标注器。给你一条记忆,判断其内容属于哪个 Wing,输出 JSON 对象:{"wing":"<域id>"}。' +
+    'wing 只能从给定候选列表中选,且必须是列表里的原文 id;列表外的值一律无效(会被丢弃)。' +
+    '横跨多域或确实无法归入任何角时选 general。只输出 JSON,不要多余文字。';
 /** 启动后台回填;已在运行返回 false(单飞)。 */
 export function startWingBackfill(deps) {
     if (state.running)
@@ -25,6 +57,13 @@ export function startWingBackfill(deps) {
     state.running = true;
     state.updated = 0;
     state.failed = 0;
+    state.cancelled = false;
+    abortRequested = false;
+    if (graceTimer !== null) {
+        clearTimeout(graceTimer);
+        graceTimer = null;
+    }
+    runAbort = new AbortController();
     void run(deps).finally(() => {
         state.running = false;
         deps.logger.info(`[memory] wing 回填结束:成功 ${state.updated} 条,失败 ${state.failed} 条`);
@@ -35,12 +74,14 @@ async function run(deps) {
     const { ctx, cfg, backend, logger } = deps;
     const MAX_RECORDS = cfg.backfill?.maxRecords ?? DEFAULT_MAX_RECORDS;
     const TIME_BUDGET_MS = cfg.backfill?.timeBudgetMs ?? DEFAULT_TIME_BUDGET_MS;
+    graceMs = clampGraceMs(cfg.backfill?.cancelGraceMs);
+    const callTimeoutMs = cfg.backfill?.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
     const halls = normWingEnabled(cfg.hall?.enabled);
     if (halls.length === 0) {
         logger.warn('[memory] wing 回填跳过:wing.enabled 为空(打标功能已关闭)');
         return;
     }
-    // 墙钟预算(cfg.backfill.timeBudgetMs,默认 120s):超时即停,剩余留待再次触发(任务本身设计为可重复执行)。
+    // 墙钟预算(cfg.backfill.timeBudgetMs):超时即停,剩余留待再次触发(任务本身设计为可重复执行)。
     // 保证后台回填不长时间占据事件循环,设置面板的状态 RPC 始终优先。
     const startedAt = Date.now();
     const candidates = [...halls, WING_FALLBACK].join(' / ');
@@ -66,125 +107,121 @@ async function run(deps) {
         }
         await yieldLoop(); // 扫描批次间让位:面板状态 RPC 优先
     }
-    let budget = Math.min(pendingIds.length, MAX_RECORDS);
+    const budget = Math.min(pendingIds.length, MAX_RECORDS);
     logger.info(`[memory] wing 回填启动:未打标 ${pendingIds.length} 条,本次上限 ${budget} 条(候选 ${candidates})`);
-    for (let offset = 0; offset < pendingIds.length && budget > 0; offset += CHUNK) {
+    // 逐条串行:取一条 → 送标 → 当场写回。不攒批、不合并(爆炸半径锁在 1 条)。
+    const ids = pendingIds.slice(0, budget);
+    for (let i = 0; i < ids.length; i++) {
+        if (abortRequested) {
+            state.cancelled = true;
+            logger.info(`[memory] wing 回填：已按请求中止,本轮完成 ${i} 条,剩 ${ids.length - i} 条留待再触发`);
+            break;
+        }
         if (Date.now() - startedAt > TIME_BUDGET_MS) {
-            logger.info(`[memory] wing 回填:墙钟预算(${TIME_BUDGET_MS / 1000}s)用尽,剩余 ${pendingIds.length - offset} 条留待再次触发`);
+            logger.info(`[memory] wing 回填:墙钟预算(${TIME_BUDGET_MS / 1000}s)用尽,剩余 ${ids.length - i} 条留待再次触发`);
             break;
         }
-        // 标注器需要 content 才能构造提示词,而扫描阶段只取了轻量投影 →
-        // 按 id 精确补水(主键索引),每批 20 条,不做全量回填。
-        const hydrated = await backend.getByIds(pendingIds.slice(offset, offset + CHUNK));
-        const chunk = hydrated.filter(pickChunk);
-        if (chunk.length === 0)
+        // 标注器需要 content 才能构造提示词,而扫描阶段只取了轻量投影 → 按 id 精确补水(主键索引)。
+        const [rec] = await backend.getByIds([ids[i]]);
+        if (!rec) {
+            state.failed++;
             continue;
-        budget -= chunk.length;
-        const labeled = await labelWingChunk(ctx, cfg, logger, chunk, candidates);
-        for (const { record, wing } of labeled) {
-            // 最小写回:只改 metadata(hall 是磁盘兼容键,不改名)。
-            // 这里**必须**用 patchMetadata 而非 upsert——批量巡检路径不持有正文,
-            // 用 upsert 会把 content 写成空(数据静默丢失,已由 l1-paging 测试钉死)。
-            const meta = { ...(record.metadata ?? {}), hall: wing };
-            if (await backend.patchMetadata(record.id, meta))
-                state.updated++;
-            else
+        }
+        const wing = await labelWingOne(ctx, cfg, logger, rec, candidates, callTimeoutMs, runAbort?.signal);
+        if (wing === null) {
+            // 中止强杀导致的失败不计入 failed（不是模型/网络的错，是中止信号）
+            if (!abortRequested)
                 state.failed++;
-            // 写回间让位:面板状态 RPC 优先于后台批次
-            await yieldLoop();
+            continue;
         }
+        // 最小写回:只改 metadata(hall 是磁盘兼容键,不改名)。
+        // 这里**必须**用 patchMetadata 而非 upsert——巡检路径不持有正文,
+        // 用 upsert 会把 content 写成空(数据静默丢失,已由 l1-paging 测试钉死)。
+        const meta = { ...(rec.metadata ?? {}), hall: wing };
+        if (await backend.patchMetadata(rec.id, meta))
+            state.updated++;
+        else
+            state.failed++;
+        await yieldLoop(); // 写回间让位:面板状态 RPC 优先于后台逐条
     }
 }
-/** 回填只处理活跃记录可安全加速,但 retired 行的 metadata_json 同样保留且 restore 后可见——
- *  写回走 `patchMetadata`(只改 metadata_json),对 retired 行与活跃行行为一致(不复活、不动正文),
- *  因此这里不做活性过滤,口径与迁移一致(全量)。 */
-function pickChunk(_r) {
-    return true;
-}
-/** Wing 标注器(导出):一键回填与反刍重标定共用同一 LLM 路径与措辞。 */
-export async function labelWingChunk(ctx, cfg, logger, chunk, candidates) {
-    const list = chunk.map((r, i) => `${i + 1}. id=${r.id}\n${r.content.slice(0, 300)}`).join('\n\n');
-    const user = `候选 Wing:${candidates}\n\n记忆列表:\n${list}`;
+/**
+ * Wing 标注器(导出):一键回填与反刍重标定共用同一 LLM 路径与措辞。
+ *
+ * **一个请求只装一条**(旧名 `labelWingChunk`,多条一次,已废)。返回该条的 wing,
+ * 失败/字段缺失/值非法返回 null(记账归调用方,本函数不动全局状态)。
+ */
+export async function labelWingOne(ctx, cfg, logger, rec, candidates, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS, 
+/** 本轮中止信号（可选）：与单次超时**取或**，宽限到期后由它当场掐断请求。 */
+externalSignal) {
+    const user = `候选 Wing:${candidates}\n\n记忆:\n${rec.content.slice(0, 600)}`;
     try {
         const raw = await callLLM(ctx, cfg, {
             system: SYSTEM_PROMPT,
             user,
-            maxTokens: 4096,
+            maxTokens: 1024,
             layer: 'l1-extract',
+            // 打标是直答任务：显式关思考（不然思考模型把预算烧在 reasoning 上吐 0 字符）。
+            reasoningEffort: 'off',
             logger,
+            signal: (() => {
+                const t = AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS);
+                return externalSignal ? AbortSignal.any([t, externalSignal]) : t;
+            })(),
         });
         const parsed = parseJsonLogged(raw, 'wing 回填', logger);
-        if (!Array.isArray(parsed))
-            return [];
-        const byId = new Map(chunk.map((r) => [r.id, r]));
-        const out = [];
-        for (const item of parsed) {
-            // 字段名必须与提示词一致读 `wing`。历史上此处误读 `item.hall`(提示词早已是 wing),
-            // 导致整批静默丢弃——日志只增长 llmSkipped 而 wingLabeled 恒为 0,排查代价极高。
-            const rawWing = typeof item?.wing === 'string' ? item.wing.trim() : '';
-            const record = typeof item?.id === 'string' ? byId.get(item.id) : undefined;
-            if (!record) {
-                logger.warn(`[memory] wing 回填:id 配对失败,已丢弃(id=${String(item?.id).slice(0, 40)})`);
-                continue;
-            }
-            // 字段缺失与值非法分开报:否则模型若又换了字段名,日志只会显示"非法值「」",
-            // 看不出真实原因是**读不到字段**——这正是上次事故难以定位的原因。
-            if (rawWing === '') {
-                logger.warn(`[memory] wing 回填:返回项缺少 wing 字段,已丢弃(id=${record.id};实际键=${Object.keys(item ?? {}).join('|')})`);
-                continue;
-            }
-            // 枚举校验:非法值不写入(含认知 hall 值如 facts/events —— 两者值域不相交)
-            if (!isWingId(rawWing)) {
-                logger.warn(`[memory] wing 回填:非法 wing 值「${rawWing.slice(0, 32)}」已丢弃(id=${record.id})`);
-                continue;
-            }
-            out.push({ record, wing: rawWing });
+        // 通吃两种形状:模型偶尔无视“只输出一个对象”而回单元素数组(或带 id 的旧形状)。
+        const obj = Array.isArray(parsed) ? parsed[0] : parsed;
+        // 字段名必须与提示词一致读 `wing`。历史上此处误读 `item.hall`(提示词早已是 wing),
+        // 导致整批静默丢弃——日志只增长 llmSkipped 而 wingLabeled 恒为 0,排查代价极高。
+        const rawWing = typeof obj?.wing === 'string' ? obj.wing.trim() : '';
+        // 字段缺失与值非法分开报:否则模型若又换了字段名,日志只会显示"非法值「」",
+        // 看不出真实原因是**读不到字段**——这正是上次事故难以定位的原因。
+        if (rawWing === '') {
+            logger.warn(`[memory] wing 回填:返回缺少 wing 字段,已丢弃(id=${rec.id};实际键=${Object.keys(obj ?? {}).join('|')})`);
+            return null;
+        }
+        // 枚举校验:非法值不写入(含认知 hall 值如 facts/events —— 两者值域不相交)
+        if (!isWingId(rawWing)) {
+            logger.warn(`[memory] wing 回填:非法 wing 值「${rawWing.slice(0, 32)}」已丢弃(id=${rec.id})`);
+            return null;
         }
-        return out;
+        return rawWing;
     }
     catch (err) {
-        logger.warn(`[memory] wing 回填块失败(跳过 ${chunk.length} 条,原记录未改): ${err instanceof Error ? err.message : String(err)}`);
-        state.failed += chunk.length;
-        return [];
+        logger.warn(`[memory] wing 回填单条失败(id=${rec.id},原记录未改): ${err instanceof Error ? err.message : String(err)}`);
+        return null;
     }
 }
-const TAGGER_SYSTEM_PROMPT = '你是记忆库的标签标注器。给你若干条记忆(带 id),为每条提炼 1-3 个能概括其主题的英文 slug 标签' +
+const TAGGER_SYSTEM_PROMPT = '你是记忆库的标签标注器。给你一条记忆,为它提炼 1-3 个能概括其主题的英文 slug 标签' +
     '(小写字母/数字/连字符,如 graphql-switch、riley-college-apps)。标签从内容中涌现,不从预定义列表选;' +
-    '输出 JSON 数组:[{"id":"<原id>","tags":["slug1","slug2"]}]。只输出 JSON,不要多余文字。';
+    '输出 JSON 对象:{"tags":["slug1","slug2"]}。只输出 JSON,不要多余文字。';
 /**
- * 涌现标签标注器(导出):为一批记录提炼 slug 标签(tags)——Room 的前身。
- * 与 Wing 标注共用 LLM 路由(layer='l1-extract');失败返回空数组,调用方零改动。
+ * 涌现标签标注器(导出):为**一条**记录提炼 slug 标签(tags)——Room 的前身。
+ * 一个请求只装一条(旧名 `tagChunk`,多条一次,已废)。失败返回 null;合法但为空返回 []。
  */
-export async function tagChunk(ctx, cfg, logger, chunk) {
-    const list = chunk.map((r, i) => `${i + 1}. id=${r.id}\n${r.content.slice(0, 300)}`).join('\n\n');
+export async function tagOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS) {
+    const user = `记忆:\n${rec.content.slice(0, 600)}`;
     try {
         const raw = await callLLM(ctx, cfg, {
             system: TAGGER_SYSTEM_PROMPT,
-            user: `记忆列表:\n${list}`,
-            maxTokens: 4096,
+            user,
+            maxTokens: 1024,
             layer: 'l1-extract',
+            // 同 wing 标：直答任务，显式关思考。
+            reasoningEffort: 'off',
             logger,
+            signal: AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS),
         });
         const parsed = parseJsonLogged(raw, 'tags 标注', logger);
-        if (!Array.isArray(parsed))
-            return [];
-        const byId = new Map(chunk.map((r) => [r.id, r]));
-        const out = [];
-        for (const item of parsed) {
-            const record = typeof item?.id === 'string' ? byId.get(item.id) : undefined;
-            if (!record) {
-                logger.warn(`[memory] tags 标注:id 配对失败,已丢弃(id=${String(item?.id).slice(0, 40)})`);
-                continue;
-            }
-            // 归一 + 校验在标注器内部就做一遍(写回点仍会再过一次,双保险)
-            const tags = normTags(item?.tags);
-            if (tags.length > 0)
-                out.push({ record, tags });
-        }
-        return out;
+        const obj = Array.isArray(parsed) ? parsed[0] : parsed;
+        if (!obj || typeof obj !== 'object')
+            return null;
+        // 归一 + 校验在标注器内部就做一遍(写回点仍会再过一次,双保险)
+        return normTags(obj.tags);
     }
     catch (err) {
-        logger.warn(`[memory] tags 标注块失败(跳过 ${chunk.length} 条,原记录未改): ${err instanceof Error ? err.message : String(err)}`);
-        return [];
+        logger.warn(`[memory] tags 标注单条失败(id=${rec.id},原记录未改): ${err instanceof Error ? err.message : String(err)}`);
+        return null;
     }
 }

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "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.25.0",
+  "version": "0.26.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",