dsh-memory-palace 1.2.2 → 1.3.0

package/README.md

@@ -1,10 +1,9 @@
-# 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)
 
 ## 特性
 
@@ -80,7 +79,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.3.0
 ```
 
 方式二：clone 后本地安装（开发 / 修改源码场景）
@@ -99,7 +98,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.3.0
 
 # 或先手动用 npm 安装（显式指定镜像），再装入：
 npm install dsh-memory-palace --registry=https://registry.npmmirror.com/
@@ -156,6 +155,12 @@ dsh plugin --profile web remove dsh-memory-palace
 
 ## 版本历史
 
+- **1.3.0**
+    - 🔥新增计划模式禁止写入记忆
+    - 💪设置-记忆控件样式优化 *使用dsh原生样式*
+    - 💪清理重复patch信息
+    - 🔥增加调试模式 *默认关闭，仅用于智能模式蒸馏失败输出调试信息*
+- **1.2.3**
 - **1.2.2**
     - 🐛修复智能模式自定义摘要模型不生效的问题
 - **1.2.1**
@@ -179,10 +184,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/client.js

@@ -62,7 +62,12 @@ window.__ModuleLoader__.load({
       distilling: "蒸馏中…",
       notifySessionDone: "会话记忆蒸馏完成",
       notifyProjectDone: "项目记忆蒸馏完成",
-      notifyFail: "记忆蒸馏失败"
+      notifyFail: "记忆蒸馏失败",
+      distillDebugLogLabel: "蒸馏调试日志",
+      distillDebugLogHint: "开启后向 dsh 服务端控制台（stderr）输出蒸馏 LLM 调用诊断，仅排障用，平时关闭。",
+      dev: "开发",
+      distillTimeoutLabel: "蒸馏超时（秒）",
+      distillTimeoutHint: "单次蒸馏 LLM 调用的超时上限（秒）；超时视为失败并降级。覆盖智能模式摘要与手动蒸馏，默认 60 秒。"
     };
 
     const en = {
@@ -117,12 +122,17 @@ 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."
     };
 
 
-    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"]);
+    const FIELD_BOOL = new Set(["bridgeBuddyMemory", "summarize", "autoCaptureErrors", "distillDebugLog"]);
 
     function projectDraft(snap) {
       const v = snap && snap.value ? snap.value : {};
@@ -136,6 +146,8 @@ 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 || ""
       };
@@ -266,7 +278,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 {
@@ -306,6 +321,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 +349,23 @@ 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: "15px",
+        height: "15px",
+        margin: "0",
+        accentColor: "var(--dsw-alias-brand-primary, #4b5bff)"
+      };
       const toggleStyle = {
         display: "flex",
         alignItems: "center",
@@ -454,6 +487,7 @@ window.__ModuleLoader__.load({
               type: "checkbox",
               checked: draft.bridgeBuddyMemory === "true",
               disabled,
+              style: checkboxStyle,
               onChange: (e) => edit("bridgeBuddyMemory", e.target.checked ? "true" : "false")
             })
           ]),
@@ -471,7 +505,7 @@ window.__ModuleLoader__.load({
               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" }, "智能模式")
@@ -483,6 +517,7 @@ window.__ModuleLoader__.load({
                   // 避免 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: "" }, "复用当前会话模型"),
@@ -500,6 +535,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/distill.mjs

@@ -13,22 +13,46 @@ 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;
   }
 
@@ -39,16 +63,15 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
   // 自动智能模式（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 ?? "");
     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,13 +80,14 @@ 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 };
     }
     // 3. LLM 调用：借鉴 dsh-sideband 的 summarizeJob（src/summarizer.ts）——
@@ -74,6 +98,9 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
     //       （JSON.parse 失败自然回落全文/降级，不会产生坏数据）。
     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,
@@ -82,23 +109,28 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
       maxTokens: 800,
       signal,
     });
-    const asm = new BlockAssembler();
-    try {
-      for await (const ch of res) {
-        signal.throwIfAborted();
-        asm.push(ch);
-      }
+      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);
+        }
     } catch (e) {
-      dbg("stream aborted/timeout/error", { message: e?.message ?? "", aborted: signal.aborted, reason: signal.reason?.message ?? "" });
+      dbgFail("stream aborted/timeout/error", { message: e?.message ?? "", aborted: signal.aborted, reason: signal.reason?.message ?? "" });
       return { ok: false };
     }
     const finish = asm.finish;
+    dbg("session finish", { kind: finish?.kind });
+    dbg("session stream done", { chunks, deltaChars, firstChunkMs: tFirstChunk });
     if (finish && (finish.kind === "error" || finish.kind === "aborted")) {
-      dbg("llm finish", { kind: finish.kind, message: finish.failure?.message ?? "" });
+      dbgFail("llm finish", { kind: finish.kind, message: finish.failure?.message ?? "" });
       return { ok: false };
     }
     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()
@@ -107,15 +139,17 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
       .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;
     let durable = [];
+    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;
       }
@@ -143,6 +177,8 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
         }
       }
     }
+    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,19 +206,25 @@ 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 gotFirstChunk = false, tFirstChunk = null, chunks = 0, deltaChars = 0;
+      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: 4000, timeoutMs: c.summaryTimeoutMs || 60000 });
 
       // LLM 蒸馏：system = 固化 DISTILL_PROMPT，user = MEMORY.md 全文。
       const timeoutMs = c.summaryTimeoutMs || 60000;
@@ -203,19 +245,25 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
       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);
       }
       const finish = asm.finish;
       if (finish && (finish.kind === "error" || finish.kind === "aborted")) {
-        return { ok: false, message: `蒸馏失败（LLM ${finish.kind}）：${finish.failure?.message ?? ""}` };
+        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 ?? ""}` };
       }
+      dbg("project finish", { kind: finish?.kind });
       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 +285,21 @@ 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, 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 内未返回任何内容，疑似未响应或限流。`;
+      }
+      return { ok: false, message: msg };
     } finally {
       distillLocks.delete(memFile);
     }

package/lib/index.js

@@ -52,7 +52,8 @@ 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 调用诊断日志（模型解析、请求参数、流进度计数、错误详情）。仅排障用，平时关闭；开启后也不打印任何对话内容或记忆文本。"),
 });
 
 export const inject = ["systemPrompt", "tools", "llm", "webServer", "webRuntime"];
@@ -103,6 +104,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 +133,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 +211,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.3.0",
   "description": "把 WorkBuddy 的文件式记忆系统移植进 DeepSeek Harness：用户级 + 工作区的人类可读 Markdown 记忆（~/.deepseek-harness/MEMORY.md 与 <cwd>/.deepseek-harness/memory/）。",
   "type": "module",
   "main": "lib/index.js",