dsh-memory-palace 1.4.1 → 1.6.0

package/lib/hybrid/tools.mjs

@@ -0,0 +1,327 @@
+// memory-palace v1.6.0 hybrid 模式：MEMORY.md 主动维护工具集（仅 hybrid 模式注册）。
+// 三个工具（操作规范全部承载在 description——定案 #11，不做 skill）：
+// - memory_write        章节追加/新增（项目级多目录同步；用户级单文件）
+// - memory_update_section 整章节精确替换 / 单条标记删除（stale 防护：oldText 归一化精确匹配）
+// - memory_reorganize   项目级全量重整（双门禁机器校验 + 原子替换 + 时间戳注释）
+// 定案约束：用户级禁止重整；重整时间戳由机器读写（HTML 注释落文件尾，agent 不可改）；
+// hybrid 下不做三级去重管线（重复治理归子 agent），仅保留同 normLine 精确去重防手滑重复。
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { writeFile, rename } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { readFileSync } from "node:fs";
+import { expandHome, toHomeShort, readMdSync, nowStamp, normLine } from "../common/text.mjs";
+import { appendToSectionText, upsertSectionText, replaceSectionText, markEntryDeletedText, locateSection } from "../common/sections.mjs";
+
+const REORG_MARK = "memory-palace:last-reorg:";
+const REORG_MARK_RE = new RegExp(`\\n?<!--\\s*${REORG_MARK}[^>]*-->\\s*$`);
+
+// 本地 ISO 时间戳（YYYY-MM-DDTHH:mm:ss，冒号保留——落文件内容无文件名限制）。
+// 沿 text.mjs nowStamp 的教训：禁 toISOString（UTC 差 8 小时）。
+const localIsoStamp = () => {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}T${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+};
+
+// 读重整时间戳：文件尾 HTML 注释；无/损坏 → 0（视为从未重整，冷却已过）。
+export function readLastReorg(md) {
+  const m = new RegExp(`<!--\\s*${REORG_MARK}([^>]+)-->`).exec(md || "");
+  if (!m) return 0;
+  const t = new Date(m[1].trim()).getTime();
+  return Number.isFinite(t) ? t : 0;
+}
+
+// 计算 memory_reorganize 双门禁状态（供 pre-execute 弹窗与 execute 复核共用）。
+export function checkReorgGate(memFile, cfg) {
+  const md = readMdSync(memFile);
+  const size = md.length;
+  const overBudget = size > (cfg.workspaceBudgetChars || 3000);
+  const last = readLastReorg(md);
+  const cooldownMs = (cfg.reorgCooldownDays ?? 7) * 86400000;
+  const cooled = Date.now() - last >= cooldownMs;
+  return {
+    ok: overBudget && cooled,
+    size,
+    overBudget,
+    last,
+    cooled,
+    reason: overBudget
+      ? cooled
+        ? "ok"
+        : `重整冷却期内（上次重整 ${new Date(last).toLocaleString()}，冷却 ${cfg.reorgCooldownDays ?? 7} 天），请用 memory_update_section 做章节级修正。`
+      : `MEMORY.md 当前 ${size} 字符未超出注入预算（${cfg.workspaceBudgetChars || 3000}），无需重整；请用 memory_write / memory_update_section 维护。`,
+  };
+}
+
+// 同 normLine 精确去重：目标章节内已存在同归一化条目 → skip（不算去重管线，仅防手滑重复）。
+function sectionHasEntry(md, section, entry) {
+  const loc = locateSection(md, section);
+  if (!loc) return false;
+  const want = normLine(entry);
+  for (let i = loc.start + 1; i < loc.end; i++) {
+    if (normLine(loc.lines[i]) === want) return true;
+  }
+  return false;
+}
+
+/**
+ * 注册 hybrid 工具 + pre-execute 闸门。仅在 memoryMode === "hybrid" 时由 index.mjs 调用
+ * （memoryMode 切换需重启 dsh——注册时机安全，不存在运行中换挡错配）。
+ * @param {{ ctx: object, getConfig: () => object, paths: object, records: object, state: object }} deps
+ */
+export function registerHybridTools({ ctx, getConfig, paths, records, state }) {
+  const cfg = () => getConfig();
+
+  // 目标文件解析：project = 主目标（dirs[0]，多 buddy 目录时与蒸馏按钮同语义只动主目标，
+  // 章节级 stale 校验天然防止错位覆写）；user = 用户级 MEMORY.md。
+  function memFileOf(scope) {
+    if (scope === "user") return { file: expandHome(cfg().userMemoryPath), dirs: [] };
+    const dirs = paths.writeDirs();
+    if (!dirs.length) return null;
+    return { file: paths.memoryFileOf(dirs[0]), dirs };
+  }
+
+  // ---------- memory_write：章节追加/新增（章节化格式规范承载于 description——定案 #11） ----------
+  ctx.tools.register(
+    defineTool({
+      name: "memory_write",
+      description:
+        "Append a durable memory entry to MEMORY.md in the required chaptered format. " +
+        "Format is STRICT: entries live under `## 章节` headings as `- 条目` lines (one-line conclusion first, " +
+        "then key details: commands/paths/numbers; objective third-person; no dialogue, no questions, no tags). " +
+        "If the section exists the entry is appended under it; if not, the section is created automatically " +
+        "(do NOT force-match a semantically wrong section — pick a new section name instead). " +
+        "An exact-duplicate entry (same normalized text) in the same section is skipped. " +
+        "scope='project' writes the active workspace MEMORY.md; scope='user' writes the cross-project user MEMORY.md. " +
+        "NEVER write memory files with the raw write/edit tools — always use this tool. " +
+        "For rewriting a whole section use memory_update_section; full-file reorganization is memory_reorganize (gated).",
+      parameters: {
+        scope: {
+          type: "string",
+          required: true,
+          description: "'project' (active workspace MEMORY.md) or 'user' (cross-project user MEMORY.md).",
+        },
+        section: { type: "string", required: true, description: "章节标题（不含 `## ` 前缀），如：环境必知。" },
+        entry: { type: "string", required: true, description: "条目文本（一行，结论先行 + 关键细节，不带 `- ` 前缀）。" },
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: { ok: { type: "boolean", required: true }, message: { type: "string", required: true } },
+        },
+        render: (_args, value) => [{ type: "text", text: value?.message ?? "Saved." }],
+      },
+      async execute(args) {
+        state.recentAgentWrote = true;
+        const c = cfg();
+        if (!c.enabled) return { ok: false, message: "memory-palace is currently disabled in settings." };
+        const section = String(args.section ?? "").trim();
+        const entry = String(args.entry ?? "").trim();
+        if (!section || !entry) return { ok: false, message: "section 与 entry 均不能为空。" };
+        const target = memFileOf(args.scope === "user" ? "user" : "project");
+        if (!target) return { ok: false, message: "No active workspace." };
+        try {
+          let wrote = 0;
+          let skipped = 0;
+          const files = target.dirs.length ? target.dirs.map((d) => paths.memoryFileOf(d)) : [target.file];
+          for (const file of files) {
+            const md = readMdSync(file);
+            if (sectionHasEntry(md, section, entry)) {
+              skipped++;
+              continue;
+            }
+            const r = upsertSectionText(md, section, entry);
+            if (!r.ok) {
+              skipped++;
+              continue;
+            }
+            await writeFile(file, r.text, "utf8");
+            wrote++;
+          }
+          return {
+            ok: wrote > 0,
+            message: wrote > 0
+              ? `Saved to ${wrote} MEMORY.md file(s) under 「${section}」${skipped ? ` (${skipped} duplicate skipped)` : ""}.`
+              : `Duplicate entry under 「${section}」; nothing written.`,
+          };
+        } catch (e) {
+          return { ok: false, message: `Failed: ${e}` };
+        }
+      },
+    }),
+  );
+
+  // ---------- memory_update_section：整章节精确替换 / 单条标记删除（stale 防护） ----------
+  ctx.tools.register(
+    defineTool({
+      name: "memory_update_section",
+      description:
+        "Update ONE section of MEMORY.md with stale-protection. Two modes:\n" +
+        "1) Replace: pass oldText = the FULL current section text including its `## heading` line " +
+        "(read it first via memory_read) and newText = the complete replacement section. The oldText is " +
+        "matched by normalized exact comparison against the section on disk — on any mismatch the tool REJECTS " +
+        "and returns the actual current content, so re-read and retry.\n" +
+        "2) Mark-delete a single entry: pass markDelete:true and oldText = the exact entry line text; the entry " +
+        "becomes a strikethrough tombstone (~~text~~) — never physically deleted, recoverable by hand.\n" +
+        "NEVER edit memory files with raw write/edit tools. Deleting whole information is only allowed as " +
+        "strikethrough; section replacement must not drop still-valid entries. " +
+        "scope='project' (active workspace MEMORY.md, primary target) or 'user' (user MEMORY.md; NO full reorganize).",
+      parameters: {
+        scope: {
+          type: "string",
+          required: true,
+          description: "'project' (active workspace MEMORY.md primary target) or 'user'.",
+        },
+        section: { type: "string", required: true, description: "章节标题（不含 `## ` 前缀）。" },
+        oldText: {
+          type: "string",
+          required: true,
+          description: "replace 模式 = 含 `## 标题` 行的整章节当前全文；markDelete 模式 = 目标条目原文（可含 `- ` 前缀）。",
+        },
+        newText: { type: "string", description: "replace 模式必填：替换后的整章节全文（含 `## 标题` 行，需保留删除线墓碑）。" },
+        markDelete: { type: "boolean", description: "true = 仅把 oldText 匹配的单条条目标记为删除线；省略 = 整章节替换。" },
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            ok: { type: "boolean", required: true },
+            message: { type: "string", required: true },
+            actual: { type: "string", required: true },
+          },
+        },
+        render: (_args, value) =>
+          [{ type: "text", text: value?.actual ? `${value.message}\n\n当前实际内容：\n${value.actual}` : value?.message ?? "Done." }],
+      },
+      async execute(args) {
+        state.recentAgentWrote = true;
+        const c = cfg();
+        if (!c.enabled) return { ok: false, message: "memory-palace is currently disabled in settings.", actual: "" };
+        const section = String(args.section ?? "").trim();
+        const oldText = String(args.oldText ?? "");
+        if (!section || !oldText.trim()) return { ok: false, message: "section 与 oldText 均不能为空。", actual: "" };
+        const target = memFileOf(args.scope === "user" ? "user" : "project");
+        if (!target) return { ok: false, message: "No active workspace.", actual: "" };
+        try {
+          const file = target.file;
+          const md = readMdSync(file);
+          const r = args.markDelete === true
+            ? markEntryDeletedText(md, section, oldText)
+            : replaceSectionText(md, section, oldText, args.newText);
+          if (!r.ok) {
+            return { ok: false, message: `更新被拒绝（${r.reason}）：请先 memory_read 重读后再试。`, actual: r.actual ?? "" };
+          }
+          await writeFile(file, r.text, "utf8");
+          return { ok: true, message: `Updated 「${section}」 in ${toHomeShort(file)} (${r.reason}).`, actual: "" };
+        } catch (e) {
+          return { ok: false, message: `Failed: ${e}`, actual: "" };
+        }
+      },
+    }),
+  );
+
+  // ---------- memory_reorganize：项目级全量重整（双门禁机器校验 + 原子替换 + 时间戳） ----------
+  ctx.tools.register(
+    defineTool({
+      name: "memory_reorganize",
+      description:
+        "FULLY reorganize the PROJECT-LEVEL MEMORY.md by replacing the whole file with newContent. " +
+        "HARD GATES (machine-checked, both required): (1) the file exceeds the injection budget " +
+        "(workspaceBudgetChars); (2) at least reorgCooldownDays (default 7) since the last reorganize. " +
+        "If either gate fails the call is REJECTED — use memory_update_section instead. " +
+        "Requirements for newContent: keep the full `## 章节` + `- 条目` format; NEVER lose still-valid key " +
+        "information — read the daily logs (memory_read) and current MEMORY.md for cross-checking first; " +
+        "merge duplicates, drop only strikethrough/obsolete content; keep user-level MEMORY.md untouched " +
+        "(user-level reorganization is FORBIDDEN). A last-reorg timestamp comment is appended automatically. " +
+        "A user confirmation dialog is shown before execution.",
+      parameters: {
+        newContent: {
+          type: "string",
+          required: true,
+          description: "重整后的项目级 MEMORY.md 完整全文（`## 章节` + `- 条目` 格式；不含重整时间戳注释——机器自动追加）。",
+        },
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: { ok: { type: "boolean", required: true }, message: { type: "string", required: true } },
+        },
+        render: (_args, value) => [{ type: "text", text: value?.message ?? "Done." }],
+      },
+      async execute(args) {
+        state.recentAgentWrote = true;
+        const c = cfg();
+        if (!c.enabled) return { ok: false, message: "memory-palace is currently disabled in settings." };
+        const dirs = paths.writeDirs();
+        if (!dirs.length) return { ok: false, message: "No active workspace." };
+        const file = paths.memoryFileOf(dirs[0]);
+        // 复核双门禁（pre-execute 已拦一道；这里防绕过）
+        const gate = checkReorgGate(file, c);
+        if (!gate.ok) return { ok: false, message: `重整被门禁拒绝：${gate.reason}` };
+        const newContent = String(args.newContent ?? "").replace(REORG_MARK_RE, "").replace(/\s+$/, "");
+        if (!newContent.trim()) return { ok: false, message: "newContent 不能为空。" };
+        const stamped = `${newContent}\n\n<!-- ${REORG_MARK}${localIsoStamp()} -->\n`;
+        try {
+          // 原子替换（沿 distillProjectMemory 模式）：cover 同目录写入 → 完整性校验 → 备份 → rename → 失败回滚
+          const coverFile = join(dirname(file), "memory-cover.md");
+          await writeFile(coverFile, stamped, "utf8");
+          if (!readMdSync(coverFile)) {
+            await import("node:fs/promises").then((m) => m.unlink(coverFile)).catch(() => {});
+            return { ok: false, message: "memory-cover.md 未完整写入，本次重整失败（原记忆未动）。" };
+          }
+          const backup = `${file}.${nowStamp()}`;
+          const fsp = await import("node:fs/promises");
+          await fsp.rename(file, backup).catch(async () => {
+            await fsp.rename(coverFile, file); // 原文件不存在（首次创建）时直接落位
+            return true;
+          });
+          try {
+            await fsp.rename(coverFile, file);
+          } catch (e) {
+            await fsp.rename(backup, file).catch(() => {});
+            throw e;
+          }
+          return {
+            ok: true,
+            message: `重整完成：${toHomeShort(file)}（原 ${gate.size} → ${stamped.length} 字符），备份 ${toHomeShort(backup)}，时间戳已更新。`,
+          };
+        } catch (e) {
+          return { ok: false, message: `重整失败（原记忆未动或已回滚）：${e?.message || String(e)}` };
+        }
+      },
+    }),
+  );
+}
+
+// hybrid 写工具闸门（pre-execute）：plan 模式 deny；memory_reorganize 门禁前置计算 + 原生确认弹窗。
+// 沿 tools.mjs 的 memory_delete 闸门模式（tools/pre-execute → approval.request）。
+export function attachHybridGuards(ctx, getConfig, paths, state) {
+  const HYBRID_WRITE_TOOLS = new Set(["memory_write", "memory_update_section", "memory_reorganize"]);
+  ctx.on("tools/pre-execute", async (exec, next) => {
+    const name = exec?.name;
+    if (!HYBRID_WRITE_TOOLS.has(name)) return next();
+    if (state.planModeActive) {
+      return { kind: "deny", reason: "plan 模式下禁止写入记忆" };
+    }
+    if (name !== "memory_reorganize") return next();
+    const c = getConfig();
+    const dirs = paths.writeDirs();
+    if (!dirs.length) return { kind: "deny", reason: "无活动工作区，无法重整。" };
+    const file = paths.memoryFileOf(dirs[0]);
+    const gate = checkReorgGate(file, c);
+    if (!gate.ok) return { kind: "deny", reason: gate.reason };
+    const args = (exec.arguments && typeof exec.arguments === "object") ? exec.arguments : {};
+    const size = String(args.newContent ?? "").length;
+    return {
+      kind: "ask",
+      reason:
+        `⚠️ 项目级 MEMORY.md 全量重整确认\n` +
+        `当前 ${gate.size} 字符（已超预算 ${c.workspaceBudgetChars || 3000}），冷却已满足（上次重整 ${gate.last ? new Date(gate.last).toLocaleString() : "从未"}）。\n` +
+        `即将用 ${size} 字符的新全文覆盖 ${file}（原文件会自动备份）。\n` +
+        `请确认是否执行重整？`,
+    };
+  });
+}

package/lib/index.js

@@ -24,17 +24,20 @@
 //   硬约束——dsh 客户端模块系统不支持插件相对 require）
 import { join } from "node:path";
 import Schema from "@deepseek-ai/schemastery";
-import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
-import { todayISO, expandHome, toHomeShort, readMdSync, budgetClip, extractText, extractToolErrorText } from "./common/text.mjs";
+// v1.6.0-rc1：适配 DSH 0.1.2-alpha.2——dsh-settings 不再导出自由函数 installSettingsSection /
+// settingsNamespace，设置节注册改用 SettingsProvider 实例方法 installSection（经 ctx.inject(["settings"])）。
+import { todayISO, expandHome, toHomeShort, readMdSync, budgetClip, stripSmartTag, stripDeletedLines, extractText, extractToolErrorText } from "./common/text.mjs";
 import { SCENE_KEYWORDS } from "./common/prompts.mjs";
 import { createPaths } from "./common/paths.mjs";
 import { createRecords } from "./common/records.mjs";
 import { createDistill } from "./distill.mjs";
 import { registerTools } from "./tools.mjs";
 import { registerApi } from "./api.mjs";
+import { registerHybrid, HYBRID_PROACTIVE } from "./hybrid/index.mjs";
 
 export const name = "memory-palace";
-const MEMORY_PALACE_SETTINGS_NAMESPACE = settingsNamespace("memory-palace");
+// v1.6.0-rc1：settingsNamespace() 已删除，namespace 直接用字符串（宿主侧做类型级校验）。
+const MEMORY_PALACE_SETTINGS_NAMESPACE = "memory-palace";
 
 export const Config = Schema.object({
   enabled: Schema.boolean().default(true).description("启用 memory-palace 记忆注入与每日日志写入。"),
@@ -49,8 +52,9 @@ export const Config = Schema.object({
   // ---- v0.7.1 调整：废弃插件侧 callLlm，主路径 = 记忆公民 prompt 主动记忆；turn/end 仅做轻量兜底 ----
   summarize: Schema.boolean().default(true).description("它是「agent 主动记忆」主路径失效时的安全网，保证实质工作不丢，代价是只留原始文本、不做总结。"),
   autoCaptureErrors: Schema.boolean().default(true).description("对话出错时（含代码运行报错、工具执行失败）自动把『错误现象』写入对应 MEMORY.md（『根因/方案』由 agent 按记忆公民指令场景①主动记；默认开，关闭无需重启）。"),
-  // ---- v1.1.0：双记忆模式（插件模式=现状；智能模式=LLM 智能会话摘要），设置页切换，互斥，切换需重启 dsh ----
-  memoryMode: Schema.union(["plugin", "smart"]).default("plugin").description("记忆模式：plugin=记忆公民指令+轮次轻量+错误捕获；smart=LLM 智能会话摘要（summary→每日日志 + durable→MEMORY.md，带 [smart] 标记）。切换需重启 dsh 生效。"),
+  // ---- v1.1.0：记忆模式（plugin=记忆公民指令+轮次轻量+错误捕获；smart=LLM 智能会话摘要）----
+  // v1.6.0：+hybrid（子 agent 自动维护日志 + agent 主动维护 MEMORY.md），三档并存，切换需重启 dsh。
+  memoryMode: Schema.union(["plugin", "smart", "hybrid"]).default("plugin").description("记忆模式：plugin=记忆公民指令+轮次轻量+错误捕获；smart=LLM 智能会话摘要（summary→每日日志 + durable→MEMORY.md）；hybrid=记忆子代理自动维护今日日志（标删去重）+ agent 主动维护 MEMORY.md（章节化写入/整章节替换/门禁内全量重整）。切换需重启 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 调用诊断。distillLogLevel=info 时仅输出元数据（模型解析/请求参数/流进度/错误详情，不含文本）；distillLogLevel=debug 会额外打印 LLM 原始响应文本（分隔符包裹），仅限受信本地排障开启。"),
@@ -60,7 +64,10 @@ export const Config = Schema.object({
   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 仍仅手动按钮开放，自动模式跳过（防误删）。"),
+  feedbackEnabled: Schema.boolean().default(false).description("蒸馏时把项目级 + 用户级 MEMORY.md 全文（逐行编号、无截断）回喂给 LLM，使其能基于既有记忆做 add/replace/delete 增量维护。默认关；开启后自动智能模式（turn/end）与手动蒸馏会话按钮均回喂存量记忆；delete 仍仅手动按钮开放，自动模式跳过（防误删）。hybrid 模式下此开关不参与（子代理自带日志回喂）。"),
+  // ---- v1.6.0：hybrid 模式配置（仅 memoryMode=hybrid 时生效） ----
+  reorgCooldownDays: Schema.number().default(7).description("hybrid 模式：项目级 MEMORY.md 全量重整的冷却天数（距上次重整）。与「超出注入预算」双条件同时满足才允许 memory_reorganize；时间戳以 HTML 注释落在 MEMORY.md 文件尾。"),
+  subagentLogBudget: Schema.number().default(20000).description("hybrid 模式：记忆子代理回喂今日工作日志的字符上限。超出时仅回喂章节目录，子代理用 log_read_section 按需读取章节。"),
 });
 
 export const inject = ["systemPrompt", "tools", "llm", "webServer", "webRuntime"];
@@ -68,14 +75,10 @@ export const inject = ["systemPrompt", "tools", "llm", "webServer", "webRuntime"
 export function apply(ctx, config) {
   // 设置集成：在 DSH 设置页暴露 memory-palace 配置面板；运行时优先读用户设置覆盖层，
   // 未挂载 settings 服务时回退到 cordis 组合里的 config。
+  // v1.6.0-rc1：注册动作挪进下方 ctx.inject(["settings"]) 回调（installSection 是
+  // SettingsProvider 实例方法，须等 settings 服务挂载；其内部同步 setSource，时序与旧版等价）。
   let source = () => config;
   const baseEntry = { ...config };
-  installSettingsSection(ctx, MEMORY_PALACE_SETTINGS_NAMESPACE, Config, baseEntry, {
-    setSource: (next) => {
-      source = next;
-    },
-    onChange: () => {},
-  });
 
   // ---- v1.1.3：设置读写 route（真保存）----
   // client fetch 同源 /memory-palace/api/settings.get|update，绕过 settingsScope(persistence=memory no-op)
@@ -84,6 +87,15 @@ export function apply(ctx, config) {
   let settingsFace = null;
   ctx.inject(["settings"], (sctx) => {
     const ns = MEMORY_PALACE_SETTINGS_NAMESPACE;
+    // v1.6.0-rc1：设置节注册挪到此处（settings 服务就绪后）。installSection 内部会同步
+    // 执行 setSource(() => scope.get())，把 source 从 cordis config 切到用户设置覆盖层；
+    // owner=ctx 使插件卸载时宿主自动回退 setSource(() => entry)。与旧版自由函数时序等价。
+    sctx.settings.installSection(ctx, ns, Config, baseEntry, {
+      setSource: (next) => {
+        source = next;
+      },
+      onChange: () => {},
+    });
     const viewOf = () => {
       const descriptor = sctx.settings.describe({ redactSecrets: true }).find((candidate) => candidate.ns === ns);
       return descriptor === undefined
@@ -112,6 +124,9 @@ export function apply(ctx, config) {
     lastSummarizedSeq: -1,    // 智能模式增量摘要断点（session 事件 seq）
     summarySessionId: null,
     planModeActive: false,    // 计划模式：禁写记忆（硬编码默认，无开关；仅经 session/event 的 plan/mode 翻转；未装 dsh-plan-mode 永不触发=不拦截）
+    // v1.4.1：已注入记忆的 session 集合——仅首次注入（DSH 会话自身继承历史轮次，逐轮注入
+    // = 内容重复 + 过时断言每轮在场）；compaction 发生后清除对应 id，下次构建重注。
+    injectedSessionIds: new Set(),
   };
   const TURN_BUFFER_MAX = 30;
   // v1.1.3：字符上限提升到 30k（长工具型 request 的工具结果动辄数千字符，6k 上限会触发
@@ -125,6 +140,14 @@ export function apply(ctx, config) {
   const distill = createDistill({ ctx, getConfig: () => source(), paths, records, state });
   registerTools({ ctx, getConfig: () => source(), paths, records, state });
   registerApi({ ctx, paths, distill, state, getSettingsFace });
+  // v1.6.0：hybrid 模式独立模块。必须【无条件注册】——apply() 同步段执行时 settings 服务
+  // 尚未挂载（v1.6.0-rc1 起设置节经 SettingsProvider.installSection 在 ctx.inject(["settings"])
+  // 回调里注册并同步 setSource），此刻 source() 读的是 cordis 组合配置（默认 plugin），
+  // 条件注册会导致设置页切 hybrid 后工具/子代理从未注册（v1.6.0 实装踩坑：settings.yaml
+  // memoryMode=hybrid 但 registerHybrid 未执行 → 子代理 TypeError 被吞、日志全空）。
+  // 运行时分派靠 _settle / proactive 的热 source() 判断；工具注册无副作用（plugin/smart
+  // 的 prompt 不引导使用，guards 白名单只拦 hybrid 工具）。
+  const hybrid = registerHybrid({ ctx, getConfig: () => source(), paths, records, state });
 
   // ---- session/event 跟踪：更新 activeCwd/activeSession/增量断点 + 累积 turnBuffer ----
   // 关键：一次用户请求在 dsh agent 循环里会被拆成多个 turn（每个工具调用一轮），
@@ -169,6 +192,10 @@ export function apply(ctx, config) {
       }
       // 不清空 buffer；用 debounce 在整段请求安静后结算一次。
       _scheduleSettle();
+    } else if (type === "compaction" || type?.startsWith?.("compaction/")) {
+      // v1.4.1：compaction 压缩上下文后，记忆块可能被压掉——清除已注入标记，
+      // 下次 system prompt 构建时重注（压缩后上下文变薄，重注时机依然正确）。
+      if (session?.id) state.injectedSessionIds.delete(session.id);
     }
   });
 
@@ -183,16 +210,28 @@ export function apply(ctx, config) {
       const userFileShort = toHomeShort(userFileResolved);
       const blocks = [];
       // v1.2.0：注入按预算截断——用户级 ≤ userBudgetChars、工作区级（MEMORY.md 与今日日志）
-      // 各自 ≤ workspaceBudgetChars；保留头部并追加截断标记（修复预算死配置问题）。
+      // 各自 ≤ workspaceBudgetChars。v1.4.1：budgetClip 改为"结构行 + 尾部最新条目"（修
+      // LIFO/FIFO 错配——写入追加在尾部，旧实现只留头部导致最新结论永远进不了视野），
+      // stripSmartTag 剥除行首 [smart] 标记（模型不可见该标签，存量自然消亡）。
+      // v1.6.0：stripDeletedLines 剔除整行删除线墓碑（文件保留、注入不过）。
       const u = readMdSync(userFileResolved);
-      if (u) blocks.push(`# 用户级记忆 (${userFileShort})\n${budgetClip(u, cfg.userBudgetChars)}`);
+      if (u) blocks.push(`# 用户级记忆 (${userFileShort})\n${stripSmartTag(stripDeletedLines(budgetClip(u, cfg.userBudgetChars)))}`);
       for (const dir of paths.readDirs()) {
         const dirShort = toHomeShort(dir);
         const w = paths.memoryReadCandidates(dir).map(readMdSync).filter(Boolean).join("\n\n");
-        if (w) blocks.push(`# 工作区记忆 (${dirShort})\n${budgetClip(w, cfg.workspaceBudgetChars)}`);
+        if (w) blocks.push(`# 工作区记忆 (${dirShort})\n${stripSmartTag(stripDeletedLines(budgetClip(w, cfg.workspaceBudgetChars)))}`);
         const t = readMdSync(join(dir, `${todayISO()}.md`));
-        if (t) blocks.push(`# 今日工作日志 (${todayISO()} @ ${dirShort})\n${budgetClip(t, cfg.workspaceBudgetChars)}`);
+        if (t) blocks.push(`# 今日工作日志 (${todayISO()} @ ${dirShort})\n${stripSmartTag(stripDeletedLines(budgetClip(t, cfg.workspaceBudgetChars)))}`);
       }
+      // v1.4.1：仅首次注入。DSH 会话自身引用历史轮次作为上下文，逐轮注入 = 内容重复 +
+      // 过时断言每轮在场；记忆注入的价值大头在冷启动第一轮。已注入过的 session 返回
+      // 空串；compaction 后经 session/event 清除标记实现重注。
+      // intro 指令仍始终注入（无记忆时也不例外——否则 agent 不知道记忆系统存在，形成
+      // 「无记忆→无指令→永不记」死循环）；被跳过的只是记忆正文块。
+      const sessionId = state.activeSession?.id ?? null;
+      const alreadyInjected = sessionId ? state.injectedSessionIds.has(sessionId) : false;
+      if (sessionId && !alreadyInjected && blocks.length) state.injectedSessionIds.add(sessionId);
+      if (alreadyInjected) blocks.length = 0;
       // 记忆正文可能为空（冷启动 / 全新环境尚无任何记忆）。
       // 注意：intro（含记忆公民指令）必须【始终】注入——若因记忆为空而整体返回空串，
       // agent 将不知道记忆系统存在、不会主动记，形成「无记忆 → 无指令 → 永不记」的死循环。
@@ -201,16 +240,19 @@ export function apply(ctx, config) {
         "提及记忆文件路径时一律用 ~ 简写（如 ~/.deepseek-harness/MEMORY.md），不要逐字拼写绝对路径——你转述绝对路径容易漏掉目录分隔符。";
       // v1.1.0：按记忆模式注入不同指令。插件模式=记忆公民指令（引导 agent 主动记）；
       // 智能模式=简短说明（记忆由 LLM 智能摘要自动维护，无需主动记，但仍可用 memory_read 读）。
+      // v1.6.0：hybrid=记忆子代理自动维护日志 + agent 主动维护 MEMORY.md（见 HYBRID_PROACTIVE）。
       const proactive =
         source().memoryMode === "smart"
           ? "\n\n[记忆说明] 你的跨 session 记忆由 LLM 智能摘要自动维护（每轮结束自动提炼摘要并沉淀 durable 事实到 MEMORY.md），无需主动调用 memory_note / memory_note_user；读取全部记忆用 memory_read 工具（不要手动 glob/read 记忆文件）。"
-          : "\n\n[记忆公民指令] 你拥有跨 session 的 Markdown 记忆。以下场景【必须】主动调用 memory_note（项目级约定）或 memory_note_user（跨项目个人偏好）落档，不要依赖轮次结束的自动兜底——它只做原始文本截断，无法代替你的高质量总结：\n" +
-            "① 完成任务 / 工作并产出结果（写脚本、统计、分析、修复、交付）→ 记任务做了什么 + 关键结果（路径/命令/数字）\n" +
-            "② 修复 bug / 定位根因（记现象 + 根因 + 绕过/修复手法，防复发）\n" +
-            "③ 验证 build/test/CI 通过（记命令与结论）\n" +
-            "④ 完成里程碑 / 关键决策 / 变更约定（记决策与理由）\n" +
-            "⑤ 用户表达的偏好、约束、durable 事实（记原话要点）\n" +
-            "判定标准：这条信息「下个 session 的我」还需要吗？不需要（闲聊、一次性操作、显而易见）就不记。格式：一句话结论开头 + 关键细节（命令/路径/数字），不写流水账。";
+          : source().memoryMode === "hybrid"
+            ? HYBRID_PROACTIVE
+            : "\n\n[记忆公民指令] 你拥有跨 session 的 Markdown 记忆。以下场景【必须】主动调用 memory_note（项目级约定）或 memory_note_user（跨项目个人偏好）落档，不要依赖轮次结束的自动兜底——它只做原始文本截断，无法代替你的高质量总结：\n" +
+              "① 完成任务 / 工作并产出结果（写脚本、统计、分析、修复、交付）→ 记任务做了什么 + 关键结果（路径/命令/数字）\n" +
+              "② 修复 bug / 定位根因（记现象 + 根因 + 绕过/修复手法，防复发）\n" +
+              "③ 验证 build/test/CI 通过（记命令与结论）\n" +
+              "④ 完成里程碑 / 关键决策 / 变更约定（记决策与理由）\n" +
+              "⑤ 用户表达的偏好、约束、durable 事实（记原话要点）\n" +
+              "判定标准：这条信息「下个 session 的我」还需要吗？不需要（闲聊、一次性操作、显而易见）就不记。格式：一句话结论开头 + 关键细节（命令/路径/数字），不写流水账。";
       const intro = bridged
         ? "你拥有持久化、人类可直接编辑的 Markdown 记忆文件。当前项目已存在 WorkBuddy/CodeBuddy 项目记忆目录，本插件直接读写这些目录（不再单独创建 .deepseek-harness/memory/）。" +
           "写入记忆：项目级约定用 memory_note 工具，跨项目个人偏好用 memory_note_user 工具；读取全部记忆用 memory_read 工具（不要手动 glob/read 记忆文件）。用它保持跨 session 一致性；看不到的内容不要编造。" +
@@ -223,6 +265,8 @@ export function apply(ctx, config) {
         ? "\n\n[plan 模式] 当前处于 plan 模式，不要调用 memory_note / memory_note_user 写入记忆，也不要请求删除记忆（读取记忆用 memory_read，仍可用）。"
         : "";
       const introFull = intro + planNote;
+      // v1.4.1：blocks 为空（已注入过）时只返回 intro 指令；返回值永非空串，
+      // 避免 harness 对空 section 的处理歧义。
       return blocks.length ? [introFull, ...blocks].join("\n\n") : introFull;
     },
   });
@@ -263,7 +307,18 @@ export function apply(ctx, config) {
       }
     }
 
-    // 写门控：命中闸门才写（受 summarize 总开关，两种模式共用）。
+    // v1.6.0 hybrid：记忆子代理每轮必跑（定案——不走闸门；plan 模式在上方已拦）。
+    // 失败不降级 writeLightEntry（v1.6.0 定案：无格式原文会破坏日志章节化结构）——
+    // 断点不推进，下一次 turn/end 子代理自动补蒸。
+    if (cfg.memoryMode === "hybrid") {
+      if (!cfg.summarize) return; // 总闸门（dirs.length 已在上方保证非空）
+      void hybrid
+        .runMemorySubagent({ ctx, getConfig: () => source(), paths, records, state, session: state.activeSession, dirs, isError: effectiveIsError })
+        .catch(() => {});
+      return;
+    }
+
+    // 写门控：命中闸门才写（受 summarize 总开关，插件/smart 模式共用）。
     if (!cfg.summarize || !baseGateOpen) return;
 
     if (cfg.memoryMode === "smart") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-palace",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "把 WorkBuddy 的文件式记忆系统移植进 DeepSeek Harness：用户级 + 工作区的人类可读 Markdown 记忆（~/.deepseek-harness/MEMORY.md 与 <cwd>/.deepseek-harness/memory/）。",
   "type": "module",
   "main": "lib/index.js",
@@ -30,24 +30,24 @@
     "client": {
       "platform": "web",
       "inject": [
-        "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-renderer",
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-connection",
-        "@deepseek-ai/dsh-api-remotes"
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-api-session-controller"
       ]
     }
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "*",
-    "@deepseek-ai/dsh-fs": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-llm": "*",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-tools": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2"
   },
   "scripts": {
     "build": "node scripts/build.mjs",