dsh-layered-memory 0.8.9 → 0.8.10

package/README.en.md

@@ -159,6 +159,16 @@ trajectory view):
 - Each session's choice is persisted by sessionId to `session-modes.json`, surviving
   restarts/session restore; stacks with the global switches (global is the master gate);
   L2/L3 are fully family-isolated — content never leaks across families.
+- **Write-only sessions (#38)**: a three-state "injection" switch inside the popover
+  (follow global / on / off) — set to "off" for a **write-only session**: capture and
+  distillation continue as usual (conversation still settles into L0→L1→L2/L3), but
+  nothing is injected into this session (recall injection, the persona/navigation
+  stable section and the tools guide all stop; `memory_search` and the other read
+  tools return a write-only notice). The pill face changes to `Memory · Write-only`;
+  the override persists per session, and switching back to "follow global" clears it
+  to the settings-page recall toggle. Ideal for debug/eval/sensitive sessions that
+  should absorb without interference. Orthogonal to the off mode: off remains full
+  stealth (capture off too), while write-only keeps the "in" and gates the "out".
 
 ## UI Preview
 

package/README.md

@@ -124,6 +124,12 @@ L1/L2/L3 层级过滤）、层级 × 时间窗口表格（调用数 / 输出与
   打开期间自适应轮询（忙 2s / 静 5s），关闭即停；
 - 每会话的选择按 sessionId 持久化到 `session-modes.json`，重启/恢复会话不丢；
   与全局开关叠加（全局是总闸）；L2/L3 完全分类，分类内容不渗透。
+- **只写不读（#38）**：悬浮板内「注入」三态开关（跟随全局 / 开 / 关）——设为「关」
+  即**只写会话**：捕获与蒸馏照常（对话照常沉淀为 L0→L1→L2/L3），但不向本会话注入
+  任何记忆（召回注入、画像/导航稳定区、工具指南一并停止；`memory_search` 等读工具
+  返回只写提示）。pill 面文换作 `记忆·只写` 提示状态；覆盖按会话持久化，切回
+  「跟随全局」即清除、跟随设置页召回开关；适合调试/评测/敏感会话「只吸收不干扰」。
+  与 off 档正交：off 仍是完全隐身（连捕获都关），只写保留「进」关「出」。
 
 ## 界面预览
 

package/dist/client.js

@@ -3066,7 +3066,13 @@ var __defProp = Object.defineProperty;
 		  if (rc.enabled === false) {
 		    rcVal = "停用";
 		    rcLabel = "召回命中";
-		    rcTitle = "召回已停用（开关关闭 / 档位关闭 / 部署未启用）";
+		    const reasonText = {
+		      deploy: "部署未启用",
+		      global: "全局开关关闭",
+		      session: "会话只写",
+		      mode: "档位关闭"
+		    };
+		    rcTitle = rc.reason ? "召回已停用（" + (reasonText[rc.reason] ?? rc.reason) + "）" : "召回已停用（开关关闭 / 档位关闭 / 部署未启用）";
 		  } else {
 		    rcVal = (rc.hitTurns || 0) + "/" + (rc.injectedTurns || 0);
 		    rcLabel = "召回命中 · " + (rc.totalHits || 0) + " 条";
@@ -3383,6 +3389,36 @@ var __defProp = Object.defineProperty;
 		              }
 		            ),
 		            props.error ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { style: { fontSize: 11, color: "var(--dsh-mem-danger)", marginTop: 10, whiteSpace: "nowrap" }, children: props.error }) : null,
+		            props.recall !== void 0 && props.onCommitRecall ? /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(
+		              "div",
+		              {
+		                style: {
+		                  borderTop: "1px solid var(--dsh-mem-border)",
+		                  marginTop: 10,
+		                  paddingTop: 8,
+		                  display: "flex",
+		                  justifyContent: "space-between",
+		                  alignItems: "center",
+		                  gap: 8
+		                },
+		                children: [
+		                  /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("span", { style: { fontSize: 12, color: "var(--dsh-mem-text-3)" }, children: "注入" }),
+		                  /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+		                    Segmented,
+		                    {
+		                      value: props.recall === null ? "follow" : props.recall ? "on" : "off",
+		                      disabled: props.mode === "off",
+		                      options: [
+		                        { key: "follow", label: "跟随全局", title: "清除本会话覆盖，跟随全局召回开关" },
+		                        { key: "on", label: "开", title: "本会话强制注入记忆" },
+		                        { key: "off", label: "关", title: "只写：记忆照常沉淀，但不注入本会话" }
+		                      ],
+		                      onChange: (key) => props.onCommitRecall(key === "on" ? true : key === "off" ? false : null)
+		                    }
+		                  )
+		                ]
+		              }
+		            ) : null,
 		            props.rpc && props.sessionId ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(SessionInfoArea, { rpc: props.rpc, sessionId: props.sessionId }) : null
 		          ]
 		        }
@@ -3397,6 +3433,8 @@ var __defProp = Object.defineProperty;
 		  const rpc = props.rpc;
 		  const sessionId = props.sessionId || props.session && props.session.sessionId;
 		  const [mode, setMode] = (0, import_react17.useState)(null);
+		  const [recall, setRecall] = (0, import_react17.useState)(null);
+		  const [recallResolved, setRecallResolved] = (0, import_react17.useState)(true);
 		  const [error, setError] = (0, import_react17.useState)(null);
 		  const [open, setOpen] = (0, import_react17.useState)(false);
 		  const wrapRef = (0, import_react17.useRef)(null);
@@ -3407,8 +3445,11 @@ var __defProp = Object.defineProperty;
 		    setError(null);
 		    rpc("dsh-memory/session-mode-get", { sessionId }).then((r) => {
 		      if (token !== seqRef.current) return;
-		      if (r && r.ok && r.value) setMode(r.value.mode);
-		      else setError(r && !r.ok ? r.error.message : "RPC error");
+		      if (r && r.ok && r.value) {
+		        setMode(r.value.mode);
+		        setRecall(r.value.recall);
+		        setRecallResolved(r.value.recallResolved);
+		      } else setError(r && !r.ok ? r.error.message : "RPC error");
 		    }).catch((e) => {
 		      if (token !== seqRef.current) return;
 		      setError(String(e && e.message || e));
@@ -3444,25 +3485,54 @@ var __defProp = Object.defineProperty;
 		    };
 		  }, [open]);
 		  const commit = (next) => {
-		    if (!rpc || next === mode) return;
+		    if (!rpc || !sessionId || mode === null || next === mode) return;
 		    const prev = mode;
+		    const token = seqRef.current;
 		    setMode(next);
 		    setError(null);
 		    rpc("dsh-memory/session-mode-set", { sessionId, mode: next }).then((r) => {
+		      if (token !== seqRef.current) return;
 		      if (!r || !r.ok) {
 		        setMode(prev);
 		        setError(r && r.error ? "档位写入失败：" + r.error.message : "档位写入失败");
 		      }
 		    }).catch((e) => {
+		      if (token !== seqRef.current) return;
 		      setMode(prev);
 		      setError("档位写入失败：" + String(e && e.message || e));
 		    });
 		  };
+		  const commitRecall = (next) => {
+		    if (!rpc || !sessionId || mode === null || next === recall) return;
+		    const prevRecall = recall;
+		    const prevResolved = recallResolved;
+		    const token = seqRef.current;
+		    setRecall(next);
+		    if (next !== null) setRecallResolved(next);
+		    setError(null);
+		    rpc("dsh-memory/session-mode-set", { sessionId, mode, recall: next }).then((r) => {
+		      if (token !== seqRef.current) return;
+		      if (!r || !r.ok) {
+		        setRecall(prevRecall);
+		        setRecallResolved(prevResolved);
+		        setError(r && r.error ? "注入设置失败：" + r.error.message : "注入设置失败");
+		      } else {
+		        setRecall(r.value.recall);
+		        setRecallResolved(r.value.recallResolved);
+		      }
+		    }).catch((e) => {
+		      if (token !== seqRef.current) return;
+		      setRecall(prevRecall);
+		      setRecallResolved(prevResolved);
+		      setError("注入设置失败：" + String(e && e.message || e));
+		    });
+		  };
 		  if (!sessionId || !rpc) return null;
 		  const info = modeInfo(mode);
 		  const loaded = mode !== null;
 		  const isOff = loaded && mode === "off";
 		  const isFlow = loaded && !isOff;
+		  const faceLabel = !loaded ? error ? "⚠" : "…" : isOff ? info.label : !recallResolved ? "只写" : info.label;
 		  ensureThemeStyle();
 		  const pillStyle = {
 		    display: "inline-flex",
@@ -3497,11 +3567,22 @@ var __defProp = Object.defineProperty;
 		        style: pillStyle,
 		        children: [
 		          "记忆 · ",
-		          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { children: loaded ? info.label : error ? "⚠" : "…" })
+		          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { children: faceLabel })
 		        ]
 		      }
 		    ),
-		    open ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(ModeSlider, { mode: mode || "auto", onCommit: commit, error, rpc, sessionId }) : null
+		    open ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+		      ModeSlider,
+		      {
+		        mode: mode || "auto",
+		        onCommit: commit,
+		        recall: loaded ? recall : void 0,
+		        onCommitRecall: commitRecall,
+		        error,
+		        rpc,
+		        sessionId
+		      }
+		    ) : null
 		  ] });
 		}
 		

package/dist/contract.d.ts

@@ -75,6 +75,8 @@ export interface MemoryLiveSettings {
      *  跟随（静态层链 → 全局解析逐级兜底）。写入经 settings-set 逐层校验（头行必须显式）。 */
     distillLayerChains: Record<LayerRouteKey, DistillChainEntry[]>;
 }
+/** 召回停用原因（session-stats recall.enabled=false 时带出；短路序第一个为假的因子）。 */
+export type RecallDisabledReason = 'deploy' | 'global' | 'session' | 'mode';
 /** 单会话召回统计（悬浮卡信息区数据源；口径见 recall.ts 注释）。 */
 export interface RecallSessionStats {
     /** 发生过召回检索的轮次数（含零命中、全量压制与超时）。 */
@@ -332,14 +334,27 @@ export interface SessionModeGetResponse {
     sessionId: string;
     mode: MemoryMode;
     defaultMode: MemoryMode;
+    /** 会话级注入覆盖（#38 只写不读）：null = 未覆盖（跟随全局）——线上 JSON 用 null
+     *  不用 undefined（序列化丢包）。 */
+    recall: boolean | null;
+    /** host 解析后的注入生效值（会话覆盖 ?? 全局开关）：pill 面文直接消费，
+     *  client 无需另知全局开关。 */
+    recallResolved: boolean;
 }
 export interface SessionModeSetRequest {
     sessionId: string;
     mode: MemoryMode;
+    /** 会话级注入覆盖：布尔 = 设置覆盖；显式 null = 清除（跟随全局）；缺省 = 不动
+     *  （旧 client 纯切档兼容，覆盖不丢）。mode 与 recall 可独立设置。 */
+    recall?: boolean | null;
 }
 export interface SessionModeSetResponse {
     sessionId: string;
     mode: MemoryMode;
+    /** 设置后的覆盖态（null = 跟随全局）。 */
+    recall: boolean | null;
+    /** 设置后的注入生效值（client 面文直接消费；清除覆盖后由 host 告知解析结果）。 */
+    recallResolved: boolean;
 }
 /** dsh-memory/session-stats（悬浮卡信息区；热路径端点）。 */
 export interface SessionStatsRequest {
@@ -360,8 +375,12 @@ export type SessionStatsResponse = {
     sessionId: string;
     mode: MemoryMode;
     defaultMode: MemoryMode;
+    /** 注入统计 + 生效位；enabled=false 时 reason 带短路序第一个为假因子
+     *  （deploy 部署上限 / global 全局开关 / session 会话只写 / mode 档位关闭），
+     *  旧宿主缺省该字段时 client 回退本地枚举文案。 */
     recall: {
         enabled: boolean;
+        reason?: RecallDisabledReason;
     } & RecallSessionStats;
     /** 记忆上下文占用账本（未注入过的会话为 null）。 */
     memoryOccupancy: MemoryOccupancy | null;

package/dist/hooks/recall.js

@@ -132,7 +132,8 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes, dataDir) {
             try {
                 const s = live.get();
                 const mode = modes.get(payload.agent.id);
-                if (!s.enabled || !s.recall || mode === 'off')
+                // 三级读闸：主闸 → off 档（完全隐身）→ 注入开关（#38：会话覆盖 ?? 全局）
+                if (!s.enabled || mode === 'off' || !modes.resolvedRecall(payload.agent.id, s.recall))
                     return decision;
                 // 只在有新的用户来源消息的步骤注入（轮首 claim 或 steering 插话）；纯工具步透传
                 const hasNewUserMessage = decision.messages.some((m) => m.source?.kind === 'user');
@@ -222,10 +223,9 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes, dataDir) {
      * 供旧会话回填估算（RecallHooks.estimateProfileTokens）复用同一口径。
      */ const composeStableText = (agentId) => {
         const s = live.get();
-        if (!s.enabled || !s.recall)
-            return '';
         const mode = modes.get(agentId);
-        if (mode === 'off')
+        // 与 pre-step 同款三级读闸（#38）：主闸 → off 档 → 注入开关；空串即物理离场
+        if (!s.enabled || mode === 'off' || !modes.resolvedRecall(agentId, s.recall))
             return '';
         // auto 档：两族按类别归组（画像/导航各一个标签，域内 <domain> 分块）；纯档：单族原格式
         const body = mode === 'auto'

package/dist/index.js

@@ -299,7 +299,7 @@ export async function apply(ctx, config) {
     }
     const recall = registerRecall(ctx, config, stores, logger, live, modes, dataDir);
     runner.setAfterRun(recall.invalidateProfile);
-    registerMemoryTools(ctx, config, stores, logger, modes);
+    registerMemoryTools(ctx, config, stores, logger, modes, live);
     registerMemoryRpc(ctx, config, stores, logger, {
         degraded: () => !storageOk || db.isDegraded(),
         pending: () => runner.pendingCount,

package/dist/stats.js

@@ -165,7 +165,16 @@ async function handleEndpoint(endpoint, payload, deps) {
                 throw new Error('档位存储未初始化');
             const p = (payload ?? {});
             const sessionId = expectSessionId(p.sessionId);
-            const v = { sessionId, mode: modes.get(sessionId), defaultMode: modes.default };
+            // 注入解析权威在 host：recall 是原始覆盖（null=跟随全局），recallResolved 是生效值
+            const s = live?.get();
+            const globalRecall = s?.recall ?? true;
+            const v = {
+                sessionId,
+                mode: modes.get(sessionId),
+                defaultMode: modes.default,
+                recall: modes.getRecall(sessionId) ?? null,
+                recallResolved: modes.resolvedRecall(sessionId, globalRecall),
+            };
             return v;
         }
         case 'dsh-memory/session-mode-set': {
@@ -177,9 +186,27 @@ async function handleEndpoint(endpoint, payload, deps) {
             if (typeof p.mode !== 'string' || !allowed.includes(p.mode)) {
                 throw new Error(`非法档位: ${String(p.mode)}（允许 ${allowed.join('/')}）`);
             }
+            // 注入覆盖可选同车（#38）：布尔 = 设置覆盖；显式 null = 清除覆盖（跟随全局）；
+            // 缺省（undefined）= 仅切档、覆盖保持不动（旧 client 永不传 recall，行为不变）。
+            // 校验前置：非法 recall 在任何写穿发生前拒绝（不做部分提交）
+            if (p.recall !== undefined && typeof p.recall !== 'boolean' && p.recall !== null) {
+                throw new Error(`非法注入覆盖: ${String(p.recall)}（允许 true/false/null）`);
+            }
             modes.set(sessionId, p.mode);
-            deps.logger.info(`[memory] 会话档位设置 session=${sessionId} mode=${p.mode}`);
-            const v = { sessionId, mode: p.mode };
+            if (typeof p.recall === 'boolean') {
+                modes.setRecall(sessionId, p.recall);
+            }
+            else if (p.recall === null) {
+                modes.setRecall(sessionId, undefined);
+            }
+            deps.logger.info(`[memory] 会话档位设置 session=${sessionId} mode=${p.mode} recall=${JSON.stringify(modes.getRecall(sessionId) ?? null)}`);
+            const s = live?.get();
+            const v = {
+                sessionId,
+                mode: p.mode,
+                recall: modes.getRecall(sessionId) ?? null,
+                recallResolved: modes.resolvedRecall(sessionId, s?.recall ?? true),
+            };
             return v;
         }
         // ── 会话级统计（悬浮卡信息区；热路径端点，见 SessionInfoSource 的零 I/O 硬规则） ──
@@ -192,7 +219,20 @@ async function handleEndpoint(endpoint, payload, deps) {
             const caps = sessionInfo.capabilities();
             const l0Count = await sessionInfo.l0Count(sessionId);
             const s = live?.get();
-            const recallOn = cfg.recall.enabled && (s?.recall ?? true) && mode !== 'off';
+            // 注入生效四因子短路序（#38）：部署上限 → 全局开关 → 会话覆盖 → 档位；
+            // disabled 时 reason 带第一个为假因子（悬浮卡停用文案的数据源）
+            const globalRecall = s?.recall ?? true;
+            const sessionRecall = modes ? modes.resolvedRecall(sessionId, globalRecall) : true;
+            let recallReason;
+            if (!cfg.recall.enabled)
+                recallReason = 'deploy';
+            else if (!globalRecall)
+                recallReason = 'global';
+            else if (!sessionRecall)
+                recallReason = 'session';
+            else if (mode === 'off')
+                recallReason = 'mode';
+            const recallOn = recallReason === undefined;
             const view = sessionInfo.runnerView(sessionId, mode);
             // lastDistillAt 统一转 ISO（与 global.lastExtractAt 口径一致，client 直接 fmtAgo）
             const distillView = { ...view, lastDistillAt: view.lastDistillAt ? new Date(view.lastDistillAt).toISOString() : null };
@@ -220,7 +260,11 @@ async function handleEndpoint(endpoint, payload, deps) {
                 sessionId,
                 mode,
                 defaultMode: modes?.default ?? cfg.family,
-                recall: { enabled: recallOn, ...(sessionInfo.recallStats(sessionId) ?? emptyRecallStats()) },
+                recall: {
+                    enabled: recallOn,
+                    ...(recallReason ? { reason: recallReason } : {}),
+                    ...(sessionInfo.recallStats(sessionId) ?? emptyRecallStats()),
+                },
                 memoryOccupancy: sessionInfo.memoryOccupancy(sessionId),
                 occupancyBackfill: sessionInfo.profileEstimate
                     ? {

package/dist/store/session-modes.d.ts

@@ -17,6 +17,13 @@ export declare class SessionModeStore {
     get default(): MemoryMode;
     /** 同步读取：未设置过的会话返回默认档。 */
     get(sessionId: string): MemoryMode;
+    /** 会话级注入覆盖原始值（#38）：undefined = 未覆盖，跟随全局。 */
+    getRecall(sessionId: string): boolean | undefined;
+    /** 解析后的注入开关：会话覆盖 ?? 全局运行时开关（部署级 cfg.recall.enabled
+     *  与主闸 s.enabled 不经此处，仍按既有硬门生效——覆盖打不穿部署上限）。 */
+    resolvedRecall(sessionId: string, globalRecall: boolean): boolean;
+    /** 设置会话级注入覆盖（#38；undefined = 清除覆盖跟随全局。写穿持久化）。 */
+    setRecall(sessionId: string, recall: boolean | undefined): void;
     /** 注册档位切换回调（同步调用；回调异常只记日志不阻断写穿）。 */
     setModeChangeHandler(cb: (sessionId: string, oldMode: MemoryMode, newMode: MemoryMode) => void): void;
     /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */

package/dist/store/session-modes.js

@@ -42,7 +42,12 @@ export class SessionModeStore {
                 continue;
             if (now - (entry.updatedAt ?? 0) > PRUNE_MS)
                 continue;
-            this.entries.set(sid, { mode: entry.mode, updatedAt: entry.updatedAt ?? now });
+            this.entries.set(sid, {
+                mode: entry.mode,
+                // 非布尔视为损坏丢弃（= 跟随全局）；旧文件无此键同款兼容
+                recall: typeof entry.recall === 'boolean' ? entry.recall : undefined,
+                updatedAt: entry.updatedAt ?? now,
+            });
             count++;
         }
         if (count > 0)
@@ -55,6 +60,25 @@ export class SessionModeStore {
     get(sessionId) {
         return this.entries.get(sessionId)?.mode ?? this.loaded;
     }
+    /** 会话级注入覆盖原始值（#38）：undefined = 未覆盖，跟随全局。 */
+    getRecall(sessionId) {
+        return this.entries.get(sessionId)?.recall;
+    }
+    /** 解析后的注入开关：会话覆盖 ?? 全局运行时开关（部署级 cfg.recall.enabled
+     *  与主闸 s.enabled 不经此处，仍按既有硬门生效——覆盖打不穿部署上限）。 */
+    resolvedRecall(sessionId, globalRecall) {
+        return this.entries.get(sessionId)?.recall ?? globalRecall;
+    }
+    /** 设置会话级注入覆盖（#38；undefined = 清除覆盖跟随全局。写穿持久化）。 */
+    setRecall(sessionId, recall) {
+        const entry = this.entries.get(sessionId);
+        this.entries.set(sessionId, {
+            mode: entry?.mode ?? this.loaded,
+            recall,
+            updatedAt: Date.now(),
+        });
+        this.writeChain = this.writeChain.then(() => this.persist());
+    }
     /** 注册档位切换回调（同步调用；回调异常只记日志不阻断写穿）。 */
     setModeChangeHandler(cb) {
         this.onModeChange = cb;
@@ -62,7 +86,9 @@ export class SessionModeStore {
     /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */
     set(sessionId, mode) {
         const old = this.get(sessionId);
-        this.entries.set(sessionId, { mode, updatedAt: Date.now() });
+        // 已有注入覆盖跨切档保留（#38：档位与注入正交，切档不动覆盖）
+        const recall = this.entries.get(sessionId)?.recall;
+        this.entries.set(sessionId, { mode, recall, updatedAt: Date.now() });
         this.writeChain = this.writeChain.then(() => this.persist());
         if (old !== mode && this.onModeChange) {
             try {

package/dist/tools/index.d.ts

@@ -4,9 +4,12 @@
  * 会话档位联动：execute 的 exec.agent 即发起调用的 agent（agent.id === sessionId），
  * memory_search 按会话档位过滤族（auto 不过滤，纯档只查本族）；off 档下三工具统一
  * 返回提示（本会话已对记忆系统隐身）。conversation_search 检索范围保持全库。
+ * 只写会话（#38：注入覆盖=关）同款拒读，notice 区分文案——写入走捕获钩子不经工具，
+ * 拒读不影响"只写"语义。
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { MemoryConfig } from '../config.js';
+import type { LiveSettingsHandle } from '../settings.js';
 import type { L0Store } from '../store/l0.js';
 import type { L1Store } from '../store/l1.js';
 import type { PersonaStore } from '../store/persona.js';
@@ -18,4 +21,4 @@ export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, sto
     l1: L1Store;
     scenes: Record<MemoryFamily, SceneStore>;
     persona: Record<MemoryFamily, PersonaStore>;
-}, logger: MemoryLogger, modes: SessionModeStore): void;
+}, logger: MemoryLogger, modes: SessionModeStore, live: LiveSettingsHandle): void;

package/dist/tools/index.js

@@ -1,10 +1,12 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 const OFF_NOTICE = '本会话的记忆档位为"关闭"：该会话对记忆系统完全隐身，不读取也不写入记忆。';
-export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
+const WRITE_ONLY_NOTICE = '本会话为只写模式：记忆照常沉淀，但不读取。';
+const GLOBAL_OFF_NOTICE = '记忆注入已全局停用：本会话不读取记忆（沉淀照常）。';
+export function registerMemoryTools(ctx, cfg, stores, logger, modes, live) {
     if (!cfg.tools)
         return;
     /**
-     * 调用会话的检索族（auto → undefined 不过滤；off → null 表示整体禁用）。
+     * 调用会话的检索族（auto → undefined 不过滤；off/只写 → null 表示整体禁用）。
      * fail-open：exec.agent 缺失（宿主调用路径未带 agent 标识）按全族检索放行——
      * 档位隔离依赖宿主正确传递 exec.agent.id，缺失只告警一次不拒绝工具调用。
      */
@@ -20,8 +22,24 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         const mode = modes.get(agentId);
         if (mode === 'off')
             return null;
+        // 只写会话拒读（#38，T2 裁决）：与注入同属读维度，不拒则"不注入"从工具路径漏风
+        if (!modes.resolvedRecall(agentId, live.get().recall))
+            return null;
         return mode === 'auto' ? undefined : mode;
     };
+    /** 拒读时的归因文案（familyOfCaller 判 null 后重查内存 Map，成本可忽略）：
+     *  off 完全隐身 / 会话只写覆盖 / 全局召回关——三种停用各说各话，不谎报只写。 */
+    const blockNoticeOf = (agentId) => {
+        if (agentId !== undefined) {
+            if (modes.get(agentId) === 'off')
+                return OFF_NOTICE;
+            if (modes.getRecall(agentId) === false)
+                return WRITE_ONLY_NOTICE;
+            if (!modes.resolvedRecall(agentId, live.get().recall))
+                return GLOBAL_OFF_NOTICE;
+        }
+        return OFF_NOTICE;
+    };
     // ── memory_search: L1 结构化记忆 ──
     ctx.tools.register(defineTool({
         name: 'memory_search',
@@ -59,7 +77,7 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         execute: async (args, exec) => {
             const family = familyOfCaller(exec.agent?.id);
             if (family === null)
-                return { items: [], notice: OFF_NOTICE };
+                return { items: [], notice: blockNoticeOf(exec.agent?.id) };
             const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
             const hits = await stores.l1.search(args.query, limit, { type: args.type || undefined, family: family ?? undefined });
             return {
@@ -107,7 +125,7 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         },
         execute: async (args, exec) => {
             if (familyOfCaller(exec.agent?.id) === null)
-                return { items: [], notice: OFF_NOTICE };
+                return { items: [], notice: blockNoticeOf(exec.agent?.id) };
             const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
             const records = await stores.l0.search(args.query, limit);
             return {
@@ -141,7 +159,7 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         },
         execute: async (args, exec) => {
             if (familyOfCaller(exec.agent?.id) === null)
-                return { content: OFF_NOTICE };
+                return { content: blockNoticeOf(exec.agent?.id) };
             const p = args.path.trim();
             let content;
             if (p === 'persona.md' || p === 'persona-chat.md' || p === 'persona' || p === 'persona-chat') {

package/package.json

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