dsh-memory-palace 1.3.0 → 1.4.1

package/README.md

@@ -1,5 +1,4 @@
 # 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 记忆**。
 
@@ -36,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` 同步读盘，把以下内容拼进系统提示词：
@@ -79,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.3.0
+# 锁定版本：dsh plugin --profile web add github:lovezi0/dsh-memory-palace#v1.4.1
 ```
 
 方式二：clone 后本地安装（开发 / 修改源码场景）
@@ -98,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.3.0
+dsh plugin --profile web add dsh-memory-palace@1.4.1
 
 # 或先手动用 npm 安装（显式指定镜像），再装入：
 npm install dsh-memory-palace --registry=https://registry.npmmirror.com/
@@ -112,49 +107,24 @@ 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.1**
+    - 🐛修复输出预算使用错位的问题
+    - 🐛增加调试模式日志级别 *默认info 仅输出元数据日志，debug 输出完整LLM text*
+- **1.4.0**
+    - 🔥智能模式增加最大输出Token限制
+    - 🔥智能模式增加失败重试机制
+    - 🔥智能模式会增加回馈存量记忆
+    - 🐛修复自动记录部分设置位置错误问题
 - **1.3.0**
     - 🔥新增计划模式禁止写入记忆
     - 💪设置-记忆控件样式优化 *使用dsh原生样式*

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: "记忆模式",
@@ -64,10 +64,16 @@ window.__ModuleLoader__.load({
       notifyProjectDone: "项目记忆蒸馏完成",
       notifyFail: "记忆蒸馏失败",
       distillDebugLogLabel: "蒸馏调试日志",
-      distillDebugLogHint: "开启后向 dsh 服务端控制台（stderr）输出蒸馏 LLM 调用诊断，仅排障用，平时关闭。",
+      distillDebugLogHint: "开启后向 dsh 服务端控制台（stderr）输出蒸馏 LLM 调用诊断。info 级别仅输出元数据（不含文本）；配合 distillLogLevel=debug 会额外打印 LLM 原始响应（分隔符包裹），仅限受信本地排障。",
       dev: "开发",
       distillTimeoutLabel: "蒸馏超时（秒）",
-      distillTimeoutHint: "单次蒸馏 LLM 调用的超时上限（秒）；超时视为失败并降级。覆盖智能模式摘要与手动蒸馏，默认 60 秒。"
+      distillTimeoutHint: "单次蒸馏 LLM 调用的超时上限（秒）；超时视为失败并降级。覆盖智能模式摘要与手动蒸馏，默认 60 秒。",
+      summaryMaxTokensLabel: "会话摘要最大 Token（智能模式）",
+      summaryMaxTokensHint: "智能模式会话摘要 LLM 的【最终输出软预算（prompt 约束，思考不受限；实际硬上限由模型自身 maxTokens 决定）】。默认 2000，可调大以容纳更多 durable 事实。",
+      projectMaxTokensLabel: "项目蒸馏输出软预算",
+      projectMaxTokensHint: "手动「蒸馏项目记忆」LLM 的【最终输出软预算（prompt 约束，思考不受限；实际硬上限由模型自身 maxTokens 决定）】。默认 8000。",
+      feedbackEnabledLabel: "蒸馏回喂存量记忆",
+      feedbackEnabledHint: "开启后，自动智能模式（turn/end）与手动蒸馏会话按钮均会把项目级 + 用户级 MEMORY.md 全文（逐行编号、无截断）回喂 LLM，使其能基于既有记忆做 add/replace/delete 增量维护。delete 仅手动蒸馏按钮开放，自动模式跳过（防误删）。默认关。"
     };
 
     const en = {
@@ -92,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",
@@ -124,15 +130,21 @@ window.__ModuleLoader__.load({
       notifyProjectDone: "Project memory distilled",
       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.",
+      distillDebugLogHint: "When on, prints distill LLM call diagnostics to the dsh server console (stderr). info level prints metadata only (no text); with distillLogLevel=debug it additionally prints the raw LLM response (wrapped in delimiters), for trusted local troubleshooting only.",
       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."
+      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: "Smart-mode session summary LLM final output soft budget (prompt constraint, thinking not limited; the actual hard cap is the model's own maxTokens). Default 2000; raise to fit more durable facts.",
+      projectMaxTokensLabel: "Project distill output soft budget",
+      projectMaxTokensHint: "Manual 'distill project memory' LLM final output soft budget (prompt constraint, thinking not limited; actual hard cap is the model's own maxTokens). Default 8000.",
+      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", "summaryTimeoutMs"]);
-    const FIELD_BOOL = new Set(["bridgeBuddyMemory", "summarize", "autoCaptureErrors", "distillDebugLog"]);
+    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 : {};
@@ -149,7 +161,10 @@ window.__ModuleLoader__.load({
         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"
       };
     }
 
@@ -311,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)
           ]),
@@ -361,10 +378,14 @@ window.__ModuleLoader__.load({
         paddingRight: "32px"
       };
       const checkboxStyle = {
-        width: "15px",
-        height: "15px",
+        width: "18px",
+        height: "18px",
         margin: "0",
-        accentColor: "var(--dsw-alias-brand-primary, #4b5bff)"
+        accentColor: "var(--dsw-alias-brand-primary, #4b5bff)",
+        // 锁死：不被 flex 长描述挤压缩（flex-shrink 默认 1 会在布局阶段无视 width/!important）。
+        flexShrink: 0,
+        flexGrow: 0,
+        alignSelf: "center"
       };
       const toggleStyle = {
         display: "flex",
@@ -464,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")),
@@ -479,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"))
             ]),
@@ -500,6 +523,8 @@ 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",
@@ -511,20 +536,24 @@ window.__ModuleLoader__.load({
               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,
-                  style: selectStyle,
-                  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")
               ])
         ]),

package/lib/common/prompts.mjs

@@ -4,22 +4,49 @@
 // 场景关键词（增强原方案 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, outputBudget } = {}) {
+  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 +
+    (outputBudget != null ? "\n【输出长度约束】你的最终 JSON（summary + durable + memoryOps 合计）请控制在约 " + outputBudget + " token（≈" + Math.round(outputBudget * 1.8) + " 字）以内。思考/推理过程不受此限、可充分判断（含「该不该记」「是否一次性操作」「与旧记忆是否冲突需 update/delete」），但**最终成稿必须精炼、不超预算**；严禁为凑结构而填充无用内容。\n" : "") +
+    "\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 全文，输出 = 精炼后的项目记忆（直接覆盖写回）。
-export const DISTILL_PROMPT =
-  "你是一名「项目记忆蒸馏器」。我会给你一份项目的原始材料（可能是记忆文件、会话记录、零散笔记，或多份材料的拼合）。你的任务：把它提炼成一段精炼的项目记忆。\n" +
+export function DISTILL_PROMPT({ outputBudget } = {}) {
+  return (
+    "你是一名「项目记忆蒸馏器」。我会给你一份项目的原始材料（可能是记忆文件、会话记录、零散笔记，或多份材料的拼合）。你的任务：把它提炼成一段精炼的项目记忆。\n" +
   "\n" +
   "【提炼总原则】\n" +
   "只保留「以后还会用到」的信息，删掉「一次性过程」。\n" +
@@ -68,4 +95,7 @@ export const DISTILL_PROMPT =
   "5. 每个坑是否「现象 → 根因 → 解法」三要素齐全？\n" +
   "6. 是否只输出了骨架要求的章节，没有额外发挥？\n" +
   "\n" +
-  "现在开始处理我提供的材料。";
+  (outputBudget != null ? "【输出长度约束】你提炼后的项目记忆请控制在约 " + outputBudget + " token（≈" + Math.round(outputBudget * 1.8) + " 字）以内。思考不受限，但成稿须精炼、不超预算；只保留「以后还会用到」的信息，删掉「一次性过程」。\n" : "") +
+  "现在开始处理我提供的材料。"
+  );
+}

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
@@ -59,10 +60,47 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
   // 项目蒸馏乐观锁：按目标 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) {
+  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) {
       dbgFail("no session");
       return { ok: false };
@@ -90,71 +128,102 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
       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 t0 = Date.now();
-    let gotFirstChunk = false, tFirstChunk = null, chunks = 0, deltaChars = 0;
-    dbg("session request", { provider, model, messages: hist.length, maxTokens: 800, timeoutMs });
-    const res = ctx.llm.stream({
-      provider,
-      model,
-      system: SUMMARY_PROMPT,
-      messages: hist,
-      maxTokens: 800,
-      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; dbg("session first chunk", { ms: tFirstChunk }); }
-          asm.push(ch);
-        }
+    dbg("session request", { provider, model, messages: messages.length, maxTokens: "(model native cap)", timeoutMs, maxRetries: RETRY_CONSTANTS.MAX_RETRIES });
+    let result;
+    try {
+      result = await runWithRetry(
+        () => streamOnce({ provider, model, system: SUMMARY_PROMPT({ allowDelete, outputBudget: c.summaryMaxTokens }), messages }, timeoutMs),
+        {
+          maxRetries: RETRY_CONSTANTS.MAX_RETRIES,
+          onAttempt: ({ attempt, maxRetries }) => dbg("session attempt", { attempt, maxRetries }),
+        },
+      );
     } catch (e) {
-      dbgFail("stream aborted/timeout/error", { message: e?.message ?? "", aborted: signal.aborted, reason: signal.reason?.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 = asm.finish;
-    dbg("session finish", { kind: finish?.kind });
+    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 === "error" || finish.kind === "aborted")) {
-      dbgFail("llm finish", { kind: finish.kind, message: finish.failure?.message ?? "" });
-      return { ok: false };
+    // 本地调试（受 distillDebugLog + distillLogLevel==="debug" 双门控）：把 LLM 原始响应 text 原样打到 stderr，
+    // 并用分隔符整段包裹，便于从 stderr 一眼框住起止、不与其它 dbg 行混淆。
+    if (cfg().distillDebugLog && cfg().distillLogLevel === "debug") {
+      console.error("[memory-palace][debug] session llm raw text begin >>>");
+      console.error("--------------------------->");
+      console.error(text);
+      console.error("<----------------------------");
+      console.error("[memory-palace][debug] session llm raw text end <<<");
     }
     if (finish && finish.kind === "max-tokens") {
       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) {
       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 = [];
+    let memoryOps = [];
     let jsonOk = false;
-    try {
-      const parsed = JSON.parse(text);
-      if (parsed && typeof parsed === "object") {
-        jsonOk = true;
-        if (typeof parsed.summary === "string") summary = parsed.summary;
-        if (Array.isArray(parsed.durable)) durable = parsed.durable;
-      }
-    } catch {
-      /* 非 JSON：全文当 summary */
+    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 缺省用闭包
@@ -162,7 +231,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;
@@ -177,6 +250,23 @@ 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 };
@@ -216,7 +306,6 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
     distillLocks.add(memFile);
     try {
       const t0 = Date.now();
-      let gotFirstChunk = false, tFirstChunk = null, chunks = 0, deltaChars = 0;
       let provider = null, model = null;
       // 模型解析：与 distillSessionCore 同序（summaryModel 注册表反查 > 会话 requestHeader）。
       const resolved = await resolveModel(c.summaryModel, session);
@@ -224,45 +313,52 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
         return { ok: false, message: "无法确定蒸馏模型（summaryModel 未配置且会话无模型信息）。" };
       }
       ({ provider, model } = resolved);
-      dbg("project request", { provider, model, inputChars: raw.length, maxTokens: 4000, timeoutMs: c.summaryTimeoutMs || 60000 });
+      dbg("project request", { provider, model, inputChars: raw.length, maxTokens: "(model native cap)", 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();
-        chunks++;
-        deltaChars += (ch.text?.length || 0);
-        if (!gotFirstChunk) { gotFirstChunk = true; tFirstChunk = Date.now() - t0; dbg("project first chunk", { ms: tFirstChunk }); }
-        asm.push(ch);
+      let result;
+      try {
+        result = await runWithRetry(
+          () => streamOnce(
+            {
+              provider,
+              model,
+              system: DISTILL_PROMPT({ outputBudget: c.projectMaxTokens }),
+              messages: [
+                createUserMessage({
+                  content: [{ type: "text", text: raw }],
+                  source: { kind: "plugin", plugin: "memory-palace" },
+                }),
+              ],
+            },
+            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")) {
-        const kindZh = finish.kind === "aborted" ? "被中断" : "出错";
-        dbgFail("project finish failed", { kind: finish.kind, message: finish.failure?.message ?? "" });
-        return { ok: false, message: `蒸馏${kindZh}（LLM ${finish.kind}）：${finish.failure?.message ?? ""}` };
+      const { finish, text, chunks, deltaChars, gotFirstChunk, tFirstChunk } = result;
+      // 本地调试（受 distillDebugLog + distillLogLevel==="debug" 双门控，与会话蒸馏路径一致）：分隔符包裹整段原始响应。
+      if (cfg().distillDebugLog && cfg().distillLogLevel === "debug") {
+        console.error("[memory-palace][debug] project llm raw text begin >>>");
+        console.error("--------------------------->");
+        console.error(text);
+        console.error("<----------------------------");
+        console.error("[memory-palace][debug] project llm raw text end <<<");
+      }
+      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 });
       }
-      dbg("project finish", { kind: finish?.kind });
-      const text = asm
-        .blocks()
-        .filter((b) => b.type === "text")
-        .map((b) => b.text ?? "")
-        .join("")
-        .trim();
       if (!text) { dbgFail("project empty result", { chunks, deltaChars }); return { ok: false, message: "蒸馏结果为空，未覆盖任何文件。" }; }
 
       // 写 cover（与 MEMORY.md 同目录，同文件系统保证 rename 原子）。
@@ -292,13 +388,8 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
       };
     } catch (e) {
       const elapsedS = Math.round((Date.now() - t0) / 1000);
-      dbgFail("project distill timeout/error", { elapsed: Date.now() - t0, chunks, deltaChars, gotFirstChunk, message: e?.message ?? String(e), stack: (e?.stack || "").split("\n")[0] });
-      let msg;
-      if (gotFirstChunk) {
-        msg = `蒸馏中途超时：模型「${model}」已在 ${tFirstChunk}ms 返回首个字符、累计 ${deltaChars} 字符，但在 ${elapsedS}s 内未结束（疑似输出中断或已被服务端截断）。`;
-      } else {
-        msg = `蒸馏超时：模型「${model}」在 ${elapsedS}s 内未返回任何内容，疑似未响应或限流。`;
-      }
+      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

@@ -53,7 +53,14 @@ export const Config = Schema.object({
   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("蒸馏 LLM 调用的超时（毫秒），超时视为失败并降级；覆盖智能模式摘要与手动蒸馏两条链路；默认 60000（60s）。"),
-  distillDebugLog: Schema.boolean().default(false).description("调试开关：向 dsh 服务端 stderr 输出蒸馏 LLM 调用诊断日志（模型解析、请求参数、流进度计数、错误详情）。仅排障用，平时关闭；开启后也不打印任何对话内容或记忆文本。"),
+  distillDebugLog: Schema.boolean().default(false).description("调试开关：向 dsh 服务端 stderr 输出蒸馏 LLM 调用诊断。distillLogLevel=info 时仅输出元数据（模型解析/请求参数/流进度/错误详情，不含文本）；distillLogLevel=debug 会额外打印 LLM 原始响应文本（分隔符包裹），仅限受信本地排障开启。"),
+  // ---- v1.4.1：蒸馏 stderr 日志级别（平铺键，不进 UI；默认 info；distillDebugLog=true 时生效） ----
+  distillLogLevel: Schema.string().default("info").description("蒸馏 stderr 日志级别：info=仅元数据诊断（默认，不打印 LLM 原始响应）；debug=额外打印 LLM 原始响应文本（分隔符包裹），仅限受信本地排障开启。无需 UI 配置，经 profile/settings.yaml 设置 distillLogLevel 键。"),
+  // ---- v1.4.0：智能模式最终输出软预算（v1.4.1 起语义变更：prompt 软约束，思考不受限；实际硬上限由模型自身 maxTokens 决定） ----
+  summaryMaxTokens: Schema.number().default(2000).description("智能模式会话摘要 LLM 的【最终输出软预算（prompt 约束，思考不受限）】。默认 2000。实际硬上限由模型自身 maxTokens 决定；可调大以容纳更多 durable 事实。"),
+  projectMaxTokens: Schema.number().default(8000).description("手动「蒸馏项目记忆」LLM 的【最终输出软预算（prompt 约束，思考不受限）】。默认 8000。实际硬上限由模型自身 maxTokens 决定。"),
+  // ---- 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"];

package/package.json

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