dsh-prime-memory 0.20.4 → 0.22.1

package/CHANGELOG.md

@@ -17,6 +17,13 @@
   - **建议状态(`longtask-hint-get`)以纯端点提供**:判定 = 上下文占用达 `contextThresholdPct` 或 todo 漂移达 `driftThreshold`(部署配置可调);配合 `longtask-compress-tail` 作手动压缩入口。
   - **撤下浮动球 UI(`client/src/longtask-fab.ts`;beta.1 起曾随包发布)**:悬浮建议面板的归属本在 context-compression 侧(「建议启动压缩」是其领域),pm 属误载——2026-10-02 用户裁定撤下。撤下不违座位契约(settings.section 恰一个 + 输入栏 pill,body 单例不占座位),但全应用级 overlay 会与其他插件的悬浮 UI 抢占屏幕角落;长任务开关与手动压缩入口待长任务定版时落记忆设置分节。
   - **`session-mode-set` 的 `mode` 转为可选**:与 `longTask` 二选一必传——纯切长任务开关不再被迫发送档位(旧客户端恒传 mode,行为不变)。响应 `mode` 改回当前生效值。
+## [0.21.0] — 2026-10-04
+
+### 新增
+
+- **工具分组封印（记忆库面板 → 记忆 → 工具封印）**:5 组开关(room 管理 / graph 图谱 / ruminate 反刍 / conflict 冲突 / mutate 写删,覆盖 13 个工具)。关闭 = 该组工具**不注册**,从模型工具列表直接消失(不是执行期拒绝);翻转经 volatile 热更即时生效,无需重启。核心读(memory_search / memory_read_scene / memory_receipts / conversation_search)与槽位三件不受控。背景:多数分组工具(如 Room 治理、反刍)日常使用频率极低,常驻工具列表徒占注意力并诱导模型误调用。
+- **memory_slot_write 的 mem_ 引用存在性校验**:refs 中 `mem_*` 形态的 L1 record_id 写入前经 `getByIds` 存在性校验,幻觉/拼错的 id 直接拒绝并提示走 memory_search——保证"search 激活的记忆"进入槽位引用的必然是真实记录(brief 侧的名称简述解析因此有可靠输入)。文件路径/URL 类 refs 不校验。
+
 ## [0.20.4] — 2026-10-04(本地构建,未发布)
 
 ### 修复

package/dist/client.js

@@ -229,7 +229,8 @@ var __defProp = Object.defineProperty;
 		    "  --dsh-mem-bg-card: var(--dsw-alias-bg-layer-2, #ffffff);",
 		    "  --dsh-mem-bg-inset: var(--dsw-alias-bg-overlay, #e9ecf2);",
 		    "  --dsh-mem-bg-hover: var(--dsw-alias-interactive-bg-hover, rgba(38,49,72,0.06));",
-		    "  --dsh-mem-bg-pop: var(--dsw-specific-menu, var(--dsw-alias-bg-layer-3, #ffffff));",
+		    "  --dsh-mem-bg-pop: var(--dsw-alias-bg-layer-3, #ffffff);",
+		    "  --dsh-mem-bg-pop-base: var(--dsw-alias-bg-primary, #ffffff);",
 		    "  --dsh-mem-border: var(--dsw-alias-border-l2, rgba(0,0,0,0.10));",
 		    "  --dsh-mem-border-strong: var(--dsw-alias-border-l3, rgba(0,0,0,0.12));",
 		    "  --dsh-mem-border-pop: var(--dsw-alias-border-inverted, rgba(0,0,0,0));",
@@ -272,7 +273,8 @@ var __defProp = Object.defineProperty;
 		    "  --dsh-mem-bg-card: var(--dsw-alias-bg-layer-2, #2c2c2e);",
 		    "  --dsh-mem-bg-inset: var(--dsw-alias-bg-layer-1, #232324);",
 		    "  --dsh-mem-bg-hover: var(--dsw-alias-interactive-bg-hover, rgba(255,255,255,0.08));",
-		    "  --dsh-mem-bg-pop: var(--dsw-specific-menu, var(--dsw-alias-bg-layer-3, #353638));",
+		    "  --dsh-mem-bg-pop: var(--dsw-alias-bg-layer-3, #353638);",
+		    "  --dsh-mem-bg-pop-base: var(--dsw-alias-bg-primary, #1b1c1e);",
 		    "  --dsh-mem-border: var(--dsw-alias-border-l2, rgba(255,255,255,0.12));",
 		    "  --dsh-mem-border-strong: var(--dsw-alias-border-l3, rgba(255,255,255,0.16));",
 		    "  --dsh-mem-border-pop: var(--dsw-alias-border-inverted, rgba(255,255,255,0.06));",
@@ -350,7 +352,8 @@ var __defProp = Object.defineProperty;
 		    "  position: absolute; top: calc(100% + 6px); left: 0; z-index: 30;",
 		    "  min-width: 100%; width: max-content; max-width: 340px; max-height: 264px;",
 		    "  overflow-y: auto; overscroll-behavior: contain; padding: 4px;",
-		    "  background: var(--dsh-mem-bg-pop); border: 1px solid var(--dsh-mem-border-pop);",
+		    "  // 不透明实底:基色垫底+别名色整层叠印(别名即使带 alpha 也被垫死),2026-10-09 用户修复",
+		    "  background: linear-gradient(var(--dsh-mem-bg-pop), var(--dsh-mem-bg-pop)) , var(--dsh-mem-bg-pop-base); border: 1px solid var(--dsh-mem-border-pop);",
 		    "  border-radius: 12px; box-shadow: var(--dsh-mem-shadow-pop);",
 		    "}",
 		    ".dsh-mem-pop-opt {",
@@ -434,7 +437,7 @@ var __defProp = Object.defineProperty;
 		    ".dsh-mem-popover {",
 		    "  border-radius: 12px;",
 		    "  border: 1px solid var(--dsh-mem-border-pop);",
-		    "  background: var(--dsh-mem-bg-pop);",
+		    "  background: linear-gradient(var(--dsh-mem-bg-pop), var(--dsh-mem-bg-pop)) , var(--dsh-mem-bg-pop-base);",
 		    "  box-shadow: var(--dsh-mem-shadow-pop);",
 		    "  color: var(--dsh-mem-text-1);",
 		    "}",
@@ -3118,6 +3121,11 @@ var __defProp = Object.defineProperty;
 		  }
 		  const mutate = settingsData && settingsData.settings ? !!settingsData.settings.memoryMutate : false;
 		  const cfEnabled = settingsData && settingsData.settings ? !!settingsData.settings.conflictFreeze : false;
+		  const toolRoom = settingsData && settingsData.settings ? settingsData.settings.toolRoom !== false : true;
+		  const toolGraph = settingsData && settingsData.settings ? settingsData.settings.toolGraph !== false : true;
+		  const toolRuminate = settingsData && settingsData.settings ? settingsData.settings.toolRuminate !== false : true;
+		  const toolConflict = settingsData && settingsData.settings ? settingsData.settings.toolConflict !== false : true;
+		  const toolMutate = settingsData && settingsData.settings ? settingsData.settings.toolMutate !== false : true;
 		  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { children: [
 		    settingsData && settingsData.supported === false ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("p", { style: S.hint, children: "settings 服务不可用，记忆模式开关未启用（记忆保持全开）。" }) : settingsData ? /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { style: S.switchPanel, children: [
 		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { style: S.panelLabel, children: "记忆模式" }),
@@ -3180,6 +3188,62 @@ var __defProp = Object.defineProperty;
 		          }
 		        }
 		      ),
+		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { style: S.panelLabel, children: "工具封印" }),
+		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+		        SwitchRow,
+		        {
+		          label: "Room 管理工具",
+		          desc: toolRoom ? "已注册：memory_room_admin / memory_room_review（目录治理）" : "已封印：两个工具从模型工具列表移除",
+		          checked: toolRoom,
+		          onChange: (v) => {
+		            toggle("toolRoom", v);
+		          }
+		        }
+		      ),
+		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+		        SwitchRow,
+		        {
+		          label: "图谱工具",
+		          desc: toolGraph ? "已注册：memory_search_graph / memory_expand_graph_node" : "已封印：图谱读工具从模型工具列表移除",
+		          checked: toolGraph,
+		          onChange: (v) => {
+		            toggle("toolGraph", v);
+		          }
+		        }
+		      ),
+		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+		        SwitchRow,
+		        {
+		          label: "反刍工具",
+		          desc: toolRuminate ? "已注册：memory_ruminate / _cancel / _status" : "已封印：反刍三件从模型工具列表移除",
+		          checked: toolRuminate,
+		          onChange: (v) => {
+		            toggle("toolRuminate", v);
+		          }
+		        }
+		      ),
+		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+		        SwitchRow,
+		        {
+		          label: "冲突工具",
+		          desc: toolConflict ? "已注册：memory_conflicts / _rejected / resolve_conflict" : "已封印：冲突三件从模型工具列表移除",
+		          checked: toolConflict,
+		          onChange: (v) => {
+		            toggle("toolConflict", v);
+		          }
+		        }
+		      ),
+		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+		        SwitchRow,
+		        {
+		          label: "写删工具",
+		          desc: toolMutate ? "已注册：memory_add / memory_import / memory_delete（仍需高权限模式）" : "已封印：L1 写删工具从模型工具列表移除（槽位三件不受此开关影响）",
+		          checked: toolMutate,
+		          onChange: (v) => {
+		            toggle("toolMutate", v);
+		          }
+		        }
+		      ),
 		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { style: S.panelLabel, children: "人工冲突裁决" }),
 		      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
 		        SwitchRow,

package/dist/config.d.ts

@@ -322,6 +322,11 @@ export declare function liveSettingsSchema(): Schema<NoInfer<Schemastery.ObjectS
     embedRemoteDimensions: Schema<number, number, "defined">;
     memoryMutate: Schema<boolean, boolean, "defined">;
     conflictFreeze: Schema<boolean, boolean, "defined">;
+    toolRoom: Schema<boolean, boolean, "defined">;
+    toolGraph: Schema<boolean, boolean, "defined">;
+    toolRuminate: Schema<boolean, boolean, "defined">;
+    toolConflict: Schema<boolean, boolean, "defined">;
+    toolMutate: Schema<boolean, boolean, "defined">;
 }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
     enabled: Schema<boolean, boolean, "defined">;
     capture: Schema<boolean, boolean, "defined">;
@@ -419,6 +424,11 @@ export declare function liveSettingsSchema(): Schema<NoInfer<Schemastery.ObjectS
     embedRemoteDimensions: Schema<number, number, "defined">;
     memoryMutate: Schema<boolean, boolean, "defined">;
     conflictFreeze: Schema<boolean, boolean, "defined">;
+    toolRoom: Schema<boolean, boolean, "defined">;
+    toolGraph: Schema<boolean, boolean, "defined">;
+    toolRuminate: Schema<boolean, boolean, "defined">;
+    toolConflict: Schema<boolean, boolean, "defined">;
+    toolMutate: Schema<boolean, boolean, "defined">;
 }>>>, "volatile">;
 export declare const memorySchema: Schema<Schemastery.ObjectS<NoInfer<{
     dataDir: Schema<string, string, "defined">;
@@ -826,6 +836,11 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<NoInfer<{
         embedRemoteDimensions: Schema<number, number, "defined">;
         memoryMutate: Schema<boolean, boolean, "defined">;
         conflictFreeze: Schema<boolean, boolean, "defined">;
+        toolRoom: Schema<boolean, boolean, "defined">;
+        toolGraph: Schema<boolean, boolean, "defined">;
+        toolRuminate: Schema<boolean, boolean, "defined">;
+        toolConflict: Schema<boolean, boolean, "defined">;
+        toolMutate: Schema<boolean, boolean, "defined">;
     }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
         enabled: Schema<boolean, boolean, "defined">;
         capture: Schema<boolean, boolean, "defined">;
@@ -923,6 +938,11 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<NoInfer<{
         embedRemoteDimensions: Schema<number, number, "defined">;
         memoryMutate: Schema<boolean, boolean, "defined">;
         conflictFreeze: Schema<boolean, boolean, "defined">;
+        toolRoom: Schema<boolean, boolean, "defined">;
+        toolGraph: Schema<boolean, boolean, "defined">;
+        toolRuminate: Schema<boolean, boolean, "defined">;
+        toolConflict: Schema<boolean, boolean, "defined">;
+        toolMutate: Schema<boolean, boolean, "defined">;
     }>>>, "volatile">;
 }>>, Schemastery.ObjectT<NoInfer<{
     dataDir: Schema<string, string, "defined">;
@@ -1330,6 +1350,11 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<NoInfer<{
         embedRemoteDimensions: Schema<number, number, "defined">;
         memoryMutate: Schema<boolean, boolean, "defined">;
         conflictFreeze: Schema<boolean, boolean, "defined">;
+        toolRoom: Schema<boolean, boolean, "defined">;
+        toolGraph: Schema<boolean, boolean, "defined">;
+        toolRuminate: Schema<boolean, boolean, "defined">;
+        toolConflict: Schema<boolean, boolean, "defined">;
+        toolMutate: Schema<boolean, boolean, "defined">;
     }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
         enabled: Schema<boolean, boolean, "defined">;
         capture: Schema<boolean, boolean, "defined">;
@@ -1427,6 +1452,11 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<NoInfer<{
         embedRemoteDimensions: Schema<number, number, "defined">;
         memoryMutate: Schema<boolean, boolean, "defined">;
         conflictFreeze: Schema<boolean, boolean, "defined">;
+        toolRoom: Schema<boolean, boolean, "defined">;
+        toolGraph: Schema<boolean, boolean, "defined">;
+        toolRuminate: Schema<boolean, boolean, "defined">;
+        toolConflict: Schema<boolean, boolean, "defined">;
+        toolMutate: Schema<boolean, boolean, "defined">;
     }>>>, "volatile">;
 }>>, "plain">;
 export declare function resolveDataDir(cfg: MemoryConfig): string;

package/dist/config.js

@@ -69,6 +69,13 @@ export function liveSettingsSchema() {
         memoryMutate: Schema.boolean().default(false),
         // §C 人工冲突裁决总开关:默认 false(冻结消耗注意力,不可默认全开)
         conflictFreeze: Schema.boolean().default(false),
+        // 工具分组封印(v0.21.0):false = 该组工具不注册,从模型工具列表消失。
+        // 核心读(memory_search/read_scene/receipts/conversation_search)与槽位三件不受控。
+        toolRoom: Schema.boolean().default(true),
+        toolGraph: Schema.boolean().default(true),
+        toolRuminate: Schema.boolean().default(true),
+        toolConflict: Schema.boolean().default(true),
+        toolMutate: Schema.boolean().default(true),
     }).volatile();
 }
 export const memorySchema = Schema.object({

package/dist/contract.d.ts

@@ -47,6 +47,12 @@ export type LayerRouteKey = 'l1' | 'l2' | 'l3';
 export interface MemoryLiveSettings {
     /** 总开关:关 = 捕获/蒸馏/召回注入全停(数据保留) */
     enabled: boolean;
+    /** 工具分组封印:false = 该组工具不注册,从模型工具列表消失。核心读(memory_search/read_scene/receipts/conversation_search)与槽位三件不受控 */
+    toolRoom: boolean;
+    toolGraph: boolean;
+    toolRuminate: boolean;
+    toolConflict: boolean;
+    toolMutate: boolean;
     /** L0 捕获(原始对话落盘) */
     capture: boolean;
     /** L1 抽取 + L2/L3 蒸馏 */

package/dist/hooks/recall.js

@@ -209,7 +209,7 @@ usage) {
     let ackDegradeWarned = false;
     // §E 压缩感知(memorax-absorb):宿主 `compaction/end`(无 error)→ 该会话下一轮
     // 做一次"定向增强召回"——跳过去重压制、画像立即重注入、占用账本归零;消费即清。
-    // 会话级回退路径保留(下方 session-start source='compact' 全量重置),两者幂等。
+    // 会话级回退路径保留(下方 agent/created source='compact' 全量重置),两者幂等。
     // 宿主无压缩计数器(compactionId 为 per-transaction UUID),故不做 generation 对账。
     const postCompaction = new PostCompactionTracker();
     ctx.on('session/event', (session, event) => {

package/dist/index.d.ts

@@ -421,6 +421,11 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         embedRemoteDimensions: import("@deepseek-ai/schemastery").default<number, number, "defined">;
         memoryMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
         conflictFreeze: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRoom: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolGraph: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRuminate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolConflict: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
     }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
         capture: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
@@ -518,6 +523,11 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         embedRemoteDimensions: import("@deepseek-ai/schemastery").default<number, number, "defined">;
         memoryMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
         conflictFreeze: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRoom: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolGraph: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRuminate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolConflict: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
     }>>>, "volatile">;
 }>>, Schemastery.ObjectT<NoInfer<{
     dataDir: import("@deepseek-ai/schemastery").default<string, string, "defined">;
@@ -925,6 +935,11 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         embedRemoteDimensions: import("@deepseek-ai/schemastery").default<number, number, "defined">;
         memoryMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
         conflictFreeze: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRoom: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolGraph: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRuminate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolConflict: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
     }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
         capture: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
@@ -1022,6 +1037,11 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         embedRemoteDimensions: import("@deepseek-ai/schemastery").default<number, number, "defined">;
         memoryMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
         conflictFreeze: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRoom: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolGraph: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolRuminate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolConflict: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+        toolMutate: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
     }>>>, "volatile">;
 }>>, "plain">;
 export declare function apply(ctx: Context, config: MemoryConfig): Promise<void>;

package/dist/projection/slots.js

@@ -156,13 +156,20 @@ export function registerSlotsProjection(ctx, store, l1) {
             .sessionProjections;
         if (registry === undefined || typeof registry.register !== 'function')
             return;
-        registry.register({
+        // 双代平面（TL beta.29 同款判别式）：0.1.0-rc.8 的 registry 是唯一的平面契约
+        // （def.schema.parse(def.view(state))），0.1.1+ 消费 wire:{viewSchema,view}。
+        // wire 形状镜像成平面键挂上，两代 registry 各取所需；一个缺 schema 的注册
+        // 单元会毒化旧 registry 的全部冷会话历史加载。
+        const definition = {
             key: MEMORY_SLOTS_KEY,
             stateSchema,
             init: () => buildState(store, l1),
             apply: (state, event) => applySlotsEvent(state, event, store, l1),
             wire: { viewSchema, view },
+            schema: viewSchema,
+            view,
             stateVersion: 0,
-        });
+        };
+        registry.register(definition);
     });
 }

package/dist/settings.js

@@ -1,4 +1,4 @@
-import { EFFORT_CHOICES } from './config.js';
+import { EFFORT_CHOICES, liveSettingsSchema } from './config.js';
 /** 运行时路由链上限(写入门与 UI 同限,防误粘贴巨数组撑爆 settings 存储)。 */
 export const DISTILL_CHAIN_MAX = 8;
 /**
@@ -80,6 +80,11 @@ const ALWAYS_ON = {
     embedRemoteDimensions: 0,
     memoryMutate: false,
     conflictFreeze: false,
+    toolRoom: true,
+    toolGraph: true,
+    toolRuminate: true,
+    toolConflict: true,
+    toolMutate: true,
 };
 /** 自带自定义设置页(settings.section 顶层「记忆」分节,client 半挂载):
  *  关掉宿主按 volatile 字段自动生成的表单页,避免同一个插件出现两份设置入口。
@@ -115,23 +120,115 @@ export function registerLiveSettings(ctx, config, logger) {
                 ? `,蒸馏模型=${current.distillProvider}/${current.distillModel}`
                 : '') + budgetNote + inputNote);
     });
-    // 写面:settings 服务(宿主服务,可能晚于本插件就绪)——用 inject 惰性握手,
-    // 服务替换时 cordis 会重跑回调换上新实例,无需手工判活。
+    // ── 读写面三代腰(纯特性检测,playbook §5:勿按版本号分支)──────────────
+    // 代 1(0.1.7+):settings 服务有 SettingsForms.update(ns,patch) —— 读走 Config
+    //   live volatile 引用(read()),写走 forms.update(整节提交)。
+    // 代 2(0.1.2/0.1.5):settings.register 返回 SettingsScope(get/watch/update)
+    //   —— 读写全走 scope(写活读死:0.1.2/0.1.5 的 scope.get() 快照可能恒默认,
+    //   磁盘才是真值,调用方以持久化成功为准)。
+    // 代 2'(register 缺失):installSection 只回 hooks —— 读走 setSource 注入的
+    //   thunk,写显式拒绝。
+    // 代 3(0.1.0/0.1.1):settings 服务整体缺席 → 恒开降级,internal/service 上线
+    //   重试。参考件:compat/0.1.5 registerLiveSettings 的 tryAttach 全套。
     let forms;
     ctx.inject(['settings'], (sctx) => {
         forms = sctx.get('settings');
     });
+    let inner = {
+        supported: false,
+        get: () => ({ ...ALWAYS_ON, distillChain: [] }),
+        update: () => Promise.reject(new Error('settings 服务不可用,记忆开关无法写入')),
+    };
+    const wireScope = (scope) => {
+        return {
+            supported: true,
+            get: () => resolveSettings(scope.get()),
+            update: async (patch) => {
+                await scope.update(patch);
+            },
+        };
+    };
+    const tryAttachOld = () => {
+        const settings = ctx.get('settings');
+        if (!settings || typeof forms?.update === 'function')
+            return true; // 代 1 生效,老臂不必挂
+        if (typeof settings.register === 'function') {
+            try {
+                const scope = settings.register(MEMORY_ENTRY_ID, liveSettingsSchema(), { applies: 'live' });
+                inner = wireScope(scope);
+                logger.info('[memory] 记忆模式开关就绪(settings.register,命名空间 dsh-memory)');
+                return true;
+            }
+            catch (err) {
+                logger.warn(`[memory] 记忆模式开关注册失败(保持全开): ${err instanceof Error ? err.message : String(err)}`);
+                return true;
+            }
+        }
+        if (typeof settings.installSection === 'function') {
+            try {
+                let source = () => ({ ...ALWAYS_ON, distillChain: [] });
+                let notify;
+                const bridge = {
+                    get: () => resolveSettings(source()),
+                    watch: (callback) => {
+                        notify = () => void callback(bridge.get());
+                        return () => {
+                            notify = undefined;
+                        };
+                    },
+                    update: () => Promise.reject(new Error('installSection 桥接模式不支持运行时写入')),
+                };
+                settings.installSection(ctx, MEMORY_ENTRY_ID, liveSettingsSchema(), { ...ALWAYS_ON, distillChain: [] }, {
+                    setSource: (current) => {
+                        source = current;
+                    },
+                    onChange: () => notify?.(),
+                });
+                inner = wireScope(bridge);
+                logger.info('[memory] 记忆模式开关就绪(settings.installSection 桥接,运行时写入不可用)');
+                return true;
+            }
+            catch (err) {
+                logger.warn(`[memory] 记忆模式开关 installSection 桥接失败(保持全开): ${err instanceof Error ? err.message : String(err)}`);
+                return true;
+            }
+        }
+        logger.warn('[memory] settings 服务无可用的 register/installSection API,记忆模式开关降级为恒开');
+        return true;
+    };
+    if (!tryAttachOld()) {
+        logger.warn('[memory] settings 服务未就绪,记忆模式开关暂不可用(保持全开,等待服务上线)');
+    }
+    // 服务迁移自愈(代 2/2' 臂):下线 → 降级;换实例/上线 → 立即重试挂接(幂等)。
+    ctx.on('internal/service', (name) => {
+        if (name !== 'settings')
+            return;
+        inner = {
+            supported: false,
+            get: () => ({ ...ALWAYS_ON, distillChain: [] }),
+            update: () => Promise.reject(new Error('settings 服务不可用,记忆开关无法写入')),
+        };
+        tryAttachOld();
+    });
+    const modernWrite = () => {
+        const f = forms;
+        return !!(f && typeof f.update === 'function');
+    };
     return {
         supported: true,
-        get: read,
+        get: () => (modernWrite() ? read() : inner.get()),
         update: async (patch) => {
-            if (!forms)
-                throw new Error('settings 服务不可用,记忆开关无法写入');
-            // patch 合并语义与旧 scope.update 一致:只改传入键。合并在插件侧完成后
-            // **整节提交**——宿主的表单 update 按 volatile 节整体写入 profile patch,
-            // 部分对象会覆盖掉未提交字段。写失败(update 抛错)对调用方可观测。
-            const next = { ...read(), ...patch };
-            await forms.update(MEMORY_ENTRY_ID, { live: next });
+            if (modernWrite()) {
+                if (!forms)
+                    throw new Error('settings 服务不可用,记忆开关无法写入');
+                // patch 合并语义与旧 scope.update 一致:只改传入键。合并在插件侧完成后
+                // **整节提交**——宿主的表单 update 按 volatile 节整体写入 profile patch,
+                // 部分对象会覆盖掉未提交字段。写失败(update 抛错)对调用方可观测。
+                const next = { ...read(), ...patch };
+                await forms.update(MEMORY_ENTRY_ID, { live: next });
+                return;
+            }
+            await inner.update(patch);
         },
     };
 }
@@ -204,5 +301,11 @@ function resolveSettings(value) {
         memoryMutate: v.memoryMutate === true,
         // §C 人工冲突裁决:严格 === true(默认关,冻结消耗注意力)
         conflictFreeze: v.conflictFreeze === true,
+        // 工具分组封印:严格 !== false(缺省/异常值 = 未封印,工具照常注册)
+        toolRoom: v.toolRoom !== false,
+        toolGraph: v.toolGraph !== false,
+        toolRuminate: v.toolRuminate !== false,
+        toolConflict: v.toolConflict !== false,
+        toolMutate: v.toolMutate !== false,
     };
 }

package/dist/stats.js

@@ -804,6 +804,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,
                     reasoningEffort: '', distillProvider: '', distillModel: '', distillChain: [],
                     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0, graph: 0 }, distillMaxInputChars: 0,
                     distillLayerChains: { l1: [], l2: [], l3: [] },
@@ -849,7 +850,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']) {
+            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate']) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }

package/dist/tools/index.js

@@ -38,6 +38,49 @@ ruminate,
 roomRegistry) {
     if (!cfg.tools)
         return;
+    // ── 工具分组封印(v0.21.0):sealable 组的注册经 reg() 登记,按 live 开关动态
+    // 注册/反注册。封印 = 从模型工具列表消失(反注册),不是执行期拒绝;开关经
+    // 设置页 volatile 热更(loader/volatile-update)即时生效,无需重启。
+    // 核心读(memory_search / conversation_search / memory_read_scene /
+    // memory_receipts)与槽位三件(slots.ts)不参与封印。
+    const toolDisposers = new Map();
+    const toolMakers = new Map();
+    const toolSealed = (group) => {
+        const snap = live.get();
+        switch (group) {
+            case 'room': return snap.toolRoom === false;
+            case 'graph': return snap.toolGraph === false;
+            case 'ruminate': return snap.toolRuminate === false;
+            case 'conflict': return snap.toolConflict === false;
+            case 'mutate': return snap.toolMutate === false;
+            default: return false;
+        }
+    };
+    const reg = (group, make) => {
+        const makers = toolMakers.get(group) ?? [];
+        makers.push(make);
+        toolMakers.set(group, makers);
+        if (!toolSealed(group)) {
+            const disposers = toolDisposers.get(group) ?? [];
+            disposers.push(make());
+            toolDisposers.set(group, disposers);
+        }
+    };
+    const applyToolSeals = () => {
+        for (const [group, disposers] of [...toolDisposers]) {
+            if (!toolSealed(group))
+                continue;
+            disposers.forEach((dispose) => dispose());
+            toolDisposers.delete(group);
+            logger.warn(`[memory] 工具组已封印: ${group}`);
+        }
+        for (const [group, makers] of [...toolMakers]) {
+            if (toolSealed(group) || toolDisposers.has(group))
+                continue;
+            toolDisposers.set(group, makers.map((make) => make()));
+            logger.warn(`[memory] 工具组已解封: ${group}`);
+        }
+    };
     /**
      * 沿父链解析**有效档位归属会话**(§A 修复)。
      *
@@ -189,7 +232,7 @@ roomRegistry) {
     }));
     // ── memory_room_admin: Room 粒度目录治理(分类管理 beta.4;beta.5 起 merge/rename/retire 已注册) ──
     // list 免预算零风险;merge/rename/retire 走 dryRun 预览→实跑,执行前自动备份,完成入队场景重算。
-    ctx.tools.register(defineTool({
+    reg('room', () => ctx.tools.register(defineTool({
         name: 'memory_room_admin',
         description: 'Room 分类管理(目录粒度)。action="list" 列出注册表条目与自生长 Room 计数;' +
             'action="register" 预注册一个 Room(高权限;两级制——大类上限 200,小类用「大类/小类」细分不占额度,如 dsh-plugin/merge;' +
@@ -333,7 +376,7 @@ roomRegistry) {
             }
             return { notice: `非法 action:${action}(允许 list/register/merge/rename/retire)。` };
         },
-    }));
+    })));
     // ── conversation_search: L0 原始对话 ──
     ctx.tools.register(defineTool({
         name: 'conversation_search',
@@ -518,7 +561,7 @@ roomRegistry) {
         rewritten: { type: 'boolean', description: '是否已被后续条目改写/取代' },
     };
     // memory_add:显式"记得X"直接落库一条 L1 记忆(绕过抽取管线,需高权限)。
-    ctx.tools.register(defineTool({
+    reg('mutate', () => ctx.tools.register(defineTool({
         name: 'memory_add',
         description: '直接写入一条结构化记忆(L1)。仅当用户显式要求"记住/记下 X"时用;需高权限模式开启。内容须是待记忆的事实/偏好/任务/规则,不应包含对话过程。',
         parameters: {
@@ -554,9 +597,9 @@ roomRegistry) {
             logger.info(`[memory] 高权限写入记忆(${record.type}${record.metadata?.hall ? '/' + String(record.metadata.hall) : ''},时间轴 ${record.persistence ?? '?'}):${record.content.slice(0, 120)}`);
             return { id: record.id };
         },
-    }));
+    })));
     // memory_import:批量写入(工具刷写通道——外部记忆包导入/迁移,免逐条调用)。
-    ctx.tools.register(defineTool({
+    reg('mutate', () => ctx.tools.register(defineTool({
         name: 'memory_import',
         description: '批量写入多条记忆(L1)。用于把已整理好的外部记忆(其他 AI 工具导出的记忆包)一次性导入;需高权限模式开启。去重与冲突判定由调用方先行完成(见 memport Skill):本工具只做结构校验与批内重复拦截,不替调用方裁决语义冲突。单次上限 200 条。',
         parameters: {
@@ -652,9 +695,9 @@ roomRegistry) {
             logger.info(`[memory] 批量导入 ${records.length} 条(跳过 ${skipped.length} 条,场景 ${scene})`);
             return { written: records.length, ids: records.map((r) => r.id), skipped };
         },
-    }));
+    })));
     // memory_delete:显式"忘了 X"——按语义检索命中后删除(高权限门控)。
-    ctx.tools.register(defineTool({
+    reg('mutate', () => ctx.tools.register(defineTool({
         name: 'memory_delete',
         description: '退场(软删)与查询相关的记忆(L1)。仅当用户显式要求"忘记/删除某条记忆"时用;需高权限模式开启。' +
             '默认只退场**最贴近的 1 条**;可用 limit 放大(上限 10)。' +
@@ -723,11 +766,11 @@ roomRegistry) {
             logger.info(`[memory] 高权限退场(软删)记忆 ${n} 条(${ids.join('，')})`);
             return { deleted: n, ids };
         },
-    }));
+    })));
     // ── 图谱工具(读;受与 memory_search 同款的档位/注入拒读门 + 族过滤) ──
     const GRAPH_OFF_NOTICE = '图谱功能未启用:部署配置 graph.enabled 未开启,当前没有可用的知识图谱。';
     // memory_search_graph: 图谱节点检索(紧凑节点卡)
-    ctx.tools.register(defineTool({
+    reg('graph', () => ctx.tools.register(defineTool({
         name: 'memory_search_graph',
         description: '搜索知识图谱(实体节点:人物/项目/组织/工具/地点)。返回实体的当前状态摘要与匹配说明,适用于查"某人/某项目现在什么状态"这类问题;需要完整属性与关系时再用 memory_expand_graph_node 展开。',
         parameters: {
@@ -785,9 +828,9 @@ roomRegistry) {
                 })),
             };
         },
-    }));
+    })));
     // memory_expand_graph_node: 展开单个节点(facts 全量含历史 + 关系边)
-    ctx.tools.register(defineTool({
+    reg('graph', () => ctx.tools.register(defineTool({
         name: 'memory_expand_graph_node',
         description: '展开一个图谱节点的完整详情:全部属性(facts,含已被更新的历史值与生效区间)、关联关系边与来源记忆 id。先用 memory_search_graph 拿到节点 id。',
         parameters: {
@@ -843,12 +886,12 @@ roomRegistry) {
             lines.push('', `来源记忆: ${node.sourceRecordIds.join('、') || '(无)'}`);
             return { node: lines.join('\n') };
         },
-    }));
+    })));
     // ── 反刍工具(按需触发 L1→L2→L3 消化,受蒸馏开关门控) ──
     const RUMINATE_OFF_NOTICE = '反刍功能未开放:请在记忆库面板开启「蒸馏」开关后使用。';
     const RUMINATE_UNAVAIL_NOTICE = '反刍未初始化:存储处于降级态,无法反刍。';
     const RUMINATE_RUNNING_NOTICE = '反刍已在进行中,请稍后再试。';
-    ctx.tools.register(defineTool({
+    reg('ruminate', () => ctx.tools.register(defineTool({
         name: 'memory_ruminate',
         description: '触发记忆反刍:把未蒸馏的对话缓冲冲刷出来,跑一轮 L1 抽取 → L2 场景整合 → L3 画像更新。与重建不同,不清库不改 L0,仅消化攒而未蒸馏的切片;无缓冲时做轻量 L2/L3 刷新。',
         parameters: {},
@@ -894,9 +937,9 @@ roomRegistry) {
                 return { notice: `反刍启动失败: ${msg}`, running: false, phase: 'failed', done: 0, total: 0, recordsBuilt: 0, startedAt: undefined };
             }
         },
-    }));
+    })));
     // ── 取消反刍(按需取消正在进行的反刍) ──
-    ctx.tools.register(defineTool({
+    reg('ruminate', () => ctx.tools.register(defineTool({
         name: 'memory_ruminate_cancel',
         description: '取消正在进行的记忆反刍。已蒸馏部分保留,pending 切片中未被消费的部分维持原状。',
         parameters: {},
@@ -928,12 +971,12 @@ roomRegistry) {
                 return { notice: msg, phase: 'idle', running: false };
             }
         },
-    }));
+    })));
     // ── 反刍状态查询(查看当前反刍进度) ──
     // ── memory_room_review:孤儿记忆的 Room 候选逐个复查(agent 长尾治理)──────
     // next/annotate 只读或预算内标注(无需门);confirm/skip 改写 metadata,
     // confirm 吃 live.memoryMutate 高权限门(与 memory_delete 同款)。
-    ctx.tools.register(defineTool({
+    reg('room', () => ctx.tools.register(defineTool({
         name: 'memory_room_review',
         description: '孤儿记忆(无 Room 绑定)的逐个复查:action="next" 取下一条待复查记录(带系统预标记的候选 Room 与现有词表,agent 依据记录内容判定);' +
             'action="confirm" 按 id 把 1-3 个 Room slug 写入该记忆(高权限);action="skip" 跳过(不再进队列);' +
@@ -1010,8 +1053,8 @@ roomRegistry) {
             }
             return { notice: `非法 action:${action}(允许 next/confirm/skip/annotate)。剩余待复查 ${pendingReviewCount(stores.l1)} 条。` };
         },
-    }));
-    ctx.tools.register(defineTool({
+    })));
+    reg('ruminate', () => ctx.tools.register(defineTool({
         name: 'memory_ruminate_status',
         description: '查询当前记忆反刍的状态与进度(是否运行中、当前阶段、已完成/总会话数等)。\n\n注意:在 DSH Web GUI 的对话中无法直接调用此工具,因为模型可调用工具列表不包含 ruminate_status。如需查询进度,请在记忆库面板的蒸馏面板查看。',
         parameters: {},
@@ -1052,7 +1095,7 @@ roomRegistry) {
                 error: result.error ?? undefined,
             };
         },
-    }));
+    })));
     // ── memory_receipts: §B 决策凭证回溯(读;受与 memory_search 同款档位门) ──
     // 为什么给它一个模型可见的工具:凭证链的价值全在"事后能问"。若只有 RPC 端点,
     // 用户得自己去浏览器/curl 才能回溯,而真正会问「这条记忆怎么来的」的场合
@@ -1124,7 +1167,7 @@ roomRegistry) {
     // 但那个工具**一直不存在** —— 模型照着描述调用只会拿到"工具不存在"。
     // 裁决端点在、读端点与读工具两端都缺,队列于是成了只进不出的黑洞
     // (安全阀超时自动了结会成为唯一出路,那正是 §C 想避免的)。
-    ctx.tools.register(defineTool({
+    reg('conflict', () => ctx.tools.register(defineTool({
         name: 'memory_conflicts',
         description: '列出**矛盾冻结**的待裁决对(§C)。冻结不自动裁决:新记忆照常入库,与它冲突的旧记忆作为**一对**停在队列里,双方内容都不被改写,直到人给出结论。返回每对的 pair_id、**双方正文**与 LLM 建议的胜负方(id 只是进入队列时的排序位,不代表结论)。看完用 memory_resolve_conflict 给出结论:winner / loser / both。',
         parameters: {
@@ -1181,12 +1224,12 @@ roomRegistry) {
             }
             return listConflictPairs({ l1: stores.l1, conflictFreezeEnabled: live.get().conflictFreeze === true }, { limit: typeof args.limit === 'number' ? args.limit : undefined });
         },
-    }));
+    })));
     // ── memory_conflicts_rejected: §C 丢弃留痕的读出口 ──
     // LLM 输出不满足 pair 格式的冲突决策会被记入 `conflict_rejected` 表,
     // 但此前只有写入没有读取——人无法知道"哪些冲突被判定为不合法"。
     // 本工具补上读方向,与 `dsh-memory/conflicts-rejected` RPC 端点共用同一形状。
-    ctx.tools.register(defineTool({
+    reg('conflict', () => ctx.tools.register(defineTool({
         name: 'memory_conflicts_rejected',
         description: '列出被**丢弃**的冲突决策(§C 丢弃留痕)。LLM 输出不满足 pair 格式(缺 winner/loser id、无法配对等)时,该决策会被记入丢弃表而非停到待裁决队列。返回每条的 reject_id、原始正文、丢弃原因与所属蒸馏批次。可用 limit / created_before 分页。',
         parameters: {
@@ -1249,12 +1292,12 @@ roomRegistry) {
                 })),
             };
         },
-    }));
+    })));
     // ── memory_resolve_conflict: §C 矛盾冻结的人工裁决出口 ──
     // 冻结把裁决权交还给人,那么**必须**有一个"人能把结论说回去"的出口——
     // 否则待裁决队列是个只进不出的黑洞,安全阀(task_24)会成为唯一出路,
     // 那等于把 opt-in 的冻结悄悄退回成"超时后机器自己判"。
-    ctx.tools.register(defineTool({
+    reg('conflict', () => ctx.tools.register(defineTool({
         name: 'memory_resolve_conflict',
         description: '裁决一条**矛盾冻结**的待裁决对(§C)。冻结产生的冲突对停放在待裁决队列里,双方记忆都不被改写,直到你在这里给出结论:winner(判 LLM 建议的胜方为真,败方从检索中退场)、loser(判败方为真)、both(判定两者其实是各自独立的事实,都保留)、defer(看过但**暂不裁决**——它不关闭冲突,该对仍在待裁决队列里,会重置超时计时并累计复看次数)。需先开启 conflictFreeze 配置;待裁决对可用 memory_conflicts 查看。',
         parameters: {
@@ -1290,7 +1333,14 @@ roomRegistry) {
                 return { ...empty, notice: '需要 pair_id:待裁决对没有"全部裁决"这种用法。' };
             return resolveConflictPair({ l1: stores.l1, conflictFreezeEnabled: live.get().conflictFreeze === true }, pairId, outcome);
         },
-    }));
+    })));
+    applyToolSeals();
+    // 设置页翻开关 → volatile 热更 → 重新应用封印(反注册/重注册)。
+    // 守卫:测试 fake ctx / 极老宿主没有事件面时静默跳过(封印仅失去热更,
+    // 重启后仍生效)。
+    if (typeof ctx.on === 'function') {
+        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');
 }
 /** 凭证回溯的人类可读渲染(含"还有多少条没显示")。 */

package/dist/tools/slots.js

@@ -101,7 +101,7 @@ l1) {
     // ── memory_slot_write:写入新槽位(写,memoryMutate 门控) ──
     ctx.tools.register(defineTool({
         name: 'memory_slot_write',
-        description: '写入一个激活槽位(active slot)。适合把跨会话需要持续生效的规则、待办、锚点或外部指针固化下来;pinned=true 的 open 槽位会常驻注入每轮对话上下文。需高权限模式开启。',
+        description: '写入一个激活槽位(active slot)。适合把跨会话需要持续生效的规则、待办、锚点或外部指针固化下来;pinned=true 的 open 槽位会常驻注入每轮对话上下文。需高权限模式开启。refs 中的 L1 record_id 必须真实存在(用 memory_search 返回的 id),否则写入被拒。',
         parameters: {
             title: { type: 'string', required: true, description: '槽位标题(≤60 字,一句话概括)' },
             kind: { type: 'string', description: '槽位类型:rule(规则)/todo(待办)/anchor(锚点)/pointer(指针,正文可空)' },
@@ -143,6 +143,20 @@ l1) {
                 status: typeof args.status === 'string' ? args.status : undefined,
                 origin: 'user',
             };
+            // mem_ 引用必须真实存在(v0.21.0):保证"search 激活的记忆"进入引用的是
+            // 真实 record_id——模型幻觉/拼错的 id 直接拒绝并给出修正路径,不让坏引用
+            // 静默进槽位(否则 brief 侧解析不出名称简述)。文件路径/URL 类 refs 不校验。
+            const memRefs = (input.refs ?? []).filter((r) => r.startsWith('mem_'));
+            if (memRefs.length > 0 && l1) {
+                const found = new Set(l1.getByIds([...memRefs]).map((r) => r.id));
+                const missing = memRefs.filter((id) => !found.has(id));
+                if (missing.length > 0) {
+                    return {
+                        notice: `写入被拒:refs 中的 L1 record_id 不存在(${missing.join(', ')})。` +
+                            `请先用 memory_search 搜索,使用其返回的 id;文件路径/URL 类 refs 无需此校验。`,
+                    };
+                }
+            }
             try {
                 const slot = await slots.upsert(input);
                 logger.info(`[memory] 写入激活槽位(${slot.kind},pinned=${slot.pinned}):${slot.title.slice(0, 60)}`);

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.20.0-beta.6-dsh0.2.0.1",
+  "version": "0.22.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 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"
@@ -13,7 +13,7 @@
   },
   "license": "MIT",
   "engines": {
-    "dsh": ">=0.2.0-rc.1 <0.2.1-0"
+    "dsh": ">=0.1.0-rc.2"
   },
   "components": {
     "host": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.20.4",
+  "version": "0.22.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
@@ -24,8 +24,7 @@
     },
     "client": {
       "inject": [
-        "@deepseek-ai/dsh-client-ui-primitives",
-        "@deepseek-ai/dsh-client-connection"
+        "@deepseek-ai/dsh-client-ui-primitives"
       ],
       "platform": "web"
     }
@@ -57,11 +56,12 @@
     "build:smoke": "tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution nodenext --target es2022 --strict --skipLibCheck --esModuleInterop",
     "lint": "eslint src client/src scripts tests",
     "test": "vitest run",
-    "wing-migrate": "npm run build && node scripts/wing-migrate.mjs"
+    "wing-migrate": "npm run build && node scripts/wing-migrate.mjs",
+    "prepack": "npm run build"
   },
   "engines": {
     "node": ">=22.16.0",
-    "dsh": ">=0.2.0-rc.1 <0.2.1-0"
+    "dsh": ">=0.1.0-rc.2"
   },
   "keywords": [
     "dsh",
@@ -83,15 +83,15 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-client-connection": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-client-ui-primitives": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-home-paths": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-llm": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-session": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-settings": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-system-prompt": ">=0.2.0-rc.1 <0.2.1-0",
-    "@deepseek-ai/dsh-tools": ">=0.2.0-rc.1 <0.2.1-0"
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-agent": {