dsh-memory-palace 1.4.1 → 1.6.0

package/README.md

@@ -4,6 +4,9 @@
 
 [![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)
 
+> mian分支已适配**deepseek harness 0.1.2-alpha.2+**
+> 旧版本已切换分支归档，见`dsh-v0.1.x`
+
 ## 特性
 
 - **人类可读的真源**：记忆全部存储在 Markdown 文件中（`MEMORY.md` + 每日日志 `YYYY-MM-DD.md`），任何编辑器可直接修改，数据永远属于你。
@@ -15,7 +18,9 @@
 - **会话标题栏「记忆」按钮**：支持手动蒸馏：①蒸馏会话 / ②蒸馏项目记忆。
 - **设置页集成**：DSH 设置中内置「记忆」面板（中英双语），所有配置均可图形化调整，无需改配置文件。
 - **主动记忆（主路径，插件模式）**：注入「记忆公民指令」引导 agent 在「修复 bug/根因+绕过」「验证 build/test 通过」「完成里程碑/关键决策」「用户表达偏好/约束」时主动调 `memory_note` / `memory_note_user` 落档 — 对标 WorkBuddy 的"智能记一笔"手感。
-- **智能模式（LLM 智能会话摘要）**：智能模式下，每轮命中防闲聊闸门后由 harness 把本会话**新增对话增量**（按 session 事件 seq 断点）提炼成摘要——`summary` 写每日日志（带 `[smart]` 标记）+ durable 事实写 MEMORY.md。
+- **智能模式（LLM 智能会话摘要）**：智能模式下，每轮命中防闲聊闸门后由 harness 把本会话**新增对话增量**（按 session 事件 seq 断点）提炼成摘要——`summary` 写每日日志 + durable 事实写 MEMORY.md（v1.4.2 起条目不再带 `[smart]` 标签）。
+- **记忆注入（v1.4.2）**：记忆块仅在会话**首次**构建时注入（DSH 会话自身继承历史轮次，逐轮注入冗余且有过时断言干扰）；发生上下文压缩（compaction）后自动重注。注入按预算截断时保留结构行与**尾部最新条目**（写入追加在尾部，确保最新结论始终可见）。
+- **混合模式（hybrid，v1.6.0）**：记忆子代理在每轮 turn/end 自动把本轮摘要写入**今日工作日志**（章节化组织、回喂今日日志做增量去重、重复/过时条目标删除线墓碑）；MEMORY.md 写入权归还 agent（`memory_write` 章节化追加 / `memory_update_section` 整章节精确替换 / 双门禁内 `memory_reorganize` 全量重整）。hybrid 下日志永不过期（作为证据层保留）。
 - **标准 npm 插件包**：经 `dsh plugin` 一键装入 profile，`cordis.patch.yml` 声明 bundle patch，零手动改动 harness。
 
 ## 记忆文件布局
@@ -65,6 +70,9 @@ turn/end ──► 轻量兜底闸门
 | `memory_note_user` | 用户级 | 把跨项目偏好写入 `~/.deepseek-harness/MEMORY.md`（去重） |
 | `memory_read` | 聚合 | 一次性读取用户级 + 项目级记忆、今日日志与最近 3 份历史日志 |
 | `memory_delete` | 用户级/项目级/每日级 | 按内容删除记忆条目（两阶段确认：先预览匹配位置与内容，用户确认后再删；删除动作经 harness 原生确认弹窗硬闸门，真人点允许才真正执行） |
+| `memory_write`（hybrid） | 项目级/用户级 | 章节化写入：章节存在则末尾追加，不存在则新建章节（章节化格式规范） |
+| `memory_update_section`（hybrid） | 项目级/用户级 | 整章节精确替换/单条标记删除：oldText 归一化精确匹配防 stale，失败拒绝并回显实际内容 |
+| `memory_reorganize`（hybrid） | 仅项目级 | 全量重整 MEMORY.md：双门禁（超出注入预算 且 距上次重整 ≥ 冷却天数）机器校验，原子替换 + 时间戳注释，用户确认弹窗 |
 
 ## 安装
 
@@ -74,7 +82,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.4.1
+# 锁定版本：dsh plugin --profile web add github:lovezi0/dsh-memory-palace#v1.6.0
 ```
 
 方式二：clone 后本地安装（开发 / 修改源码场景）
@@ -92,8 +100,6 @@ dsh plugin --profile web add .    # 装入 web profile（profile 名按你的实
 ```bash
 # 直接由 dsh 从 npm 拉取并装入（本机若已配镜像会自动走镜像）
 dsh plugin --profile web add dsh-memory-palace
-# 锁定版本：
-dsh plugin --profile web add dsh-memory-palace@1.4.1
 
 # 或先手动用 npm 安装（显式指定镜像），再装入：
 npm install dsh-memory-palace --registry=https://registry.npmmirror.com/
@@ -117,6 +123,18 @@ dsh plugin --profile web remove dsh-memory-palace
 
 ## 版本历史
 
+- **1.6.0**
+    - 🔥适配deepseek harness 0.1.2-alpha.2
+- **1.6.0.alpha.1** *未发布npm*
+    - 🔥新增混合模式(hybrid) *仍默认插件模式，建议切换至混合模式*
+    - 🔥新增记忆子agent处理轮次会话日志
+    - 💪优化记忆文件结构做到真正人类可读
+    - 💪优化调试模式参数保存
+- **1.4.2.alpha.1** *未发布npm*
+    - 💪记忆注入：仅首次注入 + compaction 重注
+    - 💪优化手动项目蒸馏prompt
+    - 💪[smart] 标签全移除
+    - 🐛修复记忆文件LIFO/FIFO 错配
 - **1.4.1**
     - 🐛修复输出预算使用错位的问题
     - 🐛增加调试模式日志级别 *默认info 仅输出元数据日志，debug 输出完整LLM text*

package/lib/api.mjs

@@ -99,6 +99,19 @@ function apiWriteError(res, error) {
   });
 }
 
+// v1.6.0 联动纯函数（可单测）：distillDebugLog=true 时保证 distillLogLevel 存在（默认 info），
+// false 时移除 distillLogLevel。distillLogLevel 是平铺键（不进 UI），由 settings.update 在此兜底。
+export function applyDebugLogLinkage(section) {
+  if (section && typeof section === "object" && !Array.isArray(section)) {
+    if (section.distillDebugLog === true) {
+      if (!section.distillLogLevel) section.distillLogLevel = "info";
+    } else if (section.distillDebugLog === false) {
+      delete section.distillLogLevel;
+    }
+  }
+  return section;
+}
+
 /**
  * @param {{ ctx: object, paths: object, distill: object, state: object, getSettingsFace: () => object | null }} deps
  */
@@ -136,6 +149,10 @@ export function registerApi({ ctx, paths, distill, state, getSettingsFace }) {
               if (section === null || typeof section !== "object" || Array.isArray(section)) {
                 throw Object.assign(new Error("section must be a plain object"), { code: "bad-request", status: 400 });
               }
+              // v1.6.0 联动：distillDebugLog=true 时保证 distillLogLevel 存在（默认 info，保证
+              // 服务端日志开启即输出元数据诊断）；false 时移除 distillLogLevel（防止残留 debug
+              // 级别持续打印 LLM 原始响应文本）。distillLogLevel 是平铺键（不进 UI），在此统一兜底。
+              applyDebugLogLinkage(section);
               if (!face) {
                 throw Object.assign(new Error("settings service is not mounted"), { code: "settings-rejected", status: 503 });
               }

package/lib/client.js

@@ -5,7 +5,8 @@ window.__ModuleLoader__.load({
     var exports = module.exports;
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     let react = require("react");
-    let _deepseek_ai_dsh_client_runtime_client = require("@deepseek-ai/dsh-client-runtime/client");
+    // v1.6.0-rc1：移除 require("@deepseek-ai/dsh-client-runtime/client")——该包在
+    // DSH 0.1.2-alpha.2 已整体删除（原变量赋值后零使用），平台 seed 表的 react 足够。
 
     const NS = "memory-palace";
 
@@ -38,6 +39,11 @@ window.__ModuleLoader__.load({
       memoryModeLabel: "记忆模式",
       memoryModeHintPlugin: "插件模式：记忆公民指令 + 轮次轻量 + 错误捕获。切换需重启 dsh 生效。",
       memoryModeHintSmart: "智能模式：LLM 智能会话摘要（summary→每日日志 + durable→MEMORY.md）。切换需重启 dsh 生效。",
+      memoryModeHintHybrid: "混合模式：记忆子代理自动维护今日日志（章节化、标删去重），agent 主动维护 MEMORY.md（章节化写入、整章节替换、门禁内全量重整）。切换需重启 dsh 生效。",
+      reorgCooldownLabel: "重整冷却（天）",
+      reorgCooldownHint: "项目级 MEMORY.md 全量重整的冷却天数（距上次重整）；与「超出注入预算」双条件同时满足才允许 memory_reorganize。默认 7 天。",
+      subagentLogBudgetLabel: "子代理日志回喂预算（字符）",
+      subagentLogBudgetHint: "记忆子代理回喂今日工作日志的字符上限；超出时仅回喂章节目录，子代理按需读取章节。默认 20000。",
       summaryModelLabel: "摘要模型（智能模式）",
       summaryModelHint: "留空=复用当前会话的 provider/model；也可固定廉价小模型省 token。",
       save: "保存",
@@ -104,6 +110,11 @@ window.__ModuleLoader__.load({
       memoryModeLabel: "Memory mode",
       memoryModeHintPlugin: "Plugin mode: memory-citizen instructions + turn-end light entries + error capture. Switching requires a dsh restart.",
       memoryModeHintSmart: "Smart mode: LLM conversation summarization (summary -> daily log + durable -> MEMORY.md). Switching requires a dsh restart.",
+      memoryModeHintHybrid: "Hybrid mode: a memory sub-agent auto-maintains today's daily log (chaptered, dedupe by strikethrough); the agent proactively maintains MEMORY.md (chaptered writes, section replace, gated full reorganize). Switching requires a dsh restart.",
+      reorgCooldownLabel: "Reorganize cooldown (days)",
+      reorgCooldownHint: "Cooldown days between full reorganizes of the project MEMORY.md; combined with 'over injection budget' both gates must pass for memory_reorganize. Default 7.",
+      subagentLogBudgetLabel: "Sub-agent log feed budget (chars)",
+      subagentLogBudgetHint: "Max chars of today's daily log fed back to the memory sub-agent; beyond this only the chapter TOC is fed and the sub-agent reads sections on demand. Default 20000.",
       summaryModelLabel: "Summary model (smart mode)",
       summaryModelHint: "Leave empty to reuse the current session's provider/model, or pin a cheap model (provider/model) to save tokens.",
       save: "Save",
@@ -204,8 +215,30 @@ window.__ModuleLoader__.load({
     }
 
 
+    // v1.6.0-rc1：模型枚举改走 ctx.remote.session.modelCatalog()——ApiProxy 包已在
+    // DSH 0.1.2-alpha.2 删除（旧 conn.api.llm.models 死了）。服务缺席 / 非 ok / 异常
+    // 一律降级为空列表，下拉只剩「复用当前会话模型」，UX 不变。
+    async function fetchModelOptions(ctx) {
+      try {
+        const remote = ctx && ctx.remote;
+        if (!remote || !remote.session || typeof remote.session.modelCatalog !== "function") return [];
+        const response = await remote.session.modelCatalog();
+        if (!response || !response.ok || !response.value) return [];
+        const opts = [];
+        for (const g of response.value.groups || []) {
+          for (const m of (g && g.models) || []) {
+            // m.id 已含 provider 前缀（如 nvidia/nemotron-3-ultra-550b-a55b），直接用，避免重复拼接
+            opts.push({ value: m.id, label: (g.name || g.id) + " / " + (m.name || m.id) });
+          }
+        }
+        return opts;
+      } catch (e) {
+        return [];
+      }
+    }
+
     function MemoryPalaceSection(props) {
-      const { t, getConnection } = props;
+      const { t, fetchModels } = props;
       const [remote, setRemote] = react.useState({ value: null, user: {}, revision: undefined, loaded: false });
       const [draft, setDraft] = react.useState(() => projectDraft({ value: null }));
       const [dirty, setDirty] = react.useState(false);
@@ -214,7 +247,7 @@ window.__ModuleLoader__.load({
       const [validation, setValidation] = react.useState(null);
       const [modelOptions, setModelOptions] = react.useState([]);
 
-      // 初始加载（从自有 route 读真实值，绕过 apiproxy allowlist）。
+      // 初始加载（从自有 route 读真实值）。
       react.useEffect(() => {
         let alive = true;
         (async () => {
@@ -240,18 +273,8 @@ window.__ModuleLoader__.load({
         let alive = true;
         (async () => {
           try {
-            const conn = getConnection && getConnection();
-            if (!conn || !conn.api || !conn.api.llm || typeof conn.api.llm.models !== "function") return;
-            const r = await conn.api.llm.models({});
-            const groups = (r && r.result && r.result.value && r.result.value.groups) || (r && r.groups) || [];
-            const opts = [];
-            for (const g of groups || []) {
-              for (const m of (g && g.models) || []) {
-                // m.id 已经包含 provider 前缀（如 nvidia/nemotron-3-ultra-550b-a55b），直接用，避免重复拼接
-                opts.push({ value: m.id, label: g.name + " / " + m.name });
-              }
-            }
-            if (alive) setModelOptions(opts);
+            const opts = await (fetchModels && fetchModels());
+            if (alive) setModelOptions(Array.isArray(opts) ? opts : []);
           } catch (e) {
             /* 枚举失败：保持空列表，下拉只剩「复用当前会话模型」 */
           }
@@ -523,17 +546,23 @@ window.__ModuleLoader__.load({
         ]),
         h("div", { style: cardStyle }, [
           h("p", { style: groupTitleStyle }, t("smartSummary")),
-          // 轮次结束自动记录(summarize)：两种记忆模式的共用总闸门，始终显示，置于记忆模式之上、不随模式切换隐藏。
+          // 轮次结束自动记录(summarize)：三种记忆模式的共用总闸门，始终显示，置于记忆模式之上、不随模式切换隐藏。
           toggle(t("summarizeLabel"), t("summarizeHint"), "summarize"),
-          row(t("memoryModeLabel"), draft.memoryMode === "smart" ? t("memoryModeHintSmart") : t("memoryModeHintPlugin"),
+          row(t("memoryModeLabel"),
+            draft.memoryMode === "smart"
+              ? t("memoryModeHintSmart")
+              : draft.memoryMode === "hybrid"
+                ? t("memoryModeHintHybrid")
+                : t("memoryModeHintPlugin"),
             h("select", {
-              value: draft.memoryMode === "smart" ? "smart" : "plugin",
+              value: ["plugin", "smart", "hybrid"].includes(draft.memoryMode) ? draft.memoryMode : "plugin",
               disabled,
               onChange: (e) => edit("memoryMode", e.target.value),
               style: selectStyle
             }, [
               h("option", { value: "plugin" }, "插件模式"),
-              h("option", { value: "smart" }, "智能模式")
+              h("option", { value: "smart" }, "智能模式"),
+              h("option", { value: "hybrid" }, "混合模式")
             ]), "memoryMode"),
           draft.memoryMode === "smart"
             ? h("div", null, [
@@ -553,9 +582,14 @@ window.__ModuleLoader__.load({
                 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("autoCaptureErrorsLabel"), t("autoCaptureErrorsHint"), "autoCaptureErrors")
-              ])
+            : draft.memoryMode === "hybrid"
+              ? h("div", null, [
+                  row(t("reorgCooldownLabel"), t("reorgCooldownHint"), h("input", num("reorgCooldownDays")), "reorgCooldownDays"),
+                  row(t("subagentLogBudgetLabel"), t("subagentLogBudgetHint"), h("input", num("subagentLogBudget")), "subagentLogBudget")
+                ])
+              : h("div", null, [
+                  toggle(t("autoCaptureErrorsLabel"), t("autoCaptureErrorsHint"), "autoCaptureErrors")
+                ])
         ]),
         h("div", { style: cardStyle }, [
           h("p", { style: groupTitleStyle }, t("storage")),
@@ -839,14 +873,8 @@ window.__ModuleLoader__.load({
       // v1.1.3：设置读写走自有 route（/memory-palace/api），不再 bind settingsScope——
       // 非 loopback 下 settingsScope persistence=memory（set() no-op），保存永不落盘。
       const controller = new MemoryPalaceController(ctx);
-      // v1.1.0：枚举已配置模型供「摘要模型」下拉（connection 服务，枚举失败则降级为空列表）。
-      const getConnection = () => {
-        try {
-          return ctx.get("connection");
-        } catch {
-          return null;
-        }
-      };
+      // v1.6.0-rc1：枚举已配置模型改走 ctx.remote.session.modelCatalog()（ApiProxy 已删），
+      // 枚举失败则降级为空列表。
       ctx.slots.inject("settings.section", () => ctx.slots.register({
         name: "settings.section",
         id: "memory-palace",
@@ -854,7 +882,7 @@ window.__ModuleLoader__.load({
         label: () => t("nav"),
         locale: NS,
         inject: () => controller.inject()
-      }, (props) => MemoryPalaceSection({ ...props, getConnection })));
+      }, (props) => MemoryPalaceSection({ ...props, fetchModels: () => fetchModelOptions(ctx) })));
       // v1.2.0：会话标题栏「记忆」按钮——headerUtilities 区（右对齐），order:-1 排在 Session log 左边。
       ctx.slots.inject("conversation.session.header.utilities", () => ctx.slots.register({
         name: "conversation.session.header.utilities",
@@ -865,7 +893,8 @@ window.__ModuleLoader__.load({
     }
 
     exports.apply = apply;
-    exports.inject = ["slots", "locale", "connection"];
+    // v1.6.0-rc1：connection → remote + remote.session（模型枚举走 ctx.remote.session.modelCatalog）。
+    exports.inject = ["slots", "locale", "remote", "remote.session"];
     return module.exports;
   }
 });

package/lib/common/prompts.mjs

@@ -52,11 +52,12 @@ export function DISTILL_PROMPT({ outputBudget } = {}) {
   "只保留「以后还会用到」的信息，删掉「一次性过程」。\n" +
   "唯一判断标准：删了这条，下次开工会不会出错 / 返工 / 重踩坑？会 → 留；不会 → 删。\n" +
   "\n" +
-  "【只提炼 7 类信息，无关的类别直接省略，不要硬凑】\n" +
+  "【只提炼「以后还会用到」的信息，无关的类别直接省略，不要硬凑】\n" +
+  "常见归档维度（参考，可按材料实际内容增删维度）：\n" +
   "1. 定位 —— 一句话说清任务本质 + 最终产出什么。\n" +
   "2. 当前状态 —— 现在推进到哪一步、卡在哪、下一步是什么。\n" +
   "3. 核心约束 —— 什么绝对不能变。注意：丢了会出事的才叫约束，丢了只是不方便的是细节，细节不写。\n" +
-  "4. AI 行为边界 —— AI 能做什么、绝不能做什么、什么留给用户。所有「谁来做 / 谁授权 / 谁拍板」的约定都要显式归入这里，不能混在别的条目里。\n" +
+  "4. AI 行为边界 —— AI 能做什么、绝不能做什么、什么留给用户。若设置该章节，则所有「谁来做 / 谁授权 / 谁拍板」的约定集中于此。\n" +
   "5. 关键路径 —— 绝对路径、命令、数据源、模板、依赖。原样精确保留，禁止用占位符。\n" +
   "6. 决策记录 —— 为什么这么做（而非只记做了什么），尽量带日期或版本锚点。废弃方案单独标注为「已废弃」，不要删除。\n" +
   "7. 坑与教训 —— 现象 → 根因 → 解法，一条一个坑。一句话能讲清的坑不算坑、不记。\n" +
@@ -67,7 +68,9 @@ export function DISTILL_PROMPT({ outputBudget } = {}) {
   "- 精确值：路径、命令、字段名、版本号原样保留，禁用 ~/、占位符或「大概」。\n" +
   "- 时间锚点：决策和坑尽量带日期或版本，让人知道这是哪个阶段的结论。\n" +
   "\n" +
-  "【输出格式】严格按以下骨架输出，无关章节整节删除：\n" +
+  // v1.4.1：骨架从强制改为参考——章节可按内容增删/合并/改名，以契合为先（修实测的
+  // 「章节与内容不匹配」）。下方自检第 6 条同步翻转为「查错位」，防收尾自检把自由度撤销。
+  "【输出格式】参考以下骨架组织输出，章节可按材料实际内容增删/合并/改名，以内容与章节契合为先，无关章节不硬凑：\n" +
   "\n" +
   "# <项目名> 项目笔记\n" +
   "<一句话定位 + 当前状态>\n" +
@@ -93,7 +96,7 @@ export function DISTILL_PROMPT({ outputBudget } = {}) {
   "3. 边界是否显式、无歧义、没有混在别的条目里？\n" +
   "4. 路径 / 命令 / 版本号是否精确？\n" +
   "5. 每个坑是否「现象 → 根因 → 解法」三要素齐全？\n" +
-  "6. 是否只输出了骨架要求的章节，没有额外发挥？\n" +
+  "6. 每个条目是否归在了最契合的章节？有没有为凑骨架而错位归类？\n" +
   "\n" +
   (outputBudget != null ? "【输出长度约束】你提炼后的项目记忆请控制在约 " + outputBudget + " token（≈" + Math.round(outputBudget * 1.8) + " 字）以内。思考不受限，但成稿须精炼、不超预算；只保留「以后还会用到」的信息，删掉「一次性过程」。\n" : "") +
   "现在开始处理我提供的材料。"

package/lib/common/records.mjs

@@ -3,7 +3,7 @@
 import { mkdir, readdir, unlink, readFile, writeFile } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
-import { todayISO, expandHome, readMdSync, toHomeShort, normLine, isStructural } from "./text.mjs";
+import { todayISO, expandHome, readMdSync, toHomeShort, normLine, isStructural, stripSmartTag } from "./text.mjs";
 
 // 追加一行记忆，若目标文件已包含相同内容则跳过（去重），返回是否实际写入。
 export async function appendLineDedup(file, line) {
@@ -78,6 +78,8 @@ export async function removeLineByMatch(file, match) {
 // 全文逐行编号读取（v1.4.0 特性3：回喂存量记忆）。返回 { lines:[{n,raw,structural}], text }。
 // 行号 n 与文件实际行一一对应（1 起），供 LLM 通过 line 引用；text 为每行 `n|raw` 拼接，直接喂模型。
 // 不截断、无字符预算（用户明确要求全量回喂，避免截断导致记忆错误）。
+// v1.4.1：回喂行经 stripSmartTag 剥除行首 [smart] 标记——模型不可见该标签（写侧已停拼），
+// 存量磁盘条目读时透明剥除。replace/delete 的 oldText 校验仍以磁盘原文（raw）为准，不受影响。
 export function readNumberedMemory(file) {
   let cur = "";
   try {
@@ -90,7 +92,7 @@ export function readNumberedMemory(file) {
     const t = raw.trim();
     return { n: i + 1, raw, structural: isStructural(t) };
   });
-  const text = lines.map((l) => `${l.n}|${l.raw}`).join("\n");
+  const text = lines.map((l) => `${l.n}|${stripSmartTag(l.raw)}`).join("\n");
   return { lines, text };
 }
 
@@ -203,6 +205,9 @@ export function createRecords({ getConfig, paths }) {
 
   async function prune(dir) {
     const c = cfg();
+    // v1.6.0：hybrid 模式下日志永不过期不删（dailyLogRetentionDays 不可用，定案）——
+    // 日志是子代理维护的证据层，过期并入 MEMORY.md 的旧逻辑在 hybrid 下也不应触达。
+    if (c.memoryMode === "hybrid") return;
     const cutoff = Date.now() - c.dailyLogRetentionDays * 86400000;
     let files = [];
     try {

package/lib/common/sections.mjs

@@ -0,0 +1,167 @@
+// memory-palace v1.6.0 hybrid 模式：Markdown 章节纯函数（无 IO、无副作用）。
+// 服务三类调用方：记忆子 agent 的日志 ops（追加/新增/标删）、agent 的 memory_write /
+// memory_update_section 工具、memory_reorganize 的门禁计算。
+// 设计约束（v1.6.0 定案）：
+// - 全部返回 { ok, reason, ... }，永不抛错——LLM 产出的 ops 不可信，机器侧兜底；
+// - 只拆两级标题（`## `），`#` 文件标题与前言归 head，`###` 及更深归当前章节内容；
+// - 不改动 text.mjs 既有函数（normLine/budgetClip 有 v1.4.1 测试锚定），本文件自持归一化。
+
+// 章节标题归一化：剥 `#` 前缀、合空白、转小写。标题匹配全部走它，"带不带 ## 前缀"都鲁棒。
+const normTitle = (s) =>
+  (s || "").trim().replace(/^#+\s*/, "").replace(/\s+/g, " ").toLowerCase();
+
+// 章节块归一化：逐行 trim + 合空白、丢空行、转小写。整章节 stale 比对（防并发/重试错位）用。
+const normBlock = (t) =>
+  (t || "")
+    .split("\n")
+    .map((l) => l.trim().replace(/\s+/g, " "))
+    .filter((l) => l)
+    .join("\n")
+    .toLowerCase();
+
+const SECTION_RE = /^##\s+(.+?)\s*$/;
+
+// 解析 `## ` 章节。返回 { head: string[], sections: [{ title, lines }] }；
+// lines 含标题行本体；`#` 文件标题、前言与 `<!--` 注释归 head；`###` 及更深归当前章节。
+export function parseSections(md) {
+  const lines = (md || "").split("\n");
+  const head = [];
+  const sections = [];
+  let cur = null;
+  for (const line of lines) {
+    const m = SECTION_RE.exec(line);
+    if (m) {
+      cur = { title: m[1].trim(), lines: [line] };
+      sections.push(cur);
+      continue;
+    }
+    if (cur) cur.lines.push(line);
+    else head.push(line);
+  }
+  return { head, sections };
+}
+
+// 在 md 中定位章节，返回 { start, end, lines }（end 为下一章节起点或文件尾，不含）。
+// 未命中返回 null。供内部函数与 hybrid/tools.mjs（memory_update_section 的 stale 校验）共用。
+export function locateSection(md, section) {
+  const lines = (md || "").split("\n");
+  const want = normTitle(section);
+  if (!want) return null;
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const m = SECTION_RE.exec(lines[i]);
+    if (m && normTitle(m[1]) === want) {
+      start = i;
+      break;
+    }
+  }
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let j = start + 1; j < lines.length; j++) {
+    if (SECTION_RE.test(lines[j])) {
+      end = j;
+      break;
+    }
+  }
+  return { start, end, lines };
+}
+
+// 章节内追加条目。章节存在 → 内容最后一个非空行后插入 `- entry`（全空行则插在标题行后）；
+// 章节不存在 → { ok:false, reason:"section-miss" }（调用方决定是否走新增）。
+// entry 写入前剥除行首列表符（`- `/`* `/`-`/`*`，含缩进）——LLM 常按描述示例自带 `- ` 前缀，
+// 不剥会导致 `- - xxx` 双列表符脏数据（v1.6.0 实装踩坑）。
+export function appendToSectionText(md, section, entry) {
+  const clean = String(entry ?? "").trim().replace(/^[-*]\s+/, "").trim();
+  const entryLine = `- ${clean}`;
+  if (!entryLine.slice(2).trim()) return { ok: false, reason: "empty-entry" };
+  const loc = locateSection(md, section);
+  if (!loc) return { ok: false, reason: "section-miss" };
+  const { start, end, lines } = loc;
+  let insertAt = end;
+  while (insertAt > start + 1 && !lines[insertAt - 1].trim()) insertAt--;
+  lines.splice(insertAt, 0, entryLine);
+  return { ok: true, reason: "appended", text: lines.join("\n") };
+}
+
+// 章节追加（upsert 语义）：存在则追加，不存在则文件尾新增章节。日志 ops 的 "append" 与
+// memory_write 工具共用——"不要强行匹配现有章节，不符合章节标题就走新增"。
+export function upsertSectionText(md, section, entry) {
+  const r = appendToSectionText(md, section, entry);
+  if (r.ok) return r;
+  if (r.reason === "empty-entry") return r;
+  const title = `## ${String(section ?? "").trim()}`;
+  const base = (md || "").replace(/\s+$/, "");
+  const entryLine = `- ${String(entry ?? "").trim().replace(/^[-*]\s+/, "").trim()}`;
+  const text = base ? `${base}\n\n${title}\n${entryLine}\n` : `${title}\n${entryLine}\n`;
+  return { ok: true, reason: "section-created", text };
+}
+
+// 显式新建章节（与 upsert 的区别：章节已存在时拒绝而非追加）——子 agent 日志 ops 的
+// "new_section" 专用，防止模型把该走 append 的操作误标为 new_section 造成静默混写。
+export function createSectionText(md, section, entry) {
+  if (locateSection(md, section)) return { ok: false, reason: "section-exists" };
+  return upsertSectionText(md, section, entry);
+}
+
+// 整章节精确替换（stale 防护）：oldSectionText 与当前章节全文（含标题行，归一化后）必须完全
+// 一致才执行替换，否则拒绝并回显当前实际内容（供 agent 重读后再试）。newSectionText 原样落盘
+// （模型负责含 `## 标题` 与删除线标记）；匹配/拒绝的归一化对首尾空行不敏感。
+export function replaceSectionText(md, section, oldSectionText, newSectionText) {
+  const newText = String(newSectionText ?? "").trim();
+  if (!newText) return { ok: false, reason: "empty-replacement" };
+  const loc = locateSection(md, section);
+  if (!loc) return { ok: false, reason: "section-miss" };
+  const { start, end, lines } = loc;
+  const current = lines.slice(start, end).join("\n").trim();
+  if (normBlock(current) !== normBlock(String(oldSectionText ?? ""))) {
+    return { ok: false, reason: "conflict", actual: current };
+  }
+  // 保留章节末尾的分隔空行（章节与下一章节之间通常有空行，整块替换时不能吞掉，
+  // 否则下一章节标题会紧贴上一章节最后一条目）。
+  const hasTrailingBlank = end > start && !lines[end - 1].trim();
+  const spliceEnd = hasTrailingBlank ? end - 1 : end;
+  lines.splice(start, spliceEnd - start, ...newText.split("\n"));
+  return { ok: true, reason: "replaced", text: lines.join("\n") };
+}
+
+// 章节内标记删除（墓碑，不物理删除）：命中行改写为删除线格式；已删除线 → already；
+// 结构行（# / <!--）与已删除线条目永不被改写；章节未命中 / 行未命中分别上报。
+// 删除线格式：保留原列表符（`- text` → `- ~~text~~`；无列表符 → `~~text~~`）。
+export function markEntryDeletedText(md, section, entryOldText) {
+  const want = normLineLoose(entryOldText);
+  if (!want) return { ok: false, reason: "empty-entry" };
+  const loc = locateSection(md, section);
+  if (!loc) return { ok: false, reason: "section-miss" };
+  const { start, end, lines } = loc;
+  for (let i = start + 1; i < end; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || isStructuralLine(trimmed)) continue;
+    if (/^(-\s+)?~~[\s\S]+~~$/.test(trimmed)) {
+      if (normLineLoose(trimmed) === want) return { ok: true, reason: "already", text: md };
+      continue;
+    }
+    if (normLineLoose(trimmed) !== want) continue;
+    const struck = /^-\s+/.test(trimmed)
+      ? trimmed.replace(/^(-\s+)([\s\S]+)$/, "$1~~$2~~")
+      : `~~${trimmed}~~`;
+    lines[i] = raw.replace(trimmed, struck);
+    return { ok: true, reason: "marked", text: lines.join("\n") };
+  }
+  return { ok: false, reason: "entry-miss" };
+}
+
+// 宽松行归一化：剥列表符与删除线包裹、合空白、转小写。标删比对专用（与 text.mjs normLine
+// 语义相近但多剥一层 ~~，避免"已标删行"永远无法二次匹配）。
+function normLineLoose(s) {
+  return (s || "")
+    .trim()
+    .replace(/^-\s+/, "")
+    .replace(/^~~([\s\S]+)~~$/, "$1")
+    .replace(/\s+/g, " ")
+    .toLowerCase();
+}
+
+function isStructuralLine(t) {
+  return t.startsWith("#") || t.startsWith("<!--");
+}

package/lib/common/text.mjs

@@ -33,7 +33,7 @@ export function expandHome(p) {
 }
 
 // 反向简写：home 下的绝对路径 → ~ 简写（统一正斜杠）。AI 转述绝对路径极易拼错
-// （实测出现过 lovezi0.deepseek-harness 缺分隔符），一律喂给它 ~ 简写。
+// （实测出现过缺分隔符，如 ~/.deepseek-harness 被拼成 ~.deepseek-harness），一律喂给它 ~ 简写。
 export function toHomeShort(p) {
   if (!p) return p;
   const h = homedir();
@@ -54,13 +54,59 @@ export function readMdSync(path) {
   }
 }
 
-// v1.2.0 预算截断：注入 system prompt 时按字符上限截断（保留头部 + 截断标记）。
-// budget <= 0 / 未配置视为不限。userBudgetChars / workspaceBudgetChars 在 text() 注入路径生效，
-// 修复 v1.1.x 之前两配置为死配置的问题（与 README「注入系统提示词的长度上限」语义对齐）。
+// v1.4.1 重写：修 LIFO/FIFO 错配（旧实现 slice(0, budget) 只留头部，而写入追加在尾部——
+// 最新结论永远进不了注入视野，"写了等于没写"）。新策略：保留全部结构行（# / <!--）+
+// 从尾部向前累积内容行至预算用尽，中间以截断标记衔接。budget <= 0 / 未配置视为不限。
 export function budgetClip(text, budget) {
   if (!text || !budget || budget <= 0) return text;
   if (text.length <= budget) return text;
-  return text.slice(0, budget) + `\n…（已截断，原 ${text.length} 字符，仅注入前 ${budget} 字符）`;
+  const lines = text.split("\n");
+  const head = [];
+  let i = 0;
+  // 头部连续结构行（文件标题/注释区）与空行无条件保留
+  while (i < lines.length && (!lines[i].trim() || isStructural(lines[i].trim()))) {
+    head.push(lines[i]);
+    i++;
+  }
+  // 尾部向前累积内容行至预算用尽
+  const tail = [];
+  let used = 0;
+  let j = lines.length - 1;
+  while (j >= i && used < budget) {
+    const cost = lines[j].length + 1;
+    if (used + cost > budget && tail.length > 0) break;
+    tail.unshift(lines[j]);
+    used += cost;
+    j--;
+  }
+  if (j < i) return head.join("\n") + (head.length ? "\n" : "") + tail.join("\n");
+  const marker = `…（已截断，原 ${text.length} 字符，仅注入结构行与尾部最近条目）`;
+  return [...head, marker, ...tail].join("\n");
+}
+
+// v1.4.1：剥除行首 `[smart]` 标记（含重复），保留列表符与其余内容。用于注入与回喂的读侧——
+// 模型全程不可见该标签（写侧 v1.4.1 起不再拼接），存量磁盘条目自然消亡、无需迁移。
+// 逐行处理：允许行首有 `N|` 计数前缀（readNumberedMemory 的回喂格式）与列表符，
+// 只剥「列表符/行首之后紧跟的 [smart] 标记序列」；正文中间的 "smart" 字样不误伤。
+export function stripSmartTag(text) {
+  if (!text) return text;
+  return text
+    .split("\n")
+    .map((line) =>
+      line.replace(/^(\s*(?:\d+\|)?\s*[-*]\s+|\s*(?:\d+\|)\s*)?(\[smart\]\s*)+/, "$1"),
+    )
+    .join("\n");
+}
+
+// v1.6.0：注入侧删除线过滤——整行都是删除线墓碑（`~~...~~`，可带 `- ` 列表符）的条目
+// 视为已作废，注入 system prompt 时剔除（省 token、防模型把墓碑当现行有效）；
+// 行内局部删除线（`- 旧名 ~~原名~~` 之类）不是墓碑，不滤。文件本体保留墓碑供审计。
+export function stripDeletedLines(text) {
+  if (!text) return text;
+  return text
+    .split("\n")
+    .filter((line) => !/^\s*(?:-\s+)?~~[\s\S]+~~\s*$/.test(line))
+    .join("\n");
 }
 
 // 行归一化：去掉 `- `/`* ` 前缀、合并空白、转小写，使"带不带前缀"的子串匹配都鲁棒。

package/lib/distill.mjs

@@ -4,7 +4,7 @@ import { mkdir, unlink, writeFile, rename } from "node:fs/promises";
 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 { expandHome, readMdSync, toHomeShort, nowStamp, stripSmartTag } from "./common/text.mjs";
 import { appendLineDedup, readNumberedMemory, applyMemoryOp } from "./common/records.mjs";
 import { runWithRetry, RETRY_CONSTANTS } from "./common/retry.mjs";
 
@@ -239,9 +239,12 @@ export function createDistill({ ctx, getConfig, paths, records, state }) {
     }
     for (const d of durable) {
       if (!d || typeof d !== "object") continue;
-      const fact = String(d.fact ?? "").trim();
+      let fact = String(d.fact ?? "").trim();
       if (!fact) continue;
-      const line = `- [smart] ${fact}`;
+      // v1.4.1：写侧不再拼接 [smart] 标签（防回喂二次拼接形成 [smart] [smart] 双前缀、
+      // 防标签注意力稀释）；防御性剥除 LLM 自行带回的标签，保证落盘条目干净。
+      fact = stripSmartTag(fact).trim();
+      const line = `- ${fact}`;
       if (d.scope === "user") {
         await appendLineDedup(expandHome(c.userMemoryPath), line).catch(() => {});
       } else {

package/lib/hybrid/index.mjs

@@ -0,0 +1,18 @@
+// memory-palace v1.6.0 hybrid 模式：模块入口（装配）。
+// 仅在 memoryMode === "hybrid" 时由 index.mjs 调用 registerHybrid（memoryMode 切换需重启
+// dsh——注册时机安全）。不注册任何 DSH 全局资源以外的东西；runMemorySubagent 由 index.mjs
+// 的 _settle hybrid 分支每轮调用。
+import { runMemorySubagent } from "./subagent.mjs";
+import { registerHybridTools, attachHybridGuards } from "./tools.mjs";
+
+export { HYBRID_PROACTIVE } from "./prompts.mjs";
+
+/**
+ * @param {{ ctx: object, getConfig: () => object, paths: object, records: object, state: object }} deps
+ * @returns {{ runMemorySubagent: Function }}
+ */
+export function registerHybrid({ ctx, getConfig, paths, records, state }) {
+  registerHybridTools({ ctx, getConfig, paths, records, state });
+  attachHybridGuards(ctx, getConfig, paths, state);
+  return { runMemorySubagent };
+}