dsh-prime-memory 0.26.0 → 0.26.1

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/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/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;

package/dist/tools/skills.js

@@ -1,10 +1,8 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 const MUTATE_OFF_NOTICE = '记忆写删未开放：请在记忆库面板开启「高权限模式」后，模型才能改动技能。';
-export function registerSkillTools(ctx, cfg, skills, logger, live) {
-    if (!(cfg.skills.enabled === true || live.get().skillsEnabled === true))
-        return; // 默认关：部署 cfg 或看板 live 任一开才注册
+export function registerSkillTools(ctx, skills, logger, live, seals) {
     // memory_skill_list：列全部技能摘要（含 status/sessionCount，candidate 也列出供审阅）。
-    ctx.tools.register(defineTool({
+    seals.reg('skills', () => ctx.tools.register(defineTool({
         name: 'memory_skill_list',
         description: '列出已沉淀的技能(程序性记忆)摘要：id/标题/状态/档位/覆盖会话数。用于查看技能库现状与候选晋升情况。',
         parameters: {},
@@ -44,9 +42,9 @@ export function registerSkillTools(ctx, cfg, skills, logger, live) {
             }));
             return { skills: list, notice: `共 ${list.length} 个技能` };
         },
-    }));
+    })));
     // memory_skill_read：取某技能完整正文 + 步骤。
-    ctx.tools.register(defineTool({
+    seals.reg('skills', () => ctx.tools.register(defineTool({
         name: 'memory_skill_read',
         description: '读取一条技能的完整正文与步骤清单（按 id）。用于展开注入里被截断/excerpt 档的技能细节。',
         parameters: { id: { type: 'string', required: true, description: '技能 id（来自 memory_skill_list 或注入头）' } },
@@ -76,9 +74,9 @@ export function registerSkillTools(ctx, cfg, skills, logger, live) {
                 return { id, title: '', body: '', steps: [], notice: `未找到技能 ${id}` };
             return { id: s.id, title: s.title, body: s.body, steps: s.steps };
         },
-    }));
+    })));
     // memory_skill_pin：pin/unpin（高权限门）。pinned 技能不受闲置归档影响。
-    ctx.tools.register(defineTool({
+    seals.reg('skills', () => ctx.tools.register(defineTool({
         name: 'memory_skill_pin',
         description: '固定/取消固定一条技能（按 id）。固定后不参与闲置自动归档。仅用户显式要求时用；需高权限模式。',
         parameters: {
@@ -100,9 +98,9 @@ export function registerSkillTools(ctx, cfg, skills, logger, live) {
             const changed = await skills.update(id, { pinned: args?.pinned === true });
             return { notice: changed ? `已${args?.pinned === true ? '固定' : '取消固定'}技能 ${id}` : `未找到技能 ${id} 或无变化` };
         },
-    }));
+    })));
     // memory_skill_archive：归档（高权限门）；走 sidecar 生命周期，不触碰 l1_records 退场。
-    ctx.tools.register(defineTool({
+    seals.reg('skills', () => ctx.tools.register(defineTool({
         name: 'memory_skill_archive',
         description: '归档一条技能（按 id，可给原因）。归档后不再注入，但记录保留可恢复。仅用户显式要求时用；需高权限模式。',
         parameters: {
@@ -126,5 +124,5 @@ export function registerSkillTools(ctx, cfg, skills, logger, live) {
                 logger.info(`[memory] 技能归档 ${id}`);
             return { notice: done ? `已归档技能 ${id}` : `未找到技能 ${id} 或已归档` };
         },
-    }));
+    })));
 }

package/dist/wing-backfill.d.ts

@@ -28,7 +28,14 @@ export interface HallBackfillState {
     /** 本进程累计成功打标条数(重启归零;仅作观测,不作账)。 */
     updated: number;
     failed: number;
+    /** 本轮被人工中止（进端点 cancel）——与“跑完”分开报文案。 */
+    cancelled: boolean;
 }
+/** 请求中止本轮（空闲时无副作用）；返回后中止是**有界**的：最多等 graceMs(≤30s)。 */
+export declare function cancelWingBackfill(): {
+    cancelled: boolean;
+    running: boolean;
+};
 export declare function wingBackfillState(): HallBackfillState;
 /** 启动后台回填;已在运行返回 false(单飞)。 */
 export declare function startWingBackfill(deps: HallBackfillDeps): {
@@ -41,7 +48,9 @@ export declare function startWingBackfill(deps: HallBackfillDeps): {
  * **一个请求只装一条**(旧名 `labelWingChunk`,多条一次,已废)。返回该条的 wing,
  * 失败/字段缺失/值非法返回 null(记账归调用方,本函数不动全局状态)。
  */
-export declare function labelWingOne(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, rec: MemoryRecord, candidates: string, callTimeoutMs?: number): Promise<string | null>;
+export declare function labelWingOne(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, rec: MemoryRecord, candidates: string, callTimeoutMs?: number, 
+/** 本轮中止信号（可选）：与单次超时**取或**，宽限到期后由它当场掐断请求。 */
+externalSignal?: AbortSignal): Promise<string | null>;
 /**
  * 涌现标签标注器(导出):为**一条**记录提炼 slug 标签(tags)——Room 的前身。
  * 一个请求只装一条(旧名 `tagChunk`,多条一次,已废)。失败返回 null;合法但为空返回 []。

package/dist/wing-backfill.js

@@ -10,7 +10,40 @@ const DEFAULT_MAX_RECORDS = 40;
 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 };
+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 };
 }
@@ -24,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} 条`);
@@ -34,6 +74,7 @@ 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) {
@@ -71,6 +112,11 @@ async function run(deps) {
     // 逐条串行:取一条 → 送标 → 当场写回。不攒批、不合并(爆炸半径锁在 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)用尽,剩余 ${ids.length - i} 条留待再次触发`);
             break;
@@ -81,9 +127,11 @@ async function run(deps) {
             state.failed++;
             continue;
         }
-        const wing = await labelWingOne(ctx, cfg, logger, rec, candidates, callTimeoutMs);
+        const wing = await labelWingOne(ctx, cfg, logger, rec, candidates, callTimeoutMs, runAbort?.signal);
         if (wing === null) {
-            state.failed++;
+            // 中止强杀导致的失败不计入 failed（不是模型/网络的错，是中止信号）
+            if (!abortRequested)
+                state.failed++;
             continue;
         }
         // 最小写回:只改 metadata(hall 是磁盘兼容键,不改名)。
@@ -103,7 +151,9 @@ async function run(deps) {
  * **一个请求只装一条**(旧名 `labelWingChunk`,多条一次,已废)。返回该条的 wing,
  * 失败/字段缺失/值非法返回 null(记账归调用方,本函数不动全局状态)。
  */
-export async function labelWingOne(ctx, cfg, logger, rec, candidates, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS) {
+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, {
@@ -111,8 +161,13 @@ export async function labelWingOne(ctx, cfg, logger, rec, candidates, callTimeou
             user,
             maxTokens: 1024,
             layer: 'l1-extract',
+            // 打标是直答任务：显式关思考（不然思考模型把预算烧在 reasoning 上吐 0 字符）。
+            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;
+            })(),
         });
         const parsed = parseJsonLogged(raw, 'wing 回填', logger);
         // 通吃两种形状:模型偶尔无视“只输出一个对象”而回单元素数组(或带 id 的旧形状)。
@@ -153,6 +208,8 @@ export async function tagOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_CALL
             user,
             maxTokens: 1024,
             layer: 'l1-extract',
+            // 同 wing 标：直答任务，显式关思考。
+            reasoningEffort: 'off',
             logger,
             signal: AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS),
         });

package/dsh.plugin.json

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