dsh-prime-memory 0.26.0 → 0.26.2

package/dist/keyword-backfill.js

@@ -29,7 +29,42 @@ const state = {
     running: false, updated: 0, failed: 0,
     chunk: 1, candidates: 0, processed: 0,
     scanning: false, batchesDone: 0, batchTotal: 0, concurrency: DEFAULT_CONCURRENCY, deferred: 0,
+    cancelled: false, scanned: 0, scanTotal: 0,
 };
+/**
+ * 人工中止信号。置位后：①池子不再派新活；②已发出的请求先拿**宽限**(cancelGraceMs)
+ * 自然收工（token 不白费、已写回的全入账）；③**宽限到期强杀**在飞请求——
+ * 没有③的话「中止」最坏要等满 callTimeoutMs(240s) 才生效，等于没中止。
+ */
+let abortRequested = false;
+/** 本轮在飞请求的强杀器（runOnce 入口新建）。 */
+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。 */
+export function cancelKeywordBackfill() {
+    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 keywordBackfillState() {
     return { ...state };
 }
@@ -61,6 +96,8 @@ export function startKeywordBackfill(deps) {
     state.batchesDone = 0;
     state.batchTotal = 0;
     state.deferred = 0;
+    state.cancelled = false;
+    abortRequested = false;
     state.concurrency = clampConcurrency(deps.cfg.backfill?.concurrency);
     void runKeywordBackfillOnce(deps).finally(() => {
         state.running = false;
@@ -76,12 +113,21 @@ export function startKeywordBackfill(deps) {
  */
 export async function runKeywordBackfillOnce(deps) {
     const { cfg, backend, logger } = deps;
+    // 新一轮入口清中止信号（同 redistill：直调 runOnce 的路径不经过 startX 的复位）。
+    abortRequested = false;
+    state.cancelled = false;
+    if (graceTimer !== null) {
+        clearTimeout(graceTimer);
+        graceTimer = null;
+    }
+    runAbort = new AbortController();
     if (!cfg.keyword?.enabled) {
         logger.info('[memory] keyword 回填跳过：keyword.enabled = false（功能关，不回填）');
         return;
     }
     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 LIMIT = clampConcurrency(cfg.backfill?.concurrency);
     state.concurrency = LIMIT;
     const startedAt = Date.now();
@@ -91,6 +137,8 @@ export async function runKeywordBackfillOnce(deps) {
     let scanned = 0;
     state.scanning = true;
     for (let offset = 0;; offset += PAGE) {
+        if (abortRequested)
+            break; // 中止：扫描段也当场退出（不把最后一页白扫完）
         const page = await backend.allLite(PAGE, offset);
         if (page.length === 0)
             break;
@@ -101,6 +149,8 @@ export async function runKeywordBackfillOnce(deps) {
         }
         scanned += page.length;
         state.candidates = pendingIds.length;
+        state.scanned = scanned;
+        state.scanTotal = total;
         await yieldLoop();
     }
     state.scanning = false;
@@ -118,9 +168,11 @@ export async function runKeywordBackfillOnce(deps) {
             state.batchesDone++;
             return;
         }
-        const labeled = await labelKeywordOne(deps.ctx, cfg, logger, rec, callTimeoutMs);
+        const labeled = await labelKeywordOne(deps.ctx, cfg, logger, rec, callTimeoutMs, runAbort?.signal);
         if (!labeled) {
-            state.failed++;
+            // 中止强杀导致的失败不计入 failed（不是模型/网络的错，是中止信号）
+            if (!abortRequested)
+                state.failed++;
         }
         else {
             const meta = { ...(rec.metadata ?? {}) };
@@ -150,6 +202,8 @@ export async function runKeywordBackfillOnce(deps) {
     let budgetHit = false;
     const work = async () => {
         for (;;) {
+            if (abortRequested)
+                return; // 中止：不再取新活（在飞的那条自然跑完）
             if (budgetHit || Date.now() - startedAt > TIME_BUDGET_MS) {
                 budgetHit = true;
                 return;
@@ -168,12 +222,17 @@ export async function runKeywordBackfillOnce(deps) {
     for (;;) {
         const target = Math.max(1, Math.min(readLimit(), batch.length));
         state.concurrency = target; // 面板「并行 N」跟实时值走
-        while (!budgetHit && inFlight.size < target && cursor < batch.length)
+        while (!budgetHit && !abortRequested && inFlight.size < target && cursor < batch.length)
             spawn();
         if (inFlight.size === 0)
             break;
         await Promise.race(inFlight);
     }
+    if (abortRequested) {
+        state.cancelled = true;
+        state.deferred += Math.max(0, batch.length - state.processed);
+        logger.info(`[memory] keyword 回填：已按请求中止（在飞请求跑完即收工）,本轮完成 ${state.processed} 条,剩 ${state.deferred} 条留待再触发`);
+    }
     if (budgetHit) {
         state.deferred += Math.max(0, batch.length - state.processed);
         logger.info(`[memory] keyword 回填：墙钟预算(${Math.round(TIME_BUDGET_MS / 1000)}s)用尽,累计留待再触发 ${state.deferred} 条`);
@@ -186,7 +245,9 @@ export async function runKeywordBackfillOnce(deps) {
  * 而逐条只花秒级。记账（state.failed 等）全部归调用方——标注器不再动全局状态，
  * 否则同一条会被两处各计一次。
  */
-export async function labelKeywordOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS) {
+export async function labelKeywordOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS, 
+/** 本轮中止信号（可选）：与单次超时**取或**，宽限到期后由它当场掐断请求。 */
+externalSignal) {
     const user = `记忆:\n标题：${rec.name ?? ''}\n正文：${rec.content.slice(0, 900)}`;
     const t0 = Date.now();
     const secs = () => Math.round((Date.now() - t0) / 10);
@@ -196,8 +257,14 @@ export async function labelKeywordOne(ctx, cfg, logger, rec, callTimeoutMs = DEF
             user,
             maxTokens: LABEL_MAX_TOKENS,
             layer: 'l1-extract',
+            // 关键词/情景标注是直答任务：显式关思考，否则思考模型会把 512 预算烧在
+            // reasoning 上、正文吐 0 字符（真机 156/162 次 `llm empty output` 皆为此）。
+            reasoningEffort: 'off',
             logger,
-            signal: AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS),
+            signal: (() => {
+                const t = AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS);
+                return externalSignal ? AbortSignal.any([t, externalSignal]) : t;
+            })(),
         });
         logger.debug?.(`[memory] keyword 单条耗时 ${(Date.now() - t0) / 1000}s(id=${rec.id})`);
         const parsed = parseJsonLogged(raw, 'keyword 回填', logger);

package/dist/llm.d.ts

@@ -17,6 +17,15 @@ export interface LlmCallOptions {
     maxTokens?: number;
     temperature?: number;
     signal?: AbortSignal;
+    /**
+     * **调用级思考档位覆盖**（可选）。非空时优先于路由/层链/全局解析出的档位。
+     *
+     * 为什么需要：回填批扫（整形/关键词/wing/room）是「重排 + 拎标识」的直答任务，
+     * 不需要推理；而思考模型默认开思考，会把整个 maxTokens 预算烧在 reasoning 上、
+     * 正文吐 0 字符（真机：156/162 次 `llm empty output` 都是这么来的）。
+     * 显式传 `off` 后预算全留给答案。档位仍过一遍模型能力钳制：模型不支持 off 时不传。
+     */
+    reasoningEffort?: string;
     /** 诊断日志(缺失时静默,不影响调用) */
     logger?: MemoryLogger;
 }

package/dist/llm.js

@@ -393,8 +393,10 @@ async function callRoute(ctx, cfg, opts, route) {
     const { provider, model } = route;
     const signal = opts.signal ?? AbortSignal.timeout(cfg.llm.timeoutMs);
     // 档位按模型能力决策(跨供应商 effort 兼容):不支持的档位不传 + 告警一次,
-    // 空配置 = 自动(模型默认 → high);路由的档位候选已在链解析时定好(条目 > 全局)
-    const effort = await planDistillEffort(ctx, provider, model, route.effort, opts.logger);
+    // 空配置 = 自动(模型默认 → high);路由的档位候选已在链解析时定好(条目 > 全局)。
+    // 调用级覆盖(opts.reasoningEffort)优先——批扫靠它关掉思考，避免预算被 reasoning 吃光。
+    const routeEffort = opts.reasoningEffort ?? route.effort;
+    const effort = await planDistillEffort(ctx, provider, model, routeEffort, opts.logger);
     // 输入预算兜底:任何蒸馏调用的用户 prompt 不超过 maxInputChars
     // (L1 已在数据层分块,这里是 L2/L3 与异常场景的最后一道网)
     const user = opts.user.length > cfg.llm.maxInputChars
@@ -406,9 +408,10 @@ async function callRoute(ctx, cfg, opts, route) {
     // 配置本身就是高档时不再放大(防 ×16 双乘)
     const baseMaxTokens = opts.maxTokens ?? cfg.llm.maxTokens;
     const highTiers = HIGH_EFFORT_TIERS;
-    const triggerEffort = opts.layer
+    // 触发档位也跟调用级覆盖走：显式 off 时不得被配置里的高档触发而 ×4。
+    const triggerEffort = opts.reasoningEffort ?? (opts.layer
         ? layerEffortTrigger(cfg, layerKeyFor(opts.layer))
-        : cfg.llm.primaryEffort || cfg.llm.reasoningEffort;
+        : cfg.llm.primaryEffort || cfg.llm.reasoningEffort);
     const maxTokens = highTiers.includes(effort.effort) && !highTiers.includes(triggerEffort)
         ? layerMaxTokens(baseMaxTokens, 'high')
         : baseMaxTokens;

package/dist/memport/format.js

@@ -178,7 +178,7 @@ export function parseBundle(text) {
         declaredSha: null,
         bodyLines: [],
     };
-    const clean = text.replace(/^/, '');
+    const clean = text.replace(/^\uFEFF/, '');
     const rawLines = clean.split(/\r?\n/);
     const body = [];
     let seqLine = 0;

package/dist/pipeline/md-sync.js

@@ -321,7 +321,7 @@ export async function syncFromFiles(deps) {
             continue;
         }
         const cached = textCache.get(abs);
-        let text = '';
+        let text; // catch 分支必 continue，初始值从未被读
         try {
             text = cached ?? await readFile(abs, 'utf8');
         }

package/dist/prompts/examples.js

@@ -83,7 +83,7 @@ export const EXTRACTION_FEW_SHOT = `
 ${TITLE_GOOD_EXAMPLES.map(renderGoodExample).join('\n\n')}
 
 【不要这样】
-${TITLE_BAD_EXAMPLES.map((b) => `- ✗ ${b.title}　→ ${b.why}`).join('\n')}
+${TITLE_BAD_EXAMPLES.map((b) => `- ✗ ${b.title}\u3000→ ${b.why}`).join('\n')}
 `;
 /**
  * 各类型的"前因后果"要素表（照 G2 `NARRATIVE_CLAUSE` 写，不另造一套定义）。

package/dist/redistill-backfill.d.ts

@@ -81,7 +81,20 @@ export interface RedistillBackfillState {
     concurrency: number;
     /** 预算/上限用尽未处理、留下次的条数。 */
     deferred: number;
+    /** 本轮被人工中止（进端点 cancel）——与“预算用尽”分开报文案。 */
+    cancelled: boolean;
+    /**
+     * 扫描期已扫行数（活跃集逐页扫）/ 总行数（本模块拿不到总数，恒 0 = 未知）。
+     * 为何要暴露：扫描段原本在面板上只是一个静态「正在扫描…」，分不清在跑还是卡死。
+     */
+    scanned: number;
+    scanTotal: number;
 }
+/** 请求中止本轮（空闲时无副作用）；返回后中止是**有界**的：最多等 graceMs(≤60s)。 */
+export declare function cancelRedistillBackfill(): {
+    cancelled: boolean;
+    running: boolean;
+};
 export declare function redistillBackfillState(): RedistillBackfillState;
 /**
  * 空心标题检测：某个 `## 节名` 到下一标题之间没有实质文字。
@@ -130,4 +143,6 @@ export interface ReshapeOneResult {
  * 导出不带 ctx/cfg 以外的参数，供单测注入桩 LLM。旧名 `reshapeChunk`（多条一次）已废：
  * 合并请求把爆炸半径从 1 条放大到 20 条，而实测逐条只花 2.6s，合并毫无收益。
  */
-export declare function reshapeOne(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, rec: MemoryRecord, callTimeoutMs?: number): Promise<ReshapeOneResult | null>;
+export declare function reshapeOne(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, rec: MemoryRecord, callTimeoutMs?: number, 
+/** 本轮中止信号（可选）：与单次超时**取或**，宽限到期后由它当场掐断请求。 */
+externalSignal?: AbortSignal): Promise<ReshapeOneResult | null>;

package/dist/redistill-backfill.js

@@ -49,7 +49,42 @@ const state = {
     running: false, updated: 0, skipped: 0, failed: 0,
     chunk: 1, candidates: 0, processed: 0,
     scanning: false, batchesDone: 0, batchTotal: 0, concurrency: DEFAULT_CONCURRENCY, deferred: 0,
+    cancelled: false, scanned: 0, scanTotal: 0,
 };
+/**
+ * 人工中止信号。置位后：①池子不再派新活；②已发出的请求先拿**宽限**(cancelGraceMs)
+ * 自然收工（token 不白费、已写回的全入账）；③**宽限到期强杀**在飞请求——
+ * 没有③的话「中止」最坏要等满 callTimeoutMs(240s) 才生效，等于没中止。
+ */
+let abortRequested = false;
+/** 本轮在飞请求的强杀器（runOnce 入口新建）。 */
+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(≤60s)。 */
+export function cancelRedistillBackfill() {
+    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 redistillBackfillState() {
     return { ...state };
 }
@@ -150,6 +185,8 @@ export function startRedistillBackfill(deps) {
     state.batchesDone = 0;
     state.batchTotal = 0;
     state.deferred = 0;
+    state.cancelled = false;
+    abortRequested = false;
     state.concurrency = clampConcurrency(deps.cfg.backfill?.concurrency);
     void runRedistillBackfillOnce(deps).finally(() => {
         state.running = false;
@@ -170,6 +207,15 @@ export function startRedistillBackfill(deps) {
  */
 export async function runRedistillBackfillOnce(deps) {
     const { cfg, l1, logger } = deps;
+    // 新一轮入口清中止信号：abortRequested 是模块级，直调 runOnce 的路径（单测/未来调用方）
+    // 不经过 startX 的复位，上一轮的中止信号会粘住这一轮。
+    abortRequested = false;
+    state.cancelled = false;
+    if (graceTimer !== null) {
+        clearTimeout(graceTimer);
+        graceTimer = null;
+    }
+    runAbort = new AbortController();
     if (!cfg.redistill?.enabled) {
         logger.info('[memory] redistill 回填跳过：redistill.enabled = false（功能关，不整形）');
         return;
@@ -180,6 +226,7 @@ export async function runRedistillBackfillOnce(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 LIMIT = clampConcurrency(cfg.backfill?.concurrency);
     state.concurrency = LIMIT;
     const startedAt = Date.now();
@@ -191,6 +238,8 @@ export async function runRedistillBackfillOnce(deps) {
     let scanned = 0;
     state.scanning = true;
     for (let offset = 0;; offset += PAGE) {
+        if (abortRequested)
+            break; // 中止：扫描段也当场退出（不把最后一页白扫完）
         const page = l1.activeForSkeleton(PAGE, offset);
         if (page.length === 0)
             break;
@@ -205,6 +254,7 @@ export async function runRedistillBackfillOnce(deps) {
             targets.push(r.id);
         }
         state.candidates = targets.length;
+        state.scanned = scanned;
         await yieldLoop();
     }
     state.scanning = false;
@@ -228,9 +278,11 @@ export async function runRedistillBackfillOnce(deps) {
             state.batchesDone++;
             return;
         }
-        const item = await reshapeOne(deps.ctx, cfg, logger, rec, callTimeoutMs);
+        const item = await reshapeOne(deps.ctx, cfg, logger, rec, callTimeoutMs, runAbort?.signal);
         if (!item) {
-            state.failed++;
+            // 中止强杀导致的失败不计入 failed（不是模型/网络的错，是中止信号）
+            if (!abortRequested)
+                state.failed++;
         }
         else if (reshapePassesGate(rec.type, rec.content, item.content)) {
             const meta = { ...(rec.metadata ?? {}) };
@@ -280,6 +332,8 @@ export async function runRedistillBackfillOnce(deps) {
     let budgetHit = false;
     const work = async () => {
         for (;;) {
+            if (abortRequested)
+                return; // 中止：不再取新活（在飞的那条自然跑完）
             if (budgetHit || Date.now() - startedAt > TIME_BUDGET_MS) {
                 budgetHit = true;
                 return;
@@ -298,12 +352,17 @@ export async function runRedistillBackfillOnce(deps) {
     for (;;) {
         const target = Math.max(1, Math.min(readLimit(), batch.length));
         state.concurrency = target; // 面板「并行 N」跟着实时值走，不再停在启动值上骗人
-        while (!budgetHit && inFlight.size < target && cursor < batch.length)
+        while (!budgetHit && !abortRequested && inFlight.size < target && cursor < batch.length)
             spawn();
         if (inFlight.size === 0)
             break;
         await Promise.race(inFlight);
     }
+    if (abortRequested) {
+        state.cancelled = true;
+        state.deferred += Math.max(0, batch.length - state.processed);
+        logger.info(`[memory] redistill 回填：已按请求中止（在飞请求跑完即收工）,本轮完成 ${state.processed} 条,剩 ${state.deferred} 条留待再触发`);
+    }
     if (budgetHit) {
         state.deferred += Math.max(0, batch.length - state.processed);
         logger.info(`[memory] redistill 回填：墙钟预算(${Math.round(TIME_BUDGET_MS / 1000)}s)用尽,累计留待再触发 ${state.deferred} 条`);
@@ -315,7 +374,9 @@ export async function runRedistillBackfillOnce(deps) {
  * 导出不带 ctx/cfg 以外的参数，供单测注入桩 LLM。旧名 `reshapeChunk`（多条一次）已废：
  * 合并请求把爆炸半径从 1 条放大到 20 条，而实测逐条只花 2.6s，合并毫无收益。
  */
-export async function reshapeOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS) {
+export async function reshapeOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS, 
+/** 本轮中止信号（可选）：与单次超时**取或**，宽限到期后由它当场掐断请求。 */
+externalSignal) {
     const user = `记忆:\n类型：${rec.type}\n标题：${rec.name ?? ''}\n当前正文：${rec.content.slice(0, 1200)}`;
     // 每条都记耗时：本轮排查的就是“单条到底要多久”，没这个数就只能猜并发/超时该怎么配。
     const t0 = Date.now();
@@ -326,9 +387,16 @@ export async function reshapeOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_
             user,
             maxTokens: RESHAPE_MAX_TOKENS,
             layer: 'l1-extract',
+            // 整形是「重排 + 拎标识」的直答任务：显式关思考，否则思考模型会把预算烧在
+            // reasoning 上吐 0 字符（真机 156/162 次 `llm empty output` 皆为此）。
+            reasoningEffort: 'off',
             logger,
-            // 自己给超时信号：沿用 cfg.llm.timeoutMs(120s) 会在回退链上被掐死。
-            signal: AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS),
+            // 自己给超时信号：沿用 cfg.llm.timeoutMs(120s) 会在回退链上被掐死；
+            // 再与「本轮中止」取或——宽限到期后由它当场掐断。
+            signal: (() => {
+                const t = AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS);
+                return externalSignal ? AbortSignal.any([t, externalSignal]) : t;
+            })(),
         });
         logger.info(`[memory] redistill 单条耗时 ${secs()}s(id=${rec.id})`);
         const parsed = parseJsonLogged(raw, 'redistill 回填', logger);

package/dist/room-review.js

@@ -53,6 +53,8 @@ export async function roomCandidateOne(ctx, cfg, logger, rec, roomCatalog) {
             user,
             maxTokens: 1024,
             layer: 'l1-extract',
+            // 归类是直答任务：显式关思考（不然思考模型把预算烧在 reasoning 上吐 0 字符）。
+            reasoningEffort: 'off',
             logger,
         });
         const parsed = parseJsonLogged(raw, 'Room 候选标注', logger);

package/dist/settings.js

@@ -94,6 +94,7 @@ const ALWAYS_ON = {
     toolRuminate: true,
     toolConflict: true,
     toolMutate: true,
+    toolSkills: true,
 };
 /** 自带自定义设置页(settings.section 顶层「记忆」分节,client 半挂载):
  *  关掉宿主按 volatile 字段自动生成的表单页,避免同一个插件出现两份设置入口。
@@ -338,5 +339,6 @@ function resolveSettings(value) {
         toolRuminate: v.toolRuminate !== false,
         toolConflict: v.toolConflict !== false,
         toolMutate: v.toolMutate !== false,
+        toolSkills: v.toolSkills !== false,
     };
 }

package/dist/stats.js

@@ -32,9 +32,9 @@ import { WING_CATALOG, WING_FALLBACK } from './types.js';
 import { isRoomSlug } from './metadata-validators.js';
 import { InProcMemoryBackend } from './store/memory-backend.js';
 import { isWingCorner } from './store/session-modes.js';
-import { startWingBackfill, wingBackfillState } from './wing-backfill.js';
-import { startKeywordBackfill, keywordBackfillState } from './keyword-backfill.js';
-import { startRedistillBackfill, redistillBackfillState } from './redistill-backfill.js';
+import { startWingBackfill, wingBackfillState, cancelWingBackfill } from './wing-backfill.js';
+import { startKeywordBackfill, keywordBackfillState, cancelKeywordBackfill } from './keyword-backfill.js';
+import { startRedistillBackfill, redistillBackfillState, cancelRedistillBackfill } from './redistill-backfill.js';
 import { errDetail } from './util/filelog.js';
 import { snapshotTokenCost } from './token-cost.js';
 import { computeMaturity } from './util/maturity.js';
@@ -66,6 +66,9 @@ function backfillProgress(s) {
         batchTotal: s.batchTotal,
         concurrency: s.concurrency,
         deferred: s.deferred,
+        cancelled: s.cancelled,
+        scanned: s.scanned,
+        scanTotal: s.scanTotal,
     };
 }
 /**
@@ -1156,6 +1159,11 @@ export async function handleEndpoint(endpoint, payload, deps) {
             return v;
         }
         case 'dsh-memory/wing-backfill': {
+            // cancel=true：请求中止本轮（不硬杀在飞请求，跑完当前条即收工）。
+            if (payload?.cancel === true) {
+                cancelWingBackfill();
+                return { started: false, running: wingBackfillState().running };
+            }
             // probe=true 只读快照：不启动（UI 离开区域再回来时恢复在途任务用）。
             if (payload?.probe === true) {
                 return { started: false, running: wingBackfillState().running };
@@ -1172,6 +1180,12 @@ export async function handleEndpoint(endpoint, payload, deps) {
             // 门控看生效配置（live.keywordEnabled 覆盖部署 cfg.keyword.enabled）；关时不启动。
             const ec = effectiveCfg(cfg, live);
             const st0 = keywordBackfillState();
+            // cancel=true：请求中止本轮（不硬杀在飞请求，跑完当前条即收工）。
+            if (payload?.cancel === true) {
+                cancelKeywordBackfill();
+                const st = keywordBackfillState();
+                return { started: false, running: st.running, enabled: ec.keyword?.enabled === true, updated: st.updated, failed: st.failed, progress: backfillProgress(st) };
+            }
             // probe=true 只读快照：不启动（UI 离开区域再回来时恢复在途任务用）。
             if (payload?.probe === true) {
                 return { started: false, running: st0.running, enabled: ec.keyword?.enabled === true, updated: st0.updated, failed: st0.failed, progress: backfillProgress(st0) };
@@ -1193,6 +1207,12 @@ export async function handleEndpoint(endpoint, payload, deps) {
             // 门控看生效配置（live.redistillEnabled 覆盖部署 cfg.redistill.enabled）；关时不启动。
             const ec = effectiveCfg(cfg, live);
             const st0 = redistillBackfillState();
+            // cancel=true：请求中止本轮（不硬杀在飞请求，跑完当前条即收工）。
+            if (payload?.cancel === true) {
+                cancelRedistillBackfill();
+                const st = redistillBackfillState();
+                return { started: false, running: st.running, enabled: ec.redistill?.enabled === true, updated: st.updated, skipped: st.skipped, failed: st.failed, progress: backfillProgress(st) };
+            }
             // probe=true 只读快照：不启动（UI 离开区域再回来时恢复在途任务用）。
             if (payload?.probe === true) {
                 return { started: false, running: st0.running, enabled: ec.redistill?.enabled === true, updated: st0.updated, skipped: st0.skipped, failed: st0.failed, progress: backfillProgress(st0) };
@@ -1311,7 +1331,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 supported: live?.supported ?? false,
                 settings: sanitizeSettings(s ?? {
                     enabled: true, capture: true, distill: true, recall: true,
-                    toolRoom: true, toolGraph: true, toolRuminate: true, toolConflict: true, toolMutate: true,
+                    toolRoom: true, toolGraph: true, toolRuminate: true, toolConflict: true, toolMutate: true, toolSkills: true,
                     reasoningEffort: '', distillProvider: '', distillModel: '', distillChain: [],
                     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0, graph: 0 }, distillMaxInputChars: 0,
                     distillLayerChains: { l1: [], l2: [], l3: [] },
@@ -1364,7 +1384,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
             const patch = (payload ?? {});
             const clean = {};
             // 布尔开关组:memoryMutate(高权限写删门)与主开关同列;conflictFreeze(§C 人工冲突裁决)
-            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'skillsEnabled', 'keywordEnabled', 'redistillEnabled', 'mdSyncEnabled', 'memportEnabled', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate']) {
+            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'skillsEnabled', 'keywordEnabled', 'redistillEnabled', 'mdSyncEnabled', 'memportEnabled', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate', 'toolSkills']) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }

package/dist/store/l1-snapshot.js

@@ -388,7 +388,7 @@ export async function exportThenPurge(db, dataDir, ids, reason, logger, now = ne
     // 门禁第二半——**批次级投影**。不再拿整库哈希当门禁：那会把“本批逐字未动、但库里有
     // 别的东西被并发改过”误判成不安全，而事实恰好相反——要删的那批在快照里完整可信，
     // 删错了能原样回灌。整库漂移仍计数（它是要给人看的信息），但它不拦住删除。
-    let subset = [];
+    let subset; // try 内先赋值后读，初始空数组从未被用
     let otherChanged = 0;
     try {
         const want = new Set(ids);

package/dist/tools/index.d.ts

@@ -10,6 +10,15 @@ import type { SceneStore } from '../store/scenes.js';
 import type { SessionModeStore } from '../store/session-modes.js';
 import type { MemoryFamily, MemoryLogger } from '../types.js';
 import type { RoomRegistryStore } from '../store/rooms-registry.js';
+/**
+ * 封印登记面:把某个工具组的延迟注册交给 {@link registerMemoryTools} 的封印机制。
+ * 组名见 `toolSealed` 的 switch;登记后是否真正注册由当前封印状态决定,
+ * 并在 `loader/volatile-update` 时随 `applyToolSeals` 重放(热更)。
+ */
+export interface ToolSealRegistry {
+    /** 登记一个工具组的一次性注册器;`make()` 须返回 `ctx.tools.register` 的 disposer。 */
+    reg(group: string, make: () => () => void): void;
+}
 export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, stores: {
     l0: L0Store;
     l1: L1Store;
@@ -25,4 +34,4 @@ export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, sto
 /** 反刍控制器(可选:未装配时 ruminate 工具返回未启用提示)。 */
 ruminate?: RuminateController, 
 /** Room 注册表(分类管理 beta.4;缺省 = memory_room_admin 返回未装配提示)。 */
-roomRegistry?: RoomRegistryStore): void;
+roomRegistry?: RoomRegistryStore): ToolSealRegistry;

package/dist/tools/index.js

@@ -52,7 +52,7 @@ ruminate,
 /** Room 注册表(分类管理 beta.4;缺省 = memory_room_admin 返回未装配提示)。 */
 roomRegistry) {
     if (!cfg.tools)
-        return;
+        return { reg: () => { } };
     // ── 工具分组封印(v0.21.0):sealable 组的注册经 reg() 登记,按 live 开关动态
     // 注册/反注册。封印 = 从模型工具列表消失(反注册),不是执行期拒绝;开关经
     // 设置页 volatile 热更(loader/volatile-update)即时生效,无需重启。
@@ -60,6 +60,9 @@ roomRegistry) {
     // memory_receipts)与槽位三件(slots.ts)不参与封印。
     const toolDisposers = new Map();
     const toolMakers = new Map();
+    // 技能组是「功能开关 + 封印」双条件:功能关(部署 cfg.skills.enabled 与 live.skillsEnabled 取或)或
+    // 封印(toolSkills===false)任一满足即不注册——功能关时保持零表面积,开门后仍可单独封印。
+    const skillsFeatureOn = () => cfg.skills.enabled === true || live.get().skillsEnabled === true;
     const toolSealed = (group) => {
         const snap = live.get();
         switch (group) {
@@ -68,6 +71,7 @@ roomRegistry) {
             case 'ruminate': return snap.toolRuminate === false;
             case 'conflict': return snap.toolConflict === false;
             case 'mutate': return snap.toolMutate === false;
+            case 'skills': return !skillsFeatureOn() || snap.toolSkills === false;
             default: return false;
         }
     };
@@ -1412,6 +1416,8 @@ roomRegistry) {
         ctx.on('loader/volatile-update', () => applyToolSeals());
     }
     logger.info('[memory] 工具已注册: memory_search / conversation_search / memory_read_scene / memory_receipts / memory_search_graph / memory_expand_graph_node,及高权限 memory_add/memory_import/memory_delete / memory_resolve_conflict / memory_ruminate / memory_ruminate_cancel / memory_ruminate_status');
+    // 技能组(registerSkillTools)在注册期经本面登记,随 volatile 热更重放封印。
+    return { reg };
 }
 /** 凭证回溯的人类可读渲染(含"还有多少条没显示")。 */
 function renderReceipts(dimension, items, total) {

package/dist/tools/skills.d.ts

@@ -1,13 +1,16 @@
 /**
- * 技能工具面（轨2）。**整块仅在 cfg.skills.enabled 时注册**——默认关时零表面积
- * （对齐 benchControl"生产部署零表面积"先例，避免注册了却被门控的空壳工具污染模型工具列表）。
+ * 技能工具面（轨2）。**经宿主封印机制登记**（`seals.reg('skills', …)`），不再自行判门——
+ * 是否真正注册由 `registerMemoryTools` 的 `toolSealed('skills')` 决定：
+ *   - 功能关（部署 `cfg.skills.enabled` 与 live `skillsEnabled` 取或为 false）⇒ 封印，零表面积；
+ *   - 功能开但 `live.toolSkills === false` ⇒ 封印，从模型工具列表移除。
+ * 两者都随 `loader/volatile-update` 热更（面板拨开关即时注册/反注册，无需重启）。
  *
  * 读工具 list/read；写工具 pin/archive 过 live.memoryMutate 高权限门（与 memory_add 同门）。
  * 技能不是 memory `type`，这些工具只操作 SkillStore sidecar，不触碰 l1_records / ADD_TYPES / prompt 词表。
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { MemoryConfig } from '../config.js';
 import type { LiveSettingsHandle } from '../settings.js';
 import type { SkillStore } from '../store/skill-store.js';
 import type { MemoryLogger } from '../types.js';
-export declare function registerSkillTools(ctx: Context, cfg: MemoryConfig, skills: SkillStore, logger: MemoryLogger, live: LiveSettingsHandle): void;
+import type { ToolSealRegistry } from './index.js';
+export declare function registerSkillTools(ctx: Context, skills: SkillStore, logger: MemoryLogger, live: LiveSettingsHandle, seals: ToolSealRegistry): void;