dsh-memory-palace 1.2.2 → 1.4.0

package/README.md

@@ -1,10 +1,8 @@
-# dsh-memory-palace
+# dsh-memory-palace <img src="assets/memory-icon.svg" width="36" height="36" alt="dsh-memory-palace" />
 
 把 WorkBuddy 的文件式记忆系统移植进 [DeepSeek Harness](https://www.deepseek.com/harness/) —— 为 Harness 提供**跨会话持久化、人类可直接编辑的 Markdown 记忆**。
 
-[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
-
-记忆就是普通文本文件，用记事本就能改。AI 每轮对话把它读进上下文，对话结束后把新内容追加进日志——不依赖任何私有格式、不落 JSON、不锁数据。
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE) [![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
 
 ## 特性
 
@@ -37,10 +35,6 @@
         └── 2026-08-16.md          # 每日工作日志
 ```
 
-> **布局迭代（v1.1.x）**：早期版本曾把项目级 MEMORY.md 放在 `.deepseek-harness/memory/MEMORY.md`（嵌套）；现已改为与 `memory/` **同级**（`.deepseek-harness/MEMORY.md`）。旧嵌套位置仍会被读取（向后兼容、不丢旧数据），但**写入一律走同级**。
-
-> **桥接规则**：`bridgeBuddyMemory` 开启时，只要项目里存在任一 buddy 记忆目录，就**只**读写这些目录，不再创建 `.deepseek-harness/memory/`；全部不存在时才回退到 dsh 目录。buddy 目录绝不被主动创建。
-
 ## 工作原理
 
 **读取（每轮对话）**——`systemPrompt.section` 同步读盘，把以下内容拼进系统提示词：
@@ -80,7 +74,7 @@ turn/end ──► 轻量兜底闸门
 
 ```bash
 dsh plugin --profile web add github:lovezi0/dsh-memory-palace
-# 锁定版本：dsh plugin --profile web add github:lovezi0/dsh-memory-palace#v1.2.2
+# 锁定版本：dsh plugin --profile web add github:lovezi0/dsh-memory-palace#v1.4.0
 ```
 
 方式二：clone 后本地安装（开发 / 修改源码场景）
@@ -99,7 +93,7 @@ dsh plugin --profile web add .    # 装入 web profile（profile 名按你的实
 # 直接由 dsh 从 npm 拉取并装入（本机若已配镜像会自动走镜像）
 dsh plugin --profile web add dsh-memory-palace
 # 锁定版本：
-dsh plugin --profile web add dsh-memory-palace@1.2.2
+dsh plugin --profile web add dsh-memory-palace@1.4.0
 
 # 或先手动用 npm 安装（显式指定镜像），再装入：
 npm install dsh-memory-palace --registry=https://registry.npmmirror.com/
@@ -113,49 +107,27 @@ dsh plugin --profile web remove dsh-memory-palace
 ```
 
 ## 配置
-
-可在 DSH 设置 →「记忆」面板中调整，或通过 profile 配置注入：
-
-| 配置项 | 默认值 | 说明 |
-|---|---|---|
-| 总开关 | `true` | 总开关，关闭后不注入、不写入 |
-| 用户级记忆路径 | `~/.deepseek-harness/MEMORY.md` | 用户级记忆文件路径（支持 `~` 展开） |
-| 工作区记忆目录 | `.deepseek-harness/memory` | 无 buddy 目录时回退的项目记忆目录 |
-| 日志保留天数 | `30` | 每日日志保留天数，过期迁移进 `MEMORY.md` |
-| 用户级记忆字数上限 | `4000` | 注入系统提示词的用户级记忆长度上限（字符） |
-| 工作区级记忆字数上限 | `3000` | 注入系统提示词的工作区级记忆长度上限（字符） |
-| 桥接 Buddy 记忆 | `true` | 检测并直接读写 WorkBuddy / CodeBuddy 项目记忆目录 |
-| Buddy 记忆目录列表 | `[".workbuddy/memory", ".codebuddy/memory"]` | 要桥接的 buddy 目录列表（按优先级，已存在的全部同步写入） |
-
-### 自动记录（设置页「记忆 → 自动记录」卡片）
-
-| 配置项 | 默认值 | 说明 |
-|---|---|---|
-| 记忆模式 | `plugin` | 两种互斥模式：`plugin`=记忆公民指令+轮次轻量+错误捕获（默认）；`smart`=LLM 智能会话摘要（summary→每日日志 + durable→MEMORY.md，带 `[smart]` 标记）。**切换需重启 dsh 生效** |
-| 轮次结束自动记录 | `true` | 插件模式下：它是「agent 主动记忆」主路径失效时的安全网，保证实质工作不丢，代价是只留原始文本、不做总结。智能模式下该开关仍为总闸门 |
-| 摘要模型 | `""`（空=复用当前会话模型） | 智能模式专用：留空自动复用当前会话 provider/model；填 `provider/model`（如 `deepseek/deepseek-chat`）固定廉价模型省 token |
-| 对话出错自动记录 | `true` | 插件模式下：自动捕获 in-session 错误并写入「错误现象」到对应 MEMORY.md；「根因/方案」由 agent 主动记；默认开启，**关闭无需重启 dsh**。智能模式下错误由 LLM 摘要统一提炼 |
-
-> **设置保存（v1.1.4 起）**：设置页保存已**真正落盘**
->
-> 历史方案（仍可用作兜底）：直接在 profile 的 `cordis.patch.yml` 注入配置（id-targeted config override，与插件 bundle insert 的 id 一致）：
->
-> ```yaml
-> - id: memory-palace
->   name: 'dsh-memory-palace'
->   config:
->     memoryMode: smart
->     summaryModel: ''
-> ```
->
-> 修改后重启 dsh 生效。
+*面板路径为 DSH 设置 →「记忆」*
+所有配置项（基础 / 自动记录 / 开发 三张卡片的字段、默认值与说明）已整理至 [CONFIG.md](./CONFIG.md)
 
 ## 开发
 
-目录结构、构建与测试、技术要点见 [DEVELOPMENT.md](./DEVELOPMENT.md)。
+架构 / 构建 / 技术要点 / 蒸馏失败重试 见 [DEVELOPMENT.md](./DEVELOPMENT.md)。
+提示词与智能模式蒸馏（公民指令 / 摘要 / 蒸馏） 见 [PROMPTS.md](./PROMPTS.md)。
 
 ## 版本历史
 
+- **1.4.0**
+    - 🔥智能模式增加最大输出Token限制
+    - 🔥智能模式增加失败重试机制
+    - 🔥智能模式会增加回馈存量记忆
+    - 🐛修复自动记录部分设置位置错误问题
+- **1.3.0**
+    - 🔥新增计划模式禁止写入记忆
+    - 💪设置-记忆控件样式优化 *使用dsh原生样式*
+    - 💪清理重复patch信息
+    - 🔥增加调试模式 *默认关闭，仅用于智能模式蒸馏失败输出调试信息*
+- **1.2.3**
 - **1.2.2**
     - 🐛修复智能模式自定义摘要模型不生效的问题
 - **1.2.1**
@@ -179,10 +151,6 @@ dsh plugin --profile web remove dsh-memory-palace
     - 🔥新增删除记忆工具
 - **outdated（0.x）** — 双层 Markdown 记忆读写 / 设置页集成等 0.x 历史，见 [CHANGELOG.md](./CHANGELOG.md)
 
-## 废弃方案
-
-插件侧 LLM 自动摘要（`ctx.llm.stream()` 路线）曾在 v0.7.1 因 4 个契约/时机坑废弃；**v1.1.0 已重新论证并以「智能模式」可选形态复活**——经 `session.events` / `deriveEventMessage` / `requestHeader()?.config` 根除旧坑，默认仍为插件模式。见 [废弃方案：为什么不用 LLM 自动摘要](./ABANDONED-LLM-SUMMARY.md)。
-
 ## 参考与致谢
 
 本插件开发深度参考了以下两个开源项目（本包实现为各自机制的简化落地，不含其完整功能）：

package/cordis.patch.yml

@@ -1,17 +1,9 @@
 # dsh-memory-palace bundle patch: 一个 insert 注册本插件。
 # insert.name 必须是【包名】（pnpm add 后由 profile 的 node_modules 解析到 lib/index.js）；
 # insert.id 必须与入口导出的 cordis `name`（'memory-palace'）一致。
+# 注：包不再自带 config 块——值与原 Config schema 默认一致，cordis 按 schema 填充默认，
+#     不传 config 不会 undefined。如需在 profile 层注入覆盖配置，走自己 profile 的
+#     cordis.patch.yml（`- id: memory-palace` + `config:`，id-targeted，非 insert）。
 - insert:
     - id: memory-palace
       name: 'dsh-memory-palace'
-      config:
-        enabled: true
-        userMemoryPath: '~/.deepseek-harness/MEMORY.md'
-        workspaceMemoryDir: '.deepseek-harness/memory'
-        dailyLogRetentionDays: 30
-        userBudgetChars: 4000
-        workspaceBudgetChars: 3000
-        bridgeBuddyMemory: true
-        buddyWorkspaceMemoryDirs:
-          - '.workbuddy/memory'
-          - '.codebuddy/memory'

package/lib/api.mjs

@@ -167,7 +167,8 @@ export function registerApi({ ctx, paths, distill, state, getSettingsFace }) {
                   throw Object.assign(new Error("no memory dirs for this workspace"), { code: "bad-request", status: 400 });
                 }
                 // 整段会话全量蒸馏（fromSeq=0）；成功后推进增量断点，防智能模式对同段事件重复摘要。
-                const r = await distill.distillSessionCore(session, dirs, 0);
+                // allowDelete:true —— 手动按钮开放 delete 操作（自动智能模式传 false，见 summarizeTurn）。
+                const r = await distill.distillSessionCore(session, dirs, 0, { allowDelete: true });
                 if (r.ok && session.id === state.summarySessionId) state.lastSummarizedSeq = session.seq;
                 apiWriteOk(res, r);
                 return;

package/lib/client.js

@@ -32,7 +32,7 @@ window.__ModuleLoader__.load({
       wsBudgetLabel: "工作区预算（字符）",
       wsBudgetHint: "工作区 MEMORY.md 的最大字符数",
       summarizeLabel: "轮次结束自动记录",
-      summarizeHint: "它是「agent 主动记忆」主路径失效时的安全网，保证实质工作不丢，代价是只留原始文本、不做总结。",
+      summarizeHint: "两种记忆模式的共用总闸门：关闭后无论插件模式还是智能模式都不写记忆。插件模式下它作为「agent 主动记忆」主路径失效时的安全网，只留原始文本、不做总结；智能模式下开启则走 LLM 智能摘要（总结 + 提炼）。",
       autoCaptureErrorsLabel: "对话出错时自动记录到记忆",
       autoCaptureErrorsHint: "对话中（含代码运行报错、工具执行失败）出错时，自动把「错误现象」写入对应 MEMORY.md（用户级/项目级）；「根因/方案」由 agent 按记忆公民指令主动记。默认开，关闭无需重启。",
       memoryModeLabel: "记忆模式",
@@ -62,7 +62,18 @@ window.__ModuleLoader__.load({
       distilling: "蒸馏中…",
       notifySessionDone: "会话记忆蒸馏完成",
       notifyProjectDone: "项目记忆蒸馏完成",
-      notifyFail: "记忆蒸馏失败"
+      notifyFail: "记忆蒸馏失败",
+      distillDebugLogLabel: "蒸馏调试日志",
+      distillDebugLogHint: "开启后向 dsh 服务端控制台（stderr）输出蒸馏 LLM 调用诊断，仅排障用，平时关闭。",
+      dev: "开发",
+      distillTimeoutLabel: "蒸馏超时（秒）",
+      distillTimeoutHint: "单次蒸馏 LLM 调用的超时上限（秒）；超时视为失败并降级。覆盖智能模式摘要与手动蒸馏，默认 60 秒。",
+      summaryMaxTokensLabel: "会话摘要最大 Token（智能模式）",
+      summaryMaxTokensHint: "智能模式会话摘要 LLM 的最大输出 Token（summary + durable 合计上限）。默认 2000，过小会截断 durable 事实，可上调到 4000+。",
+      projectMaxTokensLabel: "项目蒸馏最大 Token",
+      projectMaxTokensHint: "手动「蒸馏项目记忆」LLM 的最大输出 Token（蒸馏后 MEMORY.md 长度上限）。默认 8000，过小会截断浓缩结果，可上调。",
+      feedbackEnabledLabel: "蒸馏回喂存量记忆",
+      feedbackEnabledHint: "开启后，自动智能模式（turn/end）与手动蒸馏会话按钮均会把项目级 + 用户级 MEMORY.md 全文（逐行编号、无截断）回喂 LLM，使其能基于既有记忆做 add/replace/delete 增量维护。delete 仅手动蒸馏按钮开放，自动模式跳过（防误删）。默认关。"
     };
 
     const en = {
@@ -87,7 +98,7 @@ window.__ModuleLoader__.load({
       wsBudgetLabel: "Workspace budget (chars)",
       wsBudgetHint: "Max chars for the workspace MEMORY.md",
       summarizeLabel: "Auto-record at turn end",
-      summarizeHint: "It is the safety net when the 'agent proactive memory' main path fails: substantive work is never lost, at the cost of keeping only raw text without summarization.",
+      summarizeHint: "The shared master gate for both memory modes: when off, neither plugin nor smart mode writes any memory. In plugin mode it is the safety net when the 'agent proactive memory' main path fails (keeps raw text, no summarization); in smart mode it enables the LLM summarization path (summary + extraction).",
       autoCaptureErrorsLabel: "Auto-record conversation errors",
       autoCaptureErrorsHint: "On in-session errors, auto write the 'error' into the corresponding MEMORY.md (user/project); 'root cause / fix' is recorded proactively by the agent. On by default; off takes effect without restart.",
       memoryModeLabel: "Memory mode",
@@ -117,12 +128,23 @@ window.__ModuleLoader__.load({
       distilling: "Distilling…",
       notifySessionDone: "Session memory distilled",
       notifyProjectDone: "Project memory distilled",
-      notifyFail: "Memory distillation failed"
+      notifyFail: "Memory distillation failed",
+      distillDebugLogLabel: "Distill debug log",
+      distillDebugLogHint: "When on, prints distill LLM call diagnostics to the dsh server console (stderr). For troubleshooting only; keep off normally.",
+      dev: "Developer",
+      distillTimeoutLabel: "Distill timeout (s)",
+      distillTimeoutHint: "Timeout (in seconds) for a single distill LLM call; on timeout it fails and degrades. Covers both smart-mode summary and manual distillation. Default 60s.",
+      summaryMaxTokensLabel: "Session summary max tokens (smart mode)",
+      summaryMaxTokensHint: "Max output tokens for the smart-mode session summary LLM call (summary + durable combined cap). Default 2000; too low truncates durable facts, raise to 4000+ if needed.",
+      projectMaxTokensLabel: "Project distill max tokens",
+      projectMaxTokensHint: "Max output tokens for the manual 'distill project memory' LLM call (cap on the resulting MEMORY.md length). Default 8000; too low truncates the condensed result, raise if needed.",
+      feedbackEnabledLabel: "Feed existing memory into distillation",
+      feedbackEnabledHint: "When on, both the auto smart-mode (turn/end) and the manual session distillation feed the full project-level + user-level MEMORY.md (line-numbered, no truncation) back to the LLM so it can maintain memory incrementally via add/replace/delete. delete is only allowed via the manual distill button; auto mode skips it (to avoid accidental memory loss). Off by default."
     };
 
 
-    const FIELD_NUMERIC = new Set(["dailyLogRetentionDays", "userBudgetChars", "workspaceBudgetChars"]);
-    const FIELD_BOOL = new Set(["bridgeBuddyMemory", "summarize", "autoCaptureErrors"]);
+    const FIELD_NUMERIC = new Set(["dailyLogRetentionDays", "userBudgetChars", "workspaceBudgetChars", "summaryTimeoutMs", "summaryMaxTokens", "projectMaxTokens"]);
+    const FIELD_BOOL = new Set(["bridgeBuddyMemory", "summarize", "autoCaptureErrors", "distillDebugLog", "feedbackEnabled"]);
 
     function projectDraft(snap) {
       const v = snap && snap.value ? snap.value : {};
@@ -136,8 +158,13 @@ window.__ModuleLoader__.load({
         workspaceBudgetChars: v.workspaceBudgetChars != null ? String(v.workspaceBudgetChars) : "3000",
         summarize: v.summarize === false ? "false" : "true",
         autoCaptureErrors: v.autoCaptureErrors === false ? "false" : "true",
+        distillDebugLog: v.distillDebugLog === false ? "false" : "true",
+        summaryTimeoutMs: v.summaryTimeoutMs != null ? String(Math.round((Number(v.summaryTimeoutMs) || 0) / 1000)) : "60",
         memoryMode: v.memoryMode || "plugin",
-        summaryModel: v.summaryModel || ""
+        summaryModel: v.summaryModel || "",
+        summaryMaxTokens: v.summaryMaxTokens != null ? String(v.summaryMaxTokens) : "2000",
+        projectMaxTokens: v.projectMaxTokens != null ? String(v.projectMaxTokens) : "8000",
+        feedbackEnabled: v.feedbackEnabled === false ? "false" : "true"
       };
     }
 
@@ -266,7 +293,10 @@ window.__ModuleLoader__.load({
             if (FIELD_BOOL.has(field)) {
               section[field] = text === "true";
             } else if (FIELD_NUMERIC.has(field)) {
-              if (text !== "") section[field] = Number(text);
+              if (text !== "") {
+                const n = Number(text);
+                section[field] = field === "summaryTimeoutMs" ? n * 1000 : n;
+              }
             } else if (field === "buddyWorkspaceMemoryDirs") {
               section[field] = text.split(",").map((s) => s.trim()).filter(Boolean);
             } else {
@@ -296,9 +326,11 @@ window.__ModuleLoader__.load({
       const userLayer = remote.user && typeof remote.user === "object" ? remote.user : {};
       const isOverridden = (field) => field in userLayer;
 
+      // 左侧文字容器：min-width:0 + flexShrink:1 让长描述正常换行收缩，不再撑爆 flex 把 checkbox 挤变形。
+      const toggleLabelBoxStyle = { flexShrink: 1, minWidth: 0 };
       const toggle = (label, hint, field, disabledOverride) =>
         h("div", { style: toggleStyle }, [
-          h("div", null, [
+          h("div", { style: toggleLabelBoxStyle }, [
             h("p", { style: { ...labelStyle, margin: 0 } }, label),
             h("p", { style: hintStyle }, hint)
           ]),
@@ -306,6 +338,7 @@ window.__ModuleLoader__.load({
             type: "checkbox",
             checked: draft[field] === "true",
             disabled: disabled || disabledOverride,
+            style: checkboxStyle,
             onChange: (e) => edit(field, e.target.checked ? "true" : "false")
           })
         ]);
@@ -333,6 +366,27 @@ window.__ModuleLoader__.load({
         fontSize: "13px",
         lineHeight: "1.5"
       };
+      const selectStyle = {
+        ...inputStyle,
+        height: "34px",
+        appearance: "none",
+        WebkitAppearance: "none",
+        backgroundImage: "url(data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12' fill='none'%3E%3Cpath d='M3 4.5L6 7.5L9 4.5' stroke='%2381858C' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E)",
+        backgroundPosition: "right 12px center",
+        backgroundRepeat: "no-repeat",
+        backgroundSize: "12px 12px",
+        paddingRight: "32px"
+      };
+      const checkboxStyle = {
+        width: "18px",
+        height: "18px",
+        margin: "0",
+        accentColor: "var(--dsw-alias-brand-primary, #4b5bff)",
+        // 锁死：不被 flex 长描述挤压缩（flex-shrink 默认 1 会在布局阶段无视 width/!important）。
+        flexShrink: 0,
+        flexGrow: 0,
+        alignSelf: "center"
+      };
       const toggleStyle = {
         display: "flex",
         alignItems: "center",
@@ -431,7 +485,9 @@ window.__ModuleLoader__.load({
         onChange: (e) => edit(field, e.target.value)
       });
 
-      return h("div", { style: sectionStyle }, [
+      return h("div", { className: "memory-palace-settings", style: sectionStyle }, [
+        // 强制覆盖宿主 Webview 全局样式对原生 checkbox 尺寸的覆盖（内联 style 可能不敌全局 CSS）。
+        h("style", null, ".memory-palace-settings input[type=checkbox]{width:18px!important;height:18px!important;margin:0;flex-shrink:0!important;cursor:pointer;}"),
         h("div", { style: { display: "flex", alignItems: "flex-start", justifyContent: "space-between", gap: "12px" } }, [
           h("div", null, [
             h("h3", { style: headingStyle }, t("title")),
@@ -446,7 +502,7 @@ window.__ModuleLoader__.load({
         h("div", { style: cardStyle }, [
           h("p", { style: groupTitleStyle }, t("core")),
           h("div", { style: toggleStyle }, [
-            h("div", null, [
+            h("div", { style: { flexShrink: 1, minWidth: 0 } }, [
               h("p", { style: { ...labelStyle, margin: 0 } }, t("bridgeLabel")),
               h("p", { style: hintStyle }, t("bridgeHint"))
             ]),
@@ -454,6 +510,7 @@ window.__ModuleLoader__.load({
               type: "checkbox",
               checked: draft.bridgeBuddyMemory === "true",
               disabled,
+              style: checkboxStyle,
               onChange: (e) => edit("bridgeBuddyMemory", e.target.checked ? "true" : "false")
             })
           ]),
@@ -466,30 +523,37 @@ window.__ModuleLoader__.load({
         ]),
         h("div", { style: cardStyle }, [
           h("p", { style: groupTitleStyle }, t("smartSummary")),
+          // 轮次结束自动记录(summarize)：两种记忆模式的共用总闸门，始终显示，置于记忆模式之上、不随模式切换隐藏。
+          toggle(t("summarizeLabel"), t("summarizeHint"), "summarize"),
           row(t("memoryModeLabel"), draft.memoryMode === "smart" ? t("memoryModeHintSmart") : t("memoryModeHintPlugin"),
             h("select", {
               value: draft.memoryMode === "smart" ? "smart" : "plugin",
               disabled,
               onChange: (e) => edit("memoryMode", e.target.value),
-              style: { ...inputStyle, height: "34px" }
+              style: selectStyle
             }, [
               h("option", { value: "plugin" }, "插件模式"),
               h("option", { value: "smart" }, "智能模式")
             ]), "memoryMode"),
           draft.memoryMode === "smart"
-            ? row(t("summaryModelLabel"), t("summaryModelHint"),
-                h("select", {
-                  // 已存储值不在下拉选项内（如旧版双前缀脏数据）→ 归零为「复用当前会话模型」，
-                  // 避免 select 显示悬空值、保存时又把脏值写回 settings.yaml。
-                  value: modelOptions.some((o) => o.value === draft.summaryModel) ? draft.summaryModel : "",
-                  disabled,
-                  onChange: (e) => edit("summaryModel", e.target.value)
-                }, [
-                  h("option", { value: "" }, "复用当前会话模型"),
-                  ...modelOptions.map((o) => h("option", { value: o.value }, o.label))
-                ]), "summaryModel")
+            ? h("div", null, [
+                row(t("summaryModelLabel"), t("summaryModelHint"),
+                  h("select", {
+                    // 已存储值不在下拉选项内（如旧版双前缀脏数据）→ 归零为「复用当前会话模型」，
+                    // 避免 select 显示悬空值、保存时又把脏值写回 settings.yaml。
+                    value: modelOptions.some((o) => o.value === draft.summaryModel) ? draft.summaryModel : "",
+                    disabled,
+                    style: selectStyle,
+                    onChange: (e) => edit("summaryModel", e.target.value)
+                  }, [
+                    h("option", { value: "" }, "复用当前会话模型"),
+                    ...modelOptions.map((o) => h("option", { value: o.value }, o.label))
+                  ]), "summaryModel"),
+                toggle(t("feedbackEnabledLabel"), t("feedbackEnabledHint"), "feedbackEnabled"),
+                row(t("summaryMaxTokensLabel"), t("summaryMaxTokensHint"), h("input", num("summaryMaxTokens")), "summaryMaxTokens"),
+                row(t("projectMaxTokensLabel"), t("projectMaxTokensHint"), h("input", num("projectMaxTokens")), "projectMaxTokens")
+              ])
             : h("div", null, [
-                toggle(t("summarizeLabel"), t("summarizeHint"), "summarize"),
                 toggle(t("autoCaptureErrorsLabel"), t("autoCaptureErrorsHint"), "autoCaptureErrors")
               ])
         ]),
@@ -500,6 +564,11 @@ window.__ModuleLoader__.load({
           row(t("retentionLabel"), t("retentionHint"), h("input", num("dailyLogRetentionDays")), "dailyLogRetentionDays"),
           row(t("userBudgetLabel"), t("userBudgetHint"), h("input", num("userBudgetChars")), "userBudgetChars"),
           row(t("wsBudgetLabel"), t("wsBudgetHint"), h("input", num("workspaceBudgetChars")), "workspaceBudgetChars")
+        ]),
+        h("div", { style: cardStyle }, [
+          h("p", { style: groupTitleStyle }, t("dev")),
+          row(t("distillTimeoutLabel"), t("distillTimeoutHint"), h("input", num("summaryTimeoutMs")), "summaryTimeoutMs"),
+          toggle(t("distillDebugLogLabel"), t("distillDebugLogHint"), "distillDebugLog")
         ])
       ]);
     }

package/lib/common/prompts.mjs

@@ -4,17 +4,42 @@
 // 场景关键词（增强原方案 D）：命中即视为"用户告知偏好 / 做出技术决策"，纯文本轮次也写。
 export const SCENE_KEYWORDS = ["记住", "记一下", "remind", "偏好", "决定", "以后都", "约定", "采用", "根因", "修复"];
 
-// 智能模式（memoryMode==="smart"）的摘要提炼 prompt：让 LLM 输出 {summary, durable:[{scope,fact}]}。
-// 产物：summary → 每日日志（带 [smart] 标记）；durable → MEMORY.md（- [smart] <fact>，按 scope 分层）。
-export const SUMMARY_PROMPT =
-  "你是会话记忆提炼助手。根据下面这段【新产生的】对话（含工具调用与结果），提炼两样东西：\n" +
-  "1) summary：一段简洁中文摘要——这段对话做了什么、关键结果（路径/命令/数字）。\n" +
-  "2) durable：值得跨 session 长期记住的事实列表（最多 3 条），每条带 scope：\n" +
-  '   - "project" = 当前项目的约定/决策/技术事实\n' +
-  '   - "user" = 跨项目的个人偏好/习惯\n' +
-  "   闲聊、一次性操作、显而易见的内容、纯错误现象（错误已有独立记录）不要提炼；没有就留空数组。\n" +
-  "只输出 JSON，不要多余文字，格式：\n" +
-  '{"summary":"...","durable":[{"scope":"project","fact":"一句话"}]}';
+// 智能模式（memoryMode==="smart"）的摘要提炼 prompt（v1.4.0 起为函数，支持回喂存量记忆）。
+// 让 LLM 输出 {summary, durable:[{scope,fact}], memoryOps:[...]}；memoryOps 用于基于编号的现有记忆做增量维护。
+// allowDelete=true（手动蒸馏按钮）：开放 add/replace/delete；false（自动智能模式）：禁 delete，仅 add/replace。
+// 注意：回喂是否实际发生由 distill.mjs 按 cfg().feedbackEnabled 决定（智能模式级，自动/手动均生效）；
+// 此处仅声明能力边界——allowDelete 决定 prompt 是否允许 delete 指令（自动模式禁 delete，手动按钮放开）。
+export function SUMMARY_PROMPT({ allowDelete = false } = {}) {
+  const feedbackInstr = allowDelete
+    ? "【维护现有记忆】若对话中提供了「项目级记忆 / 用户级记忆（逐行编号）」，你可在输出 memoryOps 中对现有记忆做增量维护：\n" +
+      '- add：新增一条事实（scope + fact），勿与现有重复；\n' +
+      '- replace：line=现有行号，oldText=该行精确原文，newText=替换后全文（仅内容行，禁止改动 # / <!-- 结构行）；\n' +
+      '- delete：line=现有行号，oldText=该行精确原文（仅内容行，禁止删除 # / <!-- 结构行）；\n' +
+      "所有 replace/delete 必须带 oldText 精确匹配（匹配失败将被拒绝、不修改任何内容）。"
+    : "【维护现有记忆】若对话中提供了「项目级记忆 / 用户级记忆（逐行编号）」，你可在输出 memoryOps 中对现有记忆做增量维护：\n" +
+      '- add：新增一条事实（scope + fact），勿与现有重复；\n' +
+      '- replace：line=现有行号，oldText=该行精确原文，newText=替换后全文（仅内容行）；\n' +
+      "（当前为自动模式，禁止使用 delete，避免误删记忆；replace 必须带 oldText 精确匹配，匹配失败将被拒绝。）";
+
+  return (
+    "你是会话记忆提炼助手。根据下面这段【新产生的】对话（含工具调用与结果），提炼两样东西：\n" +
+    "1) summary：一段简洁中文摘要——这段对话做了什么、关键结果（路径/命令/数字）。\n" +
+    "2) durable：值得跨 session 长期记住的事实列表（最多 3 条），每条带 scope：\n" +
+    '   - "project" = 当前项目的约定/决策/技术事实\n' +
+    '   - "user" = 跨项目的个人偏好/习惯\n' +
+    "   闲聊、一次性操作、显而易见的内容、纯错误现象（错误已有独立记录）不要提炼；没有就留空数组。\n" +
+    "【输出风格硬约束】\n" +
+    "1) summary 必须是**客观、第三人称、陈述性**的中文摘要，描述「对话完成了什么 / 得出了什么结论」；\n" +
+    "   **严禁**包含：提问、提议、请示、寒暄、自我指涉（如「我可以帮你…」「需要的话…」「要不要…」）、\n" +
+    "   内心独白（如「But wait」「I should…」）或任何对话体 / 元叙述——你是在**写记忆**，不是在**对话**。\n" +
+    "2) durable 每条必须是**可独立成立的客观事实**；**严禁**把「助手说过的话 / 向用户提问 / 未确认的提议」本身当作事实记录。\n" +
+    "3) 若对话中仅含未决的提问或提议、无确定结论，summary 写「本次对话为未决讨论，暂无确定结论」，durable 留空，绝不可照抄对话体文本。\n" +
+    feedbackInstr +
+    "\n只输出 JSON，不要多余文字，格式：\n" +
+    '{"summary":"...","durable":[{"scope":"project","fact":"一句话"}],"memoryOps":[{"op":"add","scope":"project","fact":"..."},{"op":"replace","line":12,"oldText":"...","newText":"..."},{"op":"delete","line":7,"oldText":"..."}]}\n' +
+    "（没有需要维护的现有记忆时，memoryOps 留空数组 []。）"
+  );
+}
 
 // v1.2.0 项目记忆蒸馏 prompt（固化自 upgrade plan/v1.2.0/记忆蒸馏Prompt.md，供按钮「蒸馏项目记忆」稳定调用）。
 // 用法：system = 本 prompt，user = 项目 MEMORY.md 全文，输出 = 精炼后的项目记忆（直接覆盖写回）。

package/lib/common/records.mjs

@@ -75,6 +75,85 @@ export async function removeLineByMatch(file, match) {
   return { removed, ok: true, reason: "done", lines: removedLines };
 }
 
+// 全文逐行编号读取（v1.4.0 特性3：回喂存量记忆）。返回 { lines:[{n,raw,structural}], text }。
+// 行号 n 与文件实际行一一对应（1 起），供 LLM 通过 line 引用；text 为每行 `n|raw` 拼接，直接喂模型。
+// 不截断、无字符预算（用户明确要求全量回喂，避免截断导致记忆错误）。
+export function readNumberedMemory(file) {
+  let cur = "";
+  try {
+    cur = readFileSync(file, "utf8");
+  } catch {
+    return { lines: [], text: "" };
+  }
+  if (!cur) return { lines: [], text: "" };
+  const lines = cur.split("\n").map((raw, i) => {
+    const t = raw.trim();
+    return { n: i + 1, raw, structural: isStructural(t) };
+  });
+  const text = lines.map((l) => `${l.n}|${l.raw}`).join("\n");
+  return { lines, text };
+}
+
+// 基于编号现有记忆的增量维护操作（v1.4.0 特性3）。op 之一：
+//   - add：追加一行（text/newText，去重）；scope 由 caller 决定目标文件。
+//   - replace：替换第 line 行（写前重读 + normLine(oldText) 精确匹配校验，防 stale 行号误改）。
+//   - delete：删除第 line 行（结构行 / 未匹配 oldText 均拒绝）。
+// 写前重读（re-read before write）保证基于最新文件内容，避免并发/重试导致的 stale 行号错位。
+// 返回 { ok, reason, changed, line?, removed?, actual? }
+export async function applyMemoryOp(file, op) {
+  const o = op || {};
+  await mkdir(dirname(file), { recursive: true });
+  let cur = "";
+  try {
+    cur = readFileSync(file, "utf8");
+  } catch {
+    /* 文件尚不存在 */
+  }
+  const lines = cur.split("\n");
+  const normRaw = (s) => normLine((s || "").trim());
+
+  if (o.op === "add") {
+    const text = (o.text ?? o.newText ?? "").trim();
+    if (!text) return { ok: false, reason: "empty-add" };
+    if (cur && normRaw(cur).includes(normRaw(text))) return { ok: true, reason: "dup", changed: false };
+    const base = cur && !cur.endsWith("\n") ? cur + "\n" : cur;
+    await writeFile(file, `${base}${text}\n`, "utf8");
+    return { ok: true, reason: "added", changed: true };
+  }
+
+  if (o.op !== "replace" && o.op !== "delete") {
+    return { ok: false, reason: "unknown-op", op: o.op };
+  }
+
+  const n = o.line;
+  if (!Number.isInteger(n) || n < 1 || n > lines.length) {
+    return { ok: false, reason: "bad-line", line: n, totalLines: lines.length };
+  }
+  const idx = n - 1;
+  const rawLine = lines[idx];
+  const trimmed = rawLine.trim();
+  if (isStructural(trimmed)) {
+    return { ok: false, reason: "structural-protected", line: n };
+  }
+  // 写前重读后精确匹配：确保操作基于最新内容（防止 stale 行号导致误改/误删）。
+  const oldNorm = normRaw(o.oldText);
+  if (oldNorm && normRaw(rawLine) !== oldNorm) {
+    return { ok: false, reason: "conflict", line: n, expected: o.oldText, actual: trimmed };
+  }
+
+  if (o.op === "delete") {
+    const newLines = lines.slice(0, idx).concat(lines.slice(idx + 1));
+    await writeFile(file, newLines.join("\n"), "utf8");
+    return { ok: true, reason: "deleted", changed: true, line: n, removed: trimmed };
+  }
+  // replace
+  const newText = (o.newText ?? "").trim();
+  if (!newText) return { ok: false, reason: "empty-replace" };
+  lines[idx] = newText;
+  await writeFile(file, lines.join("\n"), "utf8");
+  return { ok: true, reason: "replaced", changed: true, line: n };
+}
+
 // 读取目录下最近的非今日每日日志日期（最多 limit 份，降序）。供删除范围圈定。
 export async function recentLogDates(dir, limit = 3) {
   let files = [];

package/lib/common/retry.mjs

@@ -0,0 +1,138 @@
+// memory-palace 蒸馏 LLM 调用失败重试（v1.4.0 特性2）。
+// 纯函数 + 通用重试驱动，与具体 distill 逻辑解耦，可被 test-load.mjs 直接单测。
+//
+// 设计要点（已与用户确认）：
+// - 错误分三类：retryable（5xx/网络/超时/中断，可重试）、limited（429/529 限流，可重试但分类不同）、
+//   fatal（401/403/404 鉴权/模型不存在/永久客户端错误，不重试）。
+// - 退避：指数退避 delay = min(BASE_DELAY_MS * FACTOR^attempt, MAX_DELAY_MS) + 抖动（≤15%）。
+// - 上限：通用 MAX_RETRIES=3；500 类服务端错误单独限到 HTTP500_MAX_RETRIES=1（500 多为主服务挂，
+//   重试意义不大且拖慢降级）。
+// - 每次尝试【独立超时】：makeAttempt 内部每次新开 AbortSignal.timeout(timeoutMs)，避免单次超时耗尽累计预算。
+export const RETRY_CONSTANTS = {
+  BASE_DELAY_MS: 2000,
+  FACTOR: 2,
+  MAX_RETRIES: 3,
+  MAX_DELAY_MS: 32000,
+  HTTP500_MAX_RETRIES: 1,
+};
+
+// 把一个可能携带状态码的 error / finish.failure 归一为分类结果。
+// 入参 err 可能是：stream 抛出的 Error、ctx.llm.stream 同步抛出的错误、或 finish.failure 对象。
+export function classifyFailure(err) {
+  const e = err && typeof err === "object" ? err : {};
+  const status =
+    e.status ??
+    e.statusCode ??
+    e.code ??
+    e.response?.status ??
+    (typeof e.status === "number" ? e.status : undefined);
+  const code = e.code || e.name;
+  const message = String(e.message || e.statusText || "")
+    .concat(" ", String(e.response?.statusText || ""))
+    .trim();
+
+  // fatal：鉴权 / 模型不存在 / 永久客户端错误 —— 重试无意义。
+  if (status === 401 || status === 403) return { kind: "fatal", status, message };
+  if (status === 404) return { kind: "fatal", status, message };
+  if (status === 400) return { kind: "fatal", status, message };
+
+  // limited：限流 / 过载 —— 可重试，但 caller 可按 limited 走更激进退避（此处同用指数退避即可）。
+  if (status === 429 || status === 529) return { kind: "limited", status, message };
+
+  // retryable：5xx 服务端错误（含 500，单独限重试次数见 runWithRetry）。
+  if (typeof status === "number" && status >= 500 && status < 600) {
+    return { kind: "retryable", status, message };
+  }
+
+  // 网络类错误（连接重置/超时/连接拒绝）——DNS 解析失败(ENOTFOUND) 不重试（见升级计划：通常需人工干预）。
+  if (
+    code === "ECONNRESET" ||
+    code === "ETIMEDOUT" ||
+    code === "ECONNREFUSED" ||
+    code === "ENETUNREACH"
+  ) {
+    return { kind: "retryable", status, message };
+  }
+
+  // 超时 / 中断：AbortSignal 触发、显式 aborted/timeout 字样。
+  if (
+    e.name === "AbortError" ||
+    code === "ABORT_ERR" ||
+    /aborted|timeout|timed out|deadline/i.test(message)
+  ) {
+    return { kind: "retryable", status, message };
+  }
+
+  // 兜底：未知错误不盲目重试（避免死循环），按 fatal 处理。
+  return { kind: "fatal", status, message };
+}
+
+// 指数退避 + 抖动（≤15%）。attempt 从 0 起算。
+export function backoffDelayMs(attempt) {
+  const { BASE_DELAY_MS, FACTOR, MAX_DELAY_MS } = RETRY_CONSTANTS;
+  const n = Math.max(0, attempt | 0);
+  const base = Math.min(BASE_DELAY_MS * Math.pow(FACTOR, n), MAX_DELAY_MS);
+  const jitter = Math.random() * (base * 0.15);
+  return Math.round(base + jitter);
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// 重试失败后的结构化错误（caller 据此降级，不向上抛裸 Error）。
+export class LlmRetryExhausted extends Error {
+  constructor(cls, attempts) {
+    super(`llm call exhausted after ${attempts} attempt(s): ${cls.kind} ${cls.status || ""} ${cls.message}`);
+    this.name = "LlmRetryExhausted";
+    this.cls = cls;
+    this.attempts = attempts;
+  }
+}
+
+/**
+ * 通用重试驱动。
+ * @param {() => Promise<{ finish?: { kind?: string, failure?: any }, text?: string }>} makeAttempt
+ *   单次尝试：内部自行创建独立 AbortSignal 并处理流；返回 { finish, text }。
+ *   成功 → finish.kind 为 undefined/'done'/'max-tokens'；失败 → finish.kind 为 'error'/'aborted'（含 failure）
+ *   或抛异常（网络/超时）。
+ * @param {{ maxRetries?: number, classify?: (e:any)=>any, onAttempt?: (info:any)=>void }} opts
+ * @returns {Promise<{ finish?: any, text?: string, attempts: number }>}
+ */
+export async function runWithRetry(makeAttempt, opts = {}) {
+  const { maxRetries = RETRY_CONSTANTS.MAX_RETRIES, onAttempt } = opts;
+  const classify = opts.classify || classifyFailure;
+  let lastCls = null;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (onAttempt) onAttempt({ attempt, maxRetries });
+    try {
+      const res = await makeAttempt(attempt);
+      const kind = res?.finish?.kind;
+      if (kind === "error" || kind === "aborted") {
+        const cls = classify(res.finish?.failure || {});
+        lastCls = cls;
+        // 500 类单独限重试次数；其余按 maxRetries。
+        const cap = cls.status === 500 ? RETRY_CONSTANTS.HTTP500_MAX_RETRIES : maxRetries;
+        if ((cls.kind === "retryable" || cls.kind === "limited") && attempt < cap) {
+          await sleep(backoffDelayMs(attempt));
+          continue;
+        }
+        throw new LlmRetryExhausted(cls, attempt + 1);
+      }
+      // 成功 / max-tokens：直接返回，文本解析交给 caller。
+      return { ...res, attempts: attempt + 1 };
+    } catch (err) {
+      const cls = classify(err);
+      lastCls = cls;
+      const cap = cls.status === 500 ? RETRY_CONSTANTS.HTTP500_MAX_RETRIES : maxRetries;
+      if ((cls.kind === "retryable" || cls.kind === "limited") && attempt < cap) {
+        await sleep(backoffDelayMs(attempt));
+        continue;
+      }
+      throw new LlmRetryExhausted(cls, attempt + 1);
+    }
+  }
+  // 理论不可达（循环内必然返回或抛出），兜底。
+  throw new LlmRetryExhausted(lastCls || { kind: "fatal", message: "unknown" }, maxRetries + 1);
+}

package/lib/distill.mjs

@@ -5,7 +5,8 @@ import { join, dirname } from "node:path";
 import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SUMMARY_PROMPT, DISTILL_PROMPT } from "./common/prompts.mjs";
 import { expandHome, readMdSync, toHomeShort, nowStamp } from "./common/text.mjs";
-import { appendLineDedup } from "./common/records.mjs";
+import { appendLineDedup, readNumberedMemory, applyMemoryOp } from "./common/records.mjs";
+import { runWithRetry, RETRY_CONSTANTS } from "./common/retry.mjs";
 
 /**
  * @param {{ ctx: object, getConfig: () => object, paths: object, records: object, state: object }} deps
@@ -13,42 +14,102 @@ import { appendLineDedup } from "./common/records.mjs";
 export function createDistill({ ctx, getConfig, paths, records, state }) {
   const cfg = () => getConfig();
 
+  // 调试日志（v1.3.0）：dbgFail=失败/跳过留痕（无条件输出，不受开关控制，保证排障可观测）；
+  // dbg=受 distillDebugLog 开关控制的详单（模型解析/请求参数/流进度计数/错误详情）。
+  // 隐私红线：只打计数/字符数/元数据/错误 message+stack 首行，绝不打印对话或 MEMORY.md 文本。
+  const dbgFail = (why, extra) => console.error(`[memory-palace] distill skip: ${why}`, extra ? JSON.stringify(extra) : "");
+  const dbg = (why, extra) => { if (!cfg().distillDebugLog) return; console.error(`[memory-palace][debug] ${why}`, extra !== undefined ? JSON.stringify(extra) : ""); };
+
   // 模型解析（v1.2.3 修复）：summaryModel 存的是注册表 models[].id 原样（client 下拉 value = m.id），
   // pi-ai getModel(provider, id) 按 model.id 全等匹配（pi-ai models.js: getModels(provider).find(m => m.id === id)），
   // 所以 model 参数必须【原样直传】summaryModel——绝不能 split 拆段。v1.2.2 之前拆段把
   // `nvidia/nemotron-3-ultra-550b-a55b` 变成裸 id `nemotron-3-ultra-550b-a55b`，全等匹配失败抛 UNKNOWN_MODEL。
-  // provider 取 summaryModel 首段（带前缀 id 的 route key，如 nvidia/nemotron-3-ultra-550b-a55b → nvidia）。
+  // provider 解析优先级：
+  //   1) 注册表反查（最稳）：遍历 ctx.llm.listProviders()，对每个 provider 调 listModels，
+  //      找 m.id === summaryModel 全等命中 → 返回 { provider: m.provider, model: m.id }。
+  //      带前缀 id（nvidia/nemotron-3-ultra-550b-a55b）与裸 id（mimo-v2.5 属 xiaomi）都能一次命中。
+  //   2) 首段兜底：listProviders 不可用（测试 mock 等）时，取 summaryModel 首段当 provider（openai/gpt-4o 格式）。
   // summaryModel 为空 → 会话 requestHeader config 兜底（复用当前会话 provider/model，原样直传）。
-  // 边界：裸 id 格式（如 GLM-4.7-Flash，无 provider 前缀）首段取不到正确 provider → 需要
-  // ctx.llm.listProviders() 反查注册表；当前配置（nvidia 带前缀 / zai 裸 id）用首段即可，裸 id 场景暂不处理。
-  function resolveModel(summaryModel, session) {
+  async function findModelInRegistry(modelId) {
+    try {
+      const providers = typeof ctx.llm?.listProviders === "function" ? ctx.llm.listProviders() : [];
+      for (const p of providers || []) {
+        try {
+          const models = await ctx.llm.listModels(p.id);
+          const m = (models || []).find((x) => x.id === modelId);
+          if (m) return { provider: m.provider, model: m.id };
+        } catch { /* 该 provider 无模型列表或不可用，跳过 */ }
+      }
+    } catch { /* listProviders 不可用，跳过反查 */ }
+    return null;
+  }
+  async function resolveModel(summaryModel, session) {
     const sm = (summaryModel || "").trim();
     if (sm) {
+      const hit = await findModelInRegistry(sm);
+      if (hit) { dbg("resolveModel: registry hit", { provider: hit.provider, model: hit.model }); return hit; }
       const provider = sm.split("/")[0].trim();
-      if (provider) return { provider, model: sm };
+      if (provider && sm.includes("/")) { dbg("resolveModel: prefix fallback", { provider, model: sm }); return { provider, model: sm }; }
     }
     const conf = session?.requestHeader?.()?.config;
-    if (conf && conf.provider && conf.model) return { provider: conf.provider, model: conf.model };
+    if (conf && conf.provider && conf.model) { dbg("resolveModel: session fallback", { provider: conf.provider, model: conf.model }); return { provider: conf.provider, model: conf.model }; }
+    dbgFail("resolveModel: no model resolved", { summaryModel: sm, hasHeader: !!(conf && conf.provider) });
     return null;
   }
 
   // 项目蒸馏乐观锁：按目标 MEMORY.md 绝对路径防并发重复蒸馏。
   const distillLocks = new Set();
 
+  // 单次 LLM 流尝试（供 runWithRetry 调用）：每次【新建独立 AbortSignal】，避免单次超时耗尽累计预算。
+  // 返回 { finish, text, chunks, deltaChars, gotFirstChunk, tFirstChunk, elapsed }；流中抛错（网络/超时/中断）原样向上抛，
+  // 由 runWithRetry 分类决定是否重试。finish.kind 为 error/aborted 时不抛（让 runWithRetry 据此决定重试/降级）。
+  async function streamOnce(params, timeoutMs) {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const t0 = Date.now();
+    let gotFirstChunk = false, tFirstChunk = null, chunks = 0, deltaChars = 0;
+    const res = ctx.llm.stream({ ...params, signal });
+    const asm = new BlockAssembler();
+    try {
+      for await (const ch of res) {
+        signal.throwIfAborted();
+        chunks++;
+        deltaChars += (ch.text?.length || 0);
+        if (!gotFirstChunk) { gotFirstChunk = true; tFirstChunk = Date.now() - t0; }
+        asm.push(ch);
+      }
+    } catch (e) {
+      // 流中抛错（网络/超时/中断）：原样抛出供 runWithRetry 分类重试或失败。
+      throw e;
+    }
+    const finish = asm.finish;
+    const text = asm
+      .blocks()
+      .filter((b) => b.type === "text")
+      .map((b) => b.text ?? "")
+      .join("")
+      .trim();
+    return { finish, text, chunks, deltaChars, gotFirstChunk, tFirstChunk, elapsed: Date.now() - t0 };
+  }
+
   // 蒸馏核心（v1.2.0 抽取）：对指定 session 的 [fromSeq, ∞) surface 事件做 LLM 智能摘要并写盘。
   // 自动智能模式（summarizeTurn，增量断点）与按钮「蒸馏会话」（全量 fromSeq=0）共用本核心。
   // 返回 { ok, summary, durableCount }；失败 { ok:false }（调用方各自决定降级策略）。
-  async function distillSessionCore(session, dirs, fromSeq) {
-    const dbg = (why, extra) => console.error(`[memory-palace] distill skip: ${why}`, extra ?? "");
+  async function distillSessionCore(session, dirs, fromSeq, opts) {
+    const allowDelete = !!(opts && opts.allowDelete);
+    // 回喂存量记忆（v1.4.0 特性3）：智能模式级能力——feedbackEnabled 开启即在【自动智能模式（turn/end）
+    // 与手动蒸馏按钮】两条链路都回喂项目级 + 用户级 MEMORY.md 全文（逐行编号、无截断）。
+    // delete 仍仅手动蒸馏（allowDelete=true）开放；自动模式 memoryOps 中的 delete 在 §5.5 被 !allowDelete 跳过。
+    // 回喂目标严格限定为 MEMORY.md；每日日志（.deepseek-harness/memory/YYYY-MM-DD.md）不读取、不改写、不删旧行。
+    const useFeedback = !!cfg().feedbackEnabled;
     if (!session) {
-      dbg("no session");
+      dbgFail("no session");
       return { ok: false };
     }
     const c = cfg();
-    // 1. 模型解析：summaryModel 原样直传（注册表 id）> 复用当前会话模型；皆缺 → 降级。
-    const resolved = resolveModel(c.summaryModel, session);
+    // 1. 模型解析：summaryModel 注册表反查（带前缀/裸 id 均可）> 复用当前会话模型；皆缺 → 降级。
+    const resolved = await resolveModel(c.summaryModel, session);
     if (!resolved) {
-      dbg("no model", { summaryModel: c.summaryModel, header: JSON.stringify(session.requestHeader?.()?.config) });
+      dbgFail("no model", { summaryModel: c.summaryModel, header: JSON.stringify(session.requestHeader?.()?.config) });
       return { ok: false };
     }
     const { provider, model } = resolved;
@@ -57,70 +118,103 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
     const newEvents = (session.events || []).filter(
       (e) => e.seq >= fromSeq && SURFACE.has(e.type),
     );
+    dbg("session core entry", { sessionId: session.id, fromSeq, eventsLen: newEvents.length });
     const hist = [];
     for (const e of newEvents) {
       const m = session.deriveEventMessage ? session.deriveEventMessage(e) : null;
       if (m) hist.push(m);
     }
     if (!hist.length) {
-      dbg("no events in range", { fromSeq, eventsLen: (session.events || []).length, newEvents: newEvents.length, hasDerive: !!session.deriveEventMessage });
+      dbgFail("no events in range", { fromSeq, eventsLen: (session.events || []).length, newEvents: newEvents.length, hasDerive: !!session.deriveEventMessage });
       return { ok: false };
     }
+    // 2.5 回喂存量记忆（v1.4.0 特性3）：仅当 useFeedback 时，读取项目级 + 用户级 MEMORY.md 全文
+    // （逐行编号、无截断）作为上下文前置消息，让 LLM 基于既有记忆做 add/replace/delete 增量维护。
+    let messages = hist;
+    const feedbackFiles = { project: null, user: null };
+    if (useFeedback) {
+      const sessCwd = session?.header?.cwd ?? undefined;
+      const projectMem = paths.memoryFileOf(dirs[0], sessCwd);
+      const userMem = expandHome(cfg().userMemoryPath);
+      // 始终记录目标文件路径（即使文件尚不存在），便于后续 add 操作创建文件。
+      feedbackFiles.project = projectMem;
+      feedbackFiles.user = userMem;
+      let fbText = "";
+      if (projectMem) {
+        const pm = readNumberedMemory(projectMem);
+        if (pm.text) fbText += "【项目级记忆（逐行编号，行号从 1 开始）】\n" + pm.text + "\n";
+      }
+      if (userMem) {
+        const um = readNumberedMemory(userMem);
+        if (um.text) fbText += "【用户级记忆（逐行编号，行号从 1 开始）】\n" + um.text + "\n";
+      }
+      if (fbText) {
+        messages = [
+          createUserMessage({
+            content: [{ type: "text", text: "以下是现有记忆（仅供你增量维护参考，不要当作本次对话内容）：\n" + fbText }],
+            source: { kind: "plugin", plugin: "memory-palace" },
+          }),
+          ...hist,
+        ];
+      }
+      dbg("session feedback", { hasProject: !!feedbackFiles.project, hasUser: !!feedbackFiles.user });
+    }
     // 3. LLM 调用：借鉴 dsh-sideband 的 summarizeJob（src/summarizer.ts）——
     //    a) SUMMARY_PROMPT 放 system 参数（GenerateOptions.system），指令不占 user 消息、模型更遵守；
     //    b) AbortSignal.timeout 超时保护（默认 60s，Config.summaryTimeoutMs 可调），流循环内 throwIfAborted，
     //       杜绝「LLM 慢/挂起 → for await 无限等待」导致的摘要静默失败；
     //    c) finish.kind 细化：error/aborted → 失败降级（探针带 failure.message）；max-tokens → 尝试用已有文本
-    //       （JSON.parse 失败自然回落全文/降级，不会产生坏数据）。
+    //       （解析失败时抽取 {...} JSON 块兜底，仍失败则 summary 置空、记极简占位，绝不把 LLM 自由文本当 summary 落盘）。
     const timeoutMs = c.summaryTimeoutMs || 60000;
-    const signal = AbortSignal.timeout(timeoutMs);
-    const res = ctx.llm.stream({
-      provider,
-      model,
-      system: SUMMARY_PROMPT,
-      messages: hist,
-      maxTokens: 800,
-      signal,
-    });
-    const asm = new BlockAssembler();
+    const t0 = Date.now();
+    dbg("session request", { provider, model, messages: messages.length, maxTokens: c.summaryMaxTokens, timeoutMs, maxRetries: RETRY_CONSTANTS.MAX_RETRIES });
+    let result;
     try {
-      for await (const ch of res) {
-        signal.throwIfAborted();
-        asm.push(ch);
-      }
+      result = await runWithRetry(
+        () => streamOnce({ provider, model, system: SUMMARY_PROMPT({ allowDelete }), messages, maxTokens: c.summaryMaxTokens }, timeoutMs),
+        {
+          maxRetries: RETRY_CONSTANTS.MAX_RETRIES,
+          onAttempt: ({ attempt, maxRetries }) => dbg("session attempt", { attempt, maxRetries }),
+        },
+      );
     } catch (e) {
-      dbg("stream aborted/timeout/error", { message: e?.message ?? "", aborted: signal.aborted, reason: signal.reason?.message ?? "" });
-      return { ok: false };
-    }
-    const finish = asm.finish;
-    if (finish && (finish.kind === "error" || finish.kind === "aborted")) {
-      dbg("llm finish", { kind: finish.kind, message: finish.failure?.message ?? "" });
+      const cls = e?.cls || { kind: "fatal", message: String(e?.message ?? e) };
+      dbgFail("session distill exhausted", { kind: cls.kind, status: cls.status ?? "", attempts: e?.attempts });
       return { ok: false };
     }
+    const { finish, text, chunks, deltaChars, tFirstChunk } = result;
+    dbg("session finish", { kind: finish?.kind, attempts: result.attempts });
+    dbg("session stream done", { chunks, deltaChars, firstChunkMs: tFirstChunk });
     if (finish && finish.kind === "max-tokens") {
-      dbg("llm finish max-tokens (attempting partial JSON)", {});
+      console.error("[memory-palace] distill warn: llm finish max-tokens (attempting partial JSON)", JSON.stringify({}));
     }
-    const text = asm
-      .blocks()
-      .filter((b) => b.type === "text")
-      .map((b) => b.text ?? "")
-      .join("")
-      .trim();
     if (!text) {
-      dbg("empty llm text");
+      dbgFail("empty llm text");
       return { ok: false };
     }
-    // 4. 解析 JSON：{summary, durable:[{scope,fact}]}；解析失败回退全文当 summary。
-    let summary = text;
+    // 4. 解析 JSON：{summary, durable:[{scope,fact}], memoryOps:[...]}。
+    // 防污染（v1.4.0 修复）：解析失败【绝不】退化成"全文当 summary"——否则对话原文 / 助手独白 / 向用户的请示
+    // 会被整段灌进每日日志。先尝试从自由文本抽取最后一个 {...} JSON 块再解析；仍失败则 summary 留空。
+    let summary = "";
     let durable = [];
-    try {
-      const parsed = JSON.parse(text);
-      if (parsed && typeof parsed === "object") {
-        if (typeof parsed.summary === "string") summary = parsed.summary;
-        if (Array.isArray(parsed.durable)) durable = parsed.durable;
-      }
-    } catch {
-      /* 非 JSON：全文当 summary */
+    let memoryOps = [];
+    let jsonOk = false;
+    const tryParseJson = (s) => {
+      try {
+        const o = JSON.parse(s);
+        return o && typeof o === "object" ? o : null;
+      } catch { return null; }
+    };
+    let parsed = tryParseJson(text);
+    if (!parsed) {
+      const block = text.match(/\{[\s\S]*\}/);
+      if (block) parsed = tryParseJson(block[0]);
+    }
+    if (parsed) {
+      jsonOk = true;
+      if (typeof parsed.summary === "string") summary = parsed.summary;
+      if (Array.isArray(parsed.durable)) durable = parsed.durable;
+      if (Array.isArray(parsed.memoryOps)) memoryOps = parsed.memoryOps;
     }
     // 5. 写盘：summary → 每日日志 [smart] 前缀；durable → MEMORY.md `- [smart] fact`（按 scope 分层，去重）。
     // v1.2.0 修复：手动蒸馏（按钮）时 dirs 按 session.header.cwd 解析，但 memoryFileOf 缺省用闭包
@@ -128,7 +222,11 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
     // 此处显式传会话 cwd，使 dsh 目录正确解析到同级 MEMORY.md（自动模式 activeCwd 即会话 cwd，行为不变）。
     const sessCwd = session?.header?.cwd ?? undefined;
     for (const dir of dirs) {
-      await records.appendDaily(dir, `\n[smart] ${summary}\n\n`);
+      // summary 为空（解析失败/未产出）→ 记极简占位，绝不把 LLM 自由文本当 summary 落盘（v1.4.0 防污染）。
+      const dailyLine = summary
+        ? `\n[smart] ${summary}\n\n`
+        : "\n[smart] 本段会话已蒸馏，但 LLM 未返回可解析的结构化摘要，已跳过原文落盘以避免污染记忆。\n\n";
+      await records.appendDaily(dir, dailyLine);
     }
     for (const d of durable) {
       if (!d || typeof d !== "object") continue;
@@ -143,6 +241,25 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
         }
       }
     }
+    // 5.5 应用 memoryOps（v1.4.0 特性3 增量维护）：useFeedback 时由 LLM 产出（自动/手动皆可能）。
+    // add → 追加到对应 MEMORY.md（file 由 scope 决定，可能即时创建）；replace/delete → applyMemoryOp
+    // （写前重读 + normLine 精确匹配 + 结构行保护，防止 stale 行号误改/误删）。
+    // 自动模式（allowDelete=false）prompt 同步禁用 delete，且下方 delete op 经 !allowDelete 跳过；
+    // 自动模式仅允许 add/replace 增量维护，delete 仅手动蒸馏按钮开放。
+    let opApplied = 0, opSkipped = 0;
+    for (const op of memoryOps) {
+      if (!op || typeof op !== "object") continue;
+      const scope = op.scope === "user" ? "user" : "project";
+      const file = scope === "user" ? feedbackFiles.user : feedbackFiles.project;
+      if (!file) { opSkipped++; continue; }
+      if (op.op === "delete" && !allowDelete) { opSkipped++; continue; }
+      const r = await applyMemoryOp(file, op).catch(() => ({ ok: false, reason: "exception" }));
+      if (r && r.ok && r.changed) opApplied++;
+      else if (r && !r.ok) dbgFail("memoryOp rejected", { op: op.op, reason: r.reason, line: r.line });
+    }
+    dbg("session memoryOps", { total: memoryOps.length, applied: opApplied, skipped: opSkipped });
+    dbg("session parsed", { jsonOk, summaryChars: summary.length, durableCount: durable.length });
+    dbg("session write done", { dirs: dirs.length, durableWritten: durable.length });
     return { ok: true, summary, durableCount: durable.length };
   }
 
@@ -170,52 +287,63 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
     const memFile = paths.memoryFileOf(primary, cwd);
     if (!memFile) return { ok: false, message: "无法解析项目 MEMORY.md 路径。" };
     const memShort = toHomeShort(memFile);
+    dbg("project entry", { cwd, memFile: toHomeShort(memFile) });
 
     const raw = readMdSync(memFile);
     if (!raw) return { ok: false, message: `项目记忆为空（${memShort}），无需蒸馏。` };
+    dbg("project loaded", { memFile: toHomeShort(memFile), rawChars: raw.length });
 
     if (distillLocks.has(memFile)) return { ok: false, message: "蒸馏正在进行中，请稍候再试。" };
     distillLocks.add(memFile);
     try {
-      // 模型解析：与 distillSessionCore 同序（summaryModel 原样直传 > 会话 requestHeader）。
-      const resolved = resolveModel(c.summaryModel, session);
+      const t0 = Date.now();
+      let provider = null, model = null;
+      // 模型解析：与 distillSessionCore 同序（summaryModel 注册表反查 > 会话 requestHeader）。
+      const resolved = await resolveModel(c.summaryModel, session);
       if (!resolved) {
         return { ok: false, message: "无法确定蒸馏模型（summaryModel 未配置且会话无模型信息）。" };
       }
-      const { provider, model } = resolved;
+      ({ provider, model } = resolved);
+      dbg("project request", { provider, model, inputChars: raw.length, maxTokens: c.projectMaxTokens, timeoutMs: c.summaryTimeoutMs || 60000 });
 
-      // LLM 蒸馏：system = 固化 DISTILL_PROMPT，user = MEMORY.md 全文。
+      // LLM 蒸馏：system = 固化 DISTILL_PROMPT，user = MEMORY.md 全文。带失败重试（runWithRetry）。
       const timeoutMs = c.summaryTimeoutMs || 60000;
-      const signal = AbortSignal.timeout(timeoutMs);
-      const res = ctx.llm.stream({
-        provider,
-        model,
-        system: DISTILL_PROMPT,
-        messages: [
-          createUserMessage({
-            content: [{ type: "text", text: raw }],
-            source: { kind: "plugin", plugin: "memory-palace" },
-          }),
-        ],
-        maxTokens: 4000,
-        signal,
-      });
-      const asm = new BlockAssembler();
-      for await (const ch of res) {
-        signal.throwIfAborted();
-        asm.push(ch);
+      let result;
+      try {
+        result = await runWithRetry(
+          () => streamOnce(
+            {
+              provider,
+              model,
+              system: DISTILL_PROMPT,
+              messages: [
+                createUserMessage({
+                  content: [{ type: "text", text: raw }],
+                  source: { kind: "plugin", plugin: "memory-palace" },
+                }),
+              ],
+              maxTokens: c.projectMaxTokens,
+            },
+            timeoutMs,
+          ),
+          {
+            maxRetries: RETRY_CONSTANTS.MAX_RETRIES,
+            onAttempt: ({ attempt, maxRetries }) => dbg("project attempt", { attempt, maxRetries }),
+          },
+        );
+      } catch (e) {
+        const cls = e?.cls || { kind: "fatal", message: String(e?.message ?? e) };
+        dbgFail("project distill exhausted", { kind: cls.kind, status: cls.status ?? "", attempts: e?.attempts });
+        const kindZh = cls.kind === "fatal" ? "失败" : "限流/超时";
+        return { ok: false, message: `蒸馏${kindZh}（重试 ${e?.attempts || 0} 次后仍失败）：${cls.message || ""}` };
       }
-      const finish = asm.finish;
-      if (finish && (finish.kind === "error" || finish.kind === "aborted")) {
-        return { ok: false, message: `蒸馏失败（LLM ${finish.kind}）：${finish.failure?.message ?? ""}` };
+      const { finish, text, chunks, deltaChars, gotFirstChunk, tFirstChunk } = result;
+      if (finish && finish.kind === "max-tokens") {
+        dbg("project finish", { kind: "max-tokens", attempts: result.attempts });
+      } else {
+        dbg("project finish", { kind: finish?.kind, attempts: result.attempts });
       }
-      const text = asm
-        .blocks()
-        .filter((b) => b.type === "text")
-        .map((b) => b.text ?? "")
-        .join("")
-        .trim();
-      if (!text) return { ok: false, message: "蒸馏结果为空，未覆盖任何文件。" };
+      if (!text) { dbgFail("project empty result", { chunks, deltaChars }); return { ok: false, message: "蒸馏结果为空，未覆盖任何文件。" }; }
 
       // 写 cover（与 MEMORY.md 同目录，同文件系统保证 rename 原子）。
       const coverFile = join(dirname(memFile), "memory-cover.md");
@@ -237,12 +365,16 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
         await rename(backup, memFile).catch(() => {});
         throw e;
       }
+      dbg("project write done", { coverChars: text.length, backup: toHomeShort(backup) });
       return {
         ok: true,
         message: `蒸馏成功：${memShort} 已更新（原 ${raw.length} 字符 → ${text.length} 字符），备份 ${toHomeShort(backup)}。`,
       };
     } catch (e) {
-      return { ok: false, message: `蒸馏失败：${e?.message || String(e)}` };
+      const elapsedS = Math.round((Date.now() - t0) / 1000);
+      dbgFail("project distill timeout/error", { elapsed: Date.now() - t0, message: e?.message ?? String(e), stack: (e?.stack || "").split("\n")[0] });
+      const msg = `蒸馏失败：模型「${model || "?"}」在 ${elapsedS}s 内未成功完成（写入/覆盖阶段异常：${e?.message ?? String(e)}）。`;
+      return { ok: false, message: msg };
     } finally {
       distillLocks.delete(memFile);
     }

package/lib/index.js

@@ -52,7 +52,13 @@ export const Config = Schema.object({
   // ---- v1.1.0：双记忆模式（插件模式=现状；智能模式=LLM 智能会话摘要），设置页切换，互斥，切换需重启 dsh ----
   memoryMode: Schema.union(["plugin", "smart"]).default("plugin").description("记忆模式：plugin=记忆公民指令+轮次轻量+错误捕获；smart=LLM 智能会话摘要（summary→每日日志 + durable→MEMORY.md，带 [smart] 标记）。切换需重启 dsh 生效。"),
   summaryModel: Schema.string().default("").description("智能模式的摘要模型，留空=复用当前会话 provider/model；也可填 provider/model（如 deepseek/deepseek-chat）固定廉价模型省 token。"),
-  summaryTimeoutMs: Schema.number().default(60000).description("智能模式单次摘要调用的超时（毫秒），超时视为失败并降级轻量条目；默认 60s。"),
+  summaryTimeoutMs: Schema.number().default(60000).description("蒸馏 LLM 调用的超时（毫秒），超时视为失败并降级；覆盖智能模式摘要与手动蒸馏两条链路；默认 60000（60s）。"),
+  distillDebugLog: Schema.boolean().default(false).description("调试开关：向 dsh 服务端 stderr 输出蒸馏 LLM 调用诊断日志（模型解析、请求参数、流进度计数、错误详情）。仅排障用，平时关闭；开启后也不打印任何对话内容或记忆文本。"),
+  // ---- v1.4.0：智能模式最大输出 Token 限制（特性1，默认保守，可由设置页放大以防摘要/durable 被截断） ----
+  summaryMaxTokens: Schema.number().default(2000).description("智能模式会话摘要 LLM 的最大输出 Token（summary + durable 合计上限）。默认 2000，过小会截断 durable 事实；可上调到 4000+。"),
+  projectMaxTokens: Schema.number().default(8000).description("手动「蒸馏项目记忆」LLM 的最大输出 Token（蒸馏后 MEMORY.md 长度上限）。默认 8000，过小会截断浓缩结果；可上调。"),
+  // ---- v1.4.0：蒸馏时回喂存量记忆（特性3，默认关；开启后自动智能模式 turn/end 与手动蒸馏按钮均回喂，delete 仅手动放开） ----
+  feedbackEnabled: Schema.boolean().default(false).description("蒸馏时把项目级 + 用户级 MEMORY.md 全文（逐行编号、无截断）回喂给 LLM，使其能基于既有记忆做 add/replace/delete 增量维护。默认关；开启后自动智能模式（turn/end）与手动蒸馏会话按钮均回喂存量记忆；delete 仍仅手动按钮开放，自动模式跳过（防误删）。"),
 });
 
 export const inject = ["systemPrompt", "tools", "llm", "webServer", "webRuntime"];
@@ -103,6 +109,7 @@ export function apply(ctx, config) {
     settleTimer: null,        // debounce 计时器
     lastSummarizedSeq: -1,    // 智能模式增量摘要断点（session 事件 seq）
     summarySessionId: null,
+    planModeActive: false,    // 计划模式：禁写记忆（硬编码默认，无开关；仅经 session/event 的 plan/mode 翻转；未装 dsh-plan-mode 永不触发=不拦截）
   };
   const TURN_BUFFER_MAX = 30;
   // v1.1.3：字符上限提升到 30k（长工具型 request 的工具结果动辄数千字符，6k 上限会触发
@@ -131,6 +138,11 @@ export function apply(ctx, config) {
       state.lastSummarizedSeq = session.firstLiveSeq;
     }
     const type = event?.type;
+    // 计划模式：禁写记忆（硬编码默认行为，无开关；不依赖 dsh-plan-mode 服务，未装则永不触发=安全降级=不拦截）
+    if (type === "plan/mode") {
+      state.planModeActive = !!(event?.data?.active);
+      return;
+    }
     if (type === "user/message" || type === "assistant/message" || type === "tool/result") {
       const text = extractText(event);
       if (text) {
@@ -204,13 +216,20 @@ export function apply(ctx, config) {
         : "你拥有持久化、人类可直接编辑的 Markdown 记忆文件（位于 ~/.deepseek-harness/MEMORY.md，以及各项目的 .deepseek-harness/MEMORY.md（长期记忆）与 .deepseek-harness/memory/（每日日志））。" +
           "写入记忆：项目级约定用 memory_note 工具，跨项目个人偏好用 memory_note_user 工具；读取全部记忆用 memory_read 工具（不要手动 glob/read 记忆文件）。用它保持跨 session 一致性；看不到的内容不要编造。" +
           antiMangle + proactive;
-      return blocks.length ? [intro, ...blocks].join("\n\n") : intro;
+      // 计划模式禁写提示（硬编码默认行为，无开关）：无论记忆模式都追加，让 agent 自觉不写（网关物理兜底仍生效）
+      const planNote = state.planModeActive
+        ? "\n\n[plan 模式] 当前处于 plan 模式，不要调用 memory_note / memory_note_user 写入记忆，也不要请求删除记忆（读取记忆用 memory_read，仍可用）。"
+        : "";
+      const introFull = intro + planNote;
+      return blocks.length ? [introFull, ...blocks].join("\n\n") : introFull;
     },
   });
 
   // ---------- 结算一个完整 request：基于累积缓冲做「错误捕获 + 轻量兜底记录（闸门）」，不调 LLM ----------
   // 主路径是 agent 按记忆公民指令主动调 memory_note；此处只兜底保证"实质轮次不丢"。
   async function _settle(capturedTurn, isError, errMsg) {
+    // 计划模式禁写（硬编码默认，无开关）：自动写路径全拦截（智能模式/轻量兜底/错误捕获同源跳过）
+    if (state.planModeActive) return;
     const cfg = source();
     if (!cfg.enabled) return;
     const dirs = paths.writeDirs();

package/lib/tools.mjs

@@ -360,8 +360,15 @@ export function registerTools({ ctx, getConfig, paths, records, state }) {
   // （即删除用户记忆时你看到的「沙箱授权弹窗」）——比两阶段的 AI 级 confirm:true 更可靠：
   // 即便模型误传 confirm:true，没有真人点击弹窗允许也绝不会真正删除。
   // 预览（confirm 省略或为 false）直接放行、不弹窗，由 execute 返回候选供 AI 转述、供用户选择删哪几条。
+  // 计划模式禁写（硬编码默认，无开关）：三个写工具统一 deny（连预览/确认都拦），仅禁写不禁读。
+  const WRITE_TOOLS = new Set(["memory_note", "memory_note_user", "memory_delete"]);
   ctx.on("tools/pre-execute", async (exec, next) => {
-    if (exec?.name !== "memory_delete") return next();
+    const name = exec?.name;
+    // plan 模式禁写：三个写工具一律 deny，连预览/确认都拦
+    if (state.planModeActive && WRITE_TOOLS.has(name)) {
+      return { kind: "deny", reason: "plan 模式下禁止写入记忆" };
+    }
+    if (name !== "memory_delete") return next();
     const a = (exec.arguments && typeof exec.arguments === "object") ? exec.arguments : {};
     const confirm = a.confirm === true;
     if (!confirm) return next(); // 预览阶段：只查不删，无需弹窗

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-palace",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "把 WorkBuddy 的文件式记忆系统移植进 DeepSeek Harness：用户级 + 工作区的人类可读 Markdown 记忆（~/.deepseek-harness/MEMORY.md 与 <cwd>/.deepseek-harness/memory/）。",
   "type": "module",
   "main": "lib/index.js",