dsh-memory-palace 1.8.0-alpha.1 → 1.8.0-alpha.2

package/README.md

@@ -124,6 +124,10 @@ dsh plugin --profile web remove dsh-memory-palace
 ## 版本历史
 
 - **1.8.0**
+    - **1.8.0-alpha.2**
+        - 🐛修复多会话并发导致写侧串台 @sunligh91
+        - 🐛删除会话分桶后遗留的三个全局状态死字段
+        - 🐛修复plan 模式禁写记忆串台导致其他会话也禁写记忆
     - **1.8.0-alpha.1**
         - 💥移除插件模式与智能模式，记忆写入统一为混合模式
         - 💥配置项 memoryMode / autoCaptureErrors / dailyLogRetentionDays 删除（旧值静默失效）

package/lib/common/planmode.mjs

@@ -0,0 +1,32 @@
+// plan 模式判定（按会话）—— 单一判定入口，供 section 注入 / 结算闸门 / 写工具 deny 共用。
+//
+// 宿主事实：plan 模式是**会话级**状态，不是应用级开关 ——
+//   - 状态以事件 append 到单个会话：`session.append('plan/mode', { active })`
+//     （packages/plan/plan-mode/src/index.ts:434、:450）
+//   - plan-mode 插件自身也按 session 保存待提交意图与已记录状态：
+//     `this.pendingIntents.set(session, …)` / `this.loggedActive(session)`（同文件 :425、:434）
+//   - 状态由该会话的事件流折叠：`if (event.type === 'plan/mode') …`（同文件 :154）
+//
+// 故本插件不得用进程级全局承载它：A 会话进 plan 会波及 B 会话 —— B 的记忆不落盘、
+// B 的 system prompt 被注入 plan 提示、B 的写工具被 deny（回归测试 tests/test-planmode-crosstalk.mjs）。
+//
+// 判定顺序：
+//   ① 拿得到会话身份（session.id）→ **只看该会话的记录**：无记录 = 该会话从未进 plan = false。
+//      🔴 此处**不得**回落到全局值——那等于用别的会话的 plan 状态来判定本会话，正是本次修的串台。
+//   ② 拿不到会话身份（宿主某些调用形态的 exec 不带 agent.session，如 tools/pre-execute 的载荷）
+//      → 回落全局 `state.planModeActive`（= 最近一次 plan/mode 事件的值；fail-safe：偏向拦写，
+//      绝不会写错项目）。
+//
+// ⚠️ 写成**纯函数**而非 state 上的方法：多处单测用裸 mock state 构造
+// `{ planModeActive: … }`（tests/test-session-cwd.mjs、tests/test-load.mjs），
+// 若挂成 `state.isPlanMode()` 这些 mock 会直接 TypeError。纯函数 + 兜底读全局，两条路径都兼容。
+export function planModeOf(state, session) {
+  const sid = session?.id;
+  if (sid) {
+    const map = state?.planModeBySession;
+    // 生产路径：有会话身份 + 有分桶表 → 只看该会话（无记录即 false，绝不看全局）。
+    // 单测的裸 mock state 没有 planModeBySession → 落到下面的全局兜底，保持旧行为兼容。
+    if (map && typeof map.get === "function") return !!map.get(sid);
+  }
+  return !!state?.planModeActive;
+}

package/lib/hybrid/subagent.mjs

@@ -1,419 +1,423 @@
-// memory-palace v1.6.0 hybrid 模式：记忆子 agent（turn/end 触发的轻量工具循环）。
-// 职责（定案）：每轮必跑，判定+产出一体——无重点纯文本收尾（1 次调用）；有重点通过循环内
-// 白名单工具把格式化摘要写入今日工作日志（2-5 次调用）。只操作今日日志，三种操作：
-// 新增章节 / 章节内追加 / 标记删除（~~删除线~~ 墓碑），禁止覆盖整文件与物理删除。
-// 架构依据（v1.6.0 调研）：ctx.llm.stream 支持 GenerateOptions.tools，finish.kind ===
-// 'tool-calls' 时用 BlockAssembler.message() 回喂 assistant 消息 + createToolResultMessage
-// 回喂工具结果，自建循环；ctx.subagents 需活 Agent 作父，插件不可用。
-import { readFileSync } from "node:fs";
-import { writeFile, mkdir } from "node:fs/promises";
-import { join, dirname } from "node:path";
-import { BlockAssembler, createUserMessage, createToolResultMessage } from "@deepseek-ai/dsh-llm";
-import { todayISO, readMdSync } from "../common/text.mjs";
-import { eventsFrom } from "../common/session.mjs";
-import { appendToSectionText, upsertSectionText, createSectionText, markEntryDeletedText, parseSections, locateSection, ensureLogHeader } from "../common/sections.mjs";
-import { HYBRID_PROACTIVE, SUBAGENT_SYSTEM } from "./prompts.mjs";
-
-export { HYBRID_PROACTIVE };
-
-const MAX_ROUNDS = 6; // 循环轮次上限（含首轮）；超限降级
-const MAX_RETRY = 3;  // 未知工具触发的催促重试预算（v1.6.3 定为 3）
-const SURFACE = new Set(["user/message", "assistant/message", "tool/result"]);
-
-// 日志文件写锁（全局 promise 链串行化）：子 agent 落盘与手动蒸馏按钮/其他写路径并发防护。
-let logWriteChain = Promise.resolve();
-function withLogLock(file, fn) {
-  const run = logWriteChain.then(fn, fn);
-  logWriteChain = run.catch(() => {});
-  return run;
-}
-
-// 模型解析（与 distill.mjs resolveModel 同逻辑，改动须两处同步）：summaryModel 注册表反查
-// > 前缀兜底 > 会话 requestHeader 兜底。复制而非导出原因：hybrid 走独立模块定案，不碰 distill。
-async function resolveModel(cfg, ctx, session) {
-  const sm = (cfg.summaryModel || "").trim();
-  if (sm) {
-    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 === sm);
-          if (m) return { provider: m.provider, model: m.id };
-        } catch { /* 该 provider 无模型列表，跳过 */ }
-      }
-      const provider = sm.split("/")[0].trim();
-      if (provider && sm.includes("/")) return { provider, model: sm };
-    } catch { /* 注册表不可用，走会话兜底 */ }
-  }
-  const conf = session?.requestHeader?.()?.config;
-  if (conf && conf.provider && conf.model) return { provider: conf.provider, model: conf.model };
-  return null;
-}
-
-// 单次流式调用（带 tools）。finish.kind 为 error/aborted 时抛出由上层降级；tool-calls/stop 正常返回。
-async function streamTurn(ctx, params, timeoutMs) {
-  const signal = AbortSignal.timeout(timeoutMs);
-  const res = ctx.llm.stream({ ...params, signal });
-  const asm = new BlockAssembler();
-  for await (const ch of res) {
-    signal.throwIfAborted();
-    asm.push(ch);
-  }
-  const finish = asm.finish;
-  if (finish.kind === "error" || finish.kind === "aborted") {
-    throw new Error(finish.failure?.message || finish.kind);
-  }
-  return { finish, asm };
-}
-
-// 把本轮 surface 事件投影为消息数组（seq >= fromSeq；与 distillSessionCore 同源逻辑）。
-// v1.6.2-alpha.4：eventsFrom 兼容层（宿主 0.1.2-alpha.4 删除 Session.events getter）。
-// v1.7.0 特性3（投影去噪）：user 侧排除【注入类消息】，只留真实用户对话。
-// 旧实现只看事件类型不看 source，导致首轮 lastSummarizedSeq 较小时把 agent-instructions
-// baseline（AGENTS.md，可达 ~19k 字符）、system-prompt 快照、skill-catalog、以及本插件
-// 自己的 E 投影全部当成"本轮对话"喂给子 agent（污染日志 + 白烧 token）。
-// 判定用【黑名单】而非白名单（fail-open）：source 存在且非 'user' 才排除——
-// 注入类消息（agent-instructions / plugin / skill-catalog / skill-invocation …）在 DSH 中
-// 必带 source.kind，故排除效果与白名单等价；而 source 缺失时保留，避免误丢真实用户请求
-// 导致子 agent 空转（与 index.mjs 的 turnBuffer 采集口径保持一致）。
-// assistant/message 与 tool/result 原样保留。
-// 导出供单测直接断言（tests/test-v1.7.0.mjs），运行时仍只在 runMemorySubagent 内调用。
-export function projectTurnMessages(session, fromSeq) {
-  const hist = [];
-  for (const e of eventsFrom(session, fromSeq)) {
-    if (!SURFACE.has(e.type)) continue;
-    const m = session.deriveEventMessage ? session.deriveEventMessage(e) : null;
-    if (!m) continue;
-    // deriveEventMessage 对 user/message 直接返回 event.data（含 source），故此处可安全读取。
-    const srcKind = m.source?.kind;
-    if (e.type === "user/message" && srcKind && srcKind !== "user") continue;
-    hist.push(m);
-  }
-  return hist;
-}
-
-// 今日日志回喂正文：≤ subagentLogBudget 全文；超出仅章节目录（标题 + 条目数 + 首条），
-// 由子 agent 用 log_read_section 按需拉取（定案）。空日志（跨零点新一天）明确告知。
-function buildLogBlock(dir, budget) {
-  const file = join(dir, `${todayISO()}.md`);
-  const text = readMdSync(file);
-  if (!text) {
-    return { file, oversized: false, body: "（今日日志为空——新的一天，直接用 append/new_section 建章节写入即可。）" };
-  }
-  if (text.length <= budget) {
-    return { file, oversized: false, body: text };
-  }
-  const { sections } = parseSections(text);
-  const toc = sections
-    .map((s) => {
-      const items = s.lines.slice(1).filter((l) => l.trim());
-      const first = items[0]?.trim().slice(0, 80) || "";
-      return `- ${s.title}（${items.length} 条，首条：${first}）`;
-    })
-    .join("\n");
-  return {
-    file,
-    oversized: true,
-    body:
-      `（日志过大（${text.length} 字符），以下仅目录；需要某章节完整内容时调用 log_read_section 读取）\n${toc}`,
-  };
-}
-
-// 循环内工具执行：仅两个白名单工具，其余一律报错（模型越权时结果回喂 isError，不中断循环）。
-async function execLoopTool(block, logFiles, cfg) {
-  const name = block.name;
-  let args = {};
-  try {
-    args = JSON.parse(block.arguments || "{}");
-  } catch {
-    return { ok: false, message: "工具参数不是合法 JSON。" };
-  }
-  try {
-    if (name === "log_read_section") {
-      // v1.6.0 A 改进：一次读取多个章节（sections 数组），合并返回；兼容旧单数 section 参数。
-      const file = logFiles[0];
-      const md = readMdSync(file) || "";
-      const wants = Array.isArray(args.sections)
-        ? args.sections.filter((s) => s && typeof s === "string")
-        : args.section
-          ? [args.section]
-          : [];
-      if (!wants.length) return { ok: false, message: "sections 不能为空（数组，可一次传多个章节标题）。" };
-      const parts = [];
-      const missing = [];
-      for (const s of wants) {
-        const loc = locateSection(md, String(s).trim());
-        if (!loc) {
-          missing.push(String(s).trim());
-          continue;
-        }
-        parts.push(loc.lines.slice(loc.start, loc.end).join("\n").trim());
-      }
-      if (!parts.length) {
-        return { ok: false, message: `未找到章节：${missing.join("、")}。可用章节：${parseSections(md).sections.map((s) => s.title).join("、") || "（日志为空）"}` };
-      }
-      const note = missing.length ? `\n\n（以下章节未找到：${missing.join("、")}）` : "";
-      return { ok: true, content: parts.join("\n\n---\n\n") + note };
-    }
-    if (name === "log_write_ops") {
-      const ops = Array.isArray(args.ops) ? args.ops : [];
-      if (!ops.length) return { ok: false, message: "ops 为空。" };
-      return await applyLogOps(logFiles, todayISO(), ops);
-    }
-    return {
-      ok: false,
-      unknown: true,
-      name,
-      message:
-        `工具 ${name} 不存在，调用已拒绝。本环境仅提供两个工具：\n` +
-        `- log_write_ops：写入今日日志（ops 数组，支持 append / new_section / mark_delete）\n` +
-        `- log_read_section：读取今日日志中指定章节（sections 数组）\n` +
-        `请立即改用 log_write_ops 提交 ops 完成本轮写入；不要调用其他工具，也不要直接结束。`,
-    };
-  } catch (e) {
-    return { ok: false, message: `执行失败：${e?.message || String(e)}` };
-  }
-}
-
-// 把 ops 序列应用到每个日志文件（读-改-写，经全局写锁串行化）。op → sections 纯函数：
-// append=upsert（存在追加/不存在新增章节，"不强行匹配"）、new_section=已存在拒绝、
-// mark_delete=删除线墓碑（结构行保护）。
-function applyLogOps(logFiles, dateStr, ops) {
-  const apply = (md) => {
-    let cur = md || "";
-    const results = [];
-    for (const op of ops) {
-      if (!op || typeof op !== "object") {
-        results.push({ op: "invalid", ok: false, message: "op 非对象" });
-        continue;
-      }
-      const section = String(op.section ?? "").trim();
-      if (!section) {
-        results.push({ op: op.op, ok: false, message: "section 不能为空" });
-        continue;
-      }
-      if (op.op === "append") {
-        const r = upsertSectionText(cur, section, op.entry);
-        results.push({ op: "append", section, ok: r.ok, message: r.reason });
-        if (r.ok) cur = r.text;
-      } else if (op.op === "new_section") {
-        const r = createSectionText(cur, section, op.entry);
-        results.push({ op: "new_section", section, ok: r.ok, message: r.reason });
-        if (r.ok) cur = r.text;
-      } else if (op.op === "mark_delete") {
-        const r = markEntryDeletedText(cur, section, op.oldText);
-        results.push({ op: "mark_delete", section, ok: r.ok, message: r.reason });
-        if (r.ok && r.text !== undefined) cur = r.text;
-      } else {
-        results.push({ op: op.op, ok: false, message: "未知 op（仅 append/new_section/mark_delete）" });
-      }
-    }
-    return { cur, results };
-  };
-  return withLogLock(logFiles[0], async () => {
-    const all = [];
-    for (const file of logFiles) {
-      let md = "";
-      try {
-        md = readFileSync(file, "utf8");
-      } catch { /* 文件尚不存在 */ }
-      const { cur, results } = apply(md);
-      // v1.7.0 特性4：落盘前确保文件头为规范 `# YYYY-MM-DD`（空文件/首行空/直接以 ## 开头
-      // 三种形态都会补上；已有同日标题则原样）。仅在写入时补齐，不回填历史文件。
-      const withHeader = ensureLogHeader(cur, dateStr);
-      if (withHeader !== md) {
-        await mkdir(dirname(file), { recursive: true });
-        await writeFile(file, withHeader, "utf8");
-      }
-      all.push(...results);
-    }
-    const applied = all.filter((r) => r.ok).length;
-    return { ok: true, applied, total: all.length, results: all, date: dateStr };
-  });
-}
-
-// 记忆子 agent 主入口。每轮必跑（定案：不走闸门）；plan 模式拦截由调用方（index.mjs _settle）负责。
-// 返回 { ok, mode }：mode = "noop"（无重点收尾）| "written"（有落盘）| "no-tool-support"；
-// ok=false 表示整体失败（不推进断点、下一次 turn/end 自动补蒸；不降级为任何轻量写入）。
-export async function runMemorySubagent({ ctx, getConfig, paths, state, session, dirs, isError }) {
-  const cfg = getConfig();
-  // 调试日志（v1.6.0）：与 distill.mjs 同款门控。dbgFail=失败/跳过留痕（无条件输出，排障可观测）；
-  // dbg=受 distillDebugLog 开关控制的详单（模型解析/请求参数/流进度/ops 结果计数）。
-  // 隐私红线：只打计数/字符数/元数据/错误 message，绝不打印对话或日志正文文本。
-  const dbgFail = (why, extra) => console.error(`[memory-palace] subagent warn: ${why}`, extra ? JSON.stringify(extra) : "");
-  const dbg = (why, extra) => { if (!cfg.distillDebugLog) return; console.error(`[memory-palace][debug] subagent ${why}`, extra !== undefined ? JSON.stringify(extra) : ""); };
-  if (!cfg.enabled || !session || !dirs.length) {
-    dbgFail("disabled or no session/dirs", { enabled: !!cfg.enabled, hasSession: !!session, dirs: dirs.length });
-    return { ok: false, mode: "disabled" };
-  }
-  const resolved = await resolveModel(cfg, ctx, session);
-  if (!resolved) {
-    dbgFail("no model", { summaryModel: cfg.summaryModel });
-    return { ok: false, mode: "no-model" };
-  }
-  const { provider, model } = resolved;
-  dbg("entry", { sessionId: session.id, fromSeq: state.lastSummarizedSeq, provider, model });
-
-  const hist = projectTurnMessages(session, state.lastSummarizedSeq);
-  if (!hist.length) {
-    dbg("no events in range", { fromSeq: state.lastSummarizedSeq });
-    return { ok: true, mode: "noop" };
-  }
-
-  const log = buildLogBlock(dirs[0], cfg.subagentLogBudget || 20000);
-  const logFiles = dirs.map((dir) => join(dir, `${todayISO()}.md`));
-  dbg("log feed", { file: log.file, oversized: log.oversized, chars: log.body.length, logFiles: logFiles.length });
-
-  // 首轮 user 消息：本轮对话已在 hist 中逐条保留，末尾追加日志回喂 + 任务指令。
-  const brief = isError ? "\n\n（提示：本轮对话中出现过错误信号，错误现象值得记录。）" : "";
-  const kickoff = createUserMessage({
-    content: [
-      {
-        type: "text",
-        text:
-          `【今日工作日志（${todayISO()}）】\n${log.body}\n\n` +
-          `请按系统指令处理上面的本轮对话（对话见前文消息）：判定是否有实质内容需要写入日志，并执行。${brief}`,
-      },
-    ],
-    source: { kind: "plugin:dsh-memory-palace" },
-  });
-
-  const tools = [
-    {
-      name: "log_read_section",
-      description:
-        "读取今日工作日志中指定章节的完整内容（含标题行与全部条目）。sections 接受数组，可一次读取多个章节（合并返回，未找到的章节会注明）——需要多个章节时务必在单次调用中全部传入，避免多轮往返。仅在回喂为目录模式（日志过大）时需要调用；全文回喂时无需调用。",
-      parameters: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          sections: {
-            type: "array",
-            description: "要读取的章节标题列表（不含 `## ` 前缀），可一次传多个。",
-            items: { type: "string" },
-          },
-        },
-        required: ["sections"],
-      },
-    },
-    {
-      name: "log_write_ops",
-      description:
-        "批量写入今日工作日志（只能操作今日日志）。ops 数组，每个元素：\n" +
-        '- {"op":"append","section":"章节名","entry":"条目文本（一行，结论先行+关键细节，【不带 - 前缀】——插件会自动补）"}：章节存在则末尾追加，不存在则自动新增章节（不要强行匹配语义不符的章节）；\n' +
-        '- {"op":"new_section","section":"新章节名","entry":"首条条目（不带 - 前缀）"}：显式新建章节（已存在会拒绝，改用 append）；\n' +
-        '- {"op":"mark_delete","section":"章节名","oldText":"日志中该条目原文（可带或不带 - 前缀）"}：把重复/过时/被推翻的旧条目标记为删除线墓碑（非物理删除），oldText 逐行匹配，匹配失败会被拒绝；\n' +
-        "一条消息可带多个 ops 一次提交；entry 为客观第三人称单行文本（不带列表符），禁止对话体与任何标签。",
-      parameters: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          ops: {
-            type: "array",
-            description: "日志写操作数组（见 description）。",
-            items: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                op: { type: "string", description: "append | new_section | mark_delete" },
-                section: { type: "string", description: "章节标题（不含 ## 前缀）。" },
-                entry: { type: "string", description: "append/new_section 的条目文本（一行）。" },
-                oldText: { type: "string", description: "mark_delete 的目标条目原文。" },
-              },
-              required: ["op", "section"],
-            },
-          },
-        },
-        required: ["ops"],
-      },
-    },
-  ];
-
-  const system = SUBAGENT_SYSTEM();
-  const messages = [...hist, kickoff];
-  const timeoutMs = cfg.summaryTimeoutMs || 60000;
-
-  try {
-    // v1.6.3：本轮工具执行统计——appliedWrites=成功落盘 ops 数、toolAttempts=调用过工具次数、
-    // unknownHits/unknownNames=误调未知工具次数与点名（供 stop 三态判定与催促重试文案）。
-    let appliedWrites = 0;
-    let toolAttempts = 0;
-    let unknownHits = 0;
-    let retries = 0;
-    const unknownNames = new Set();
-    for (let round = 0; round < MAX_ROUNDS; round++) {
-      const { finish, asm } = await streamTurn(ctx, { provider, model, system, messages, tools }, timeoutMs);
-      if (finish.kind === "stop") {
-        // v1.6.3 stop 三态判定（修复：误调未知工具后模型直接收尾 → 日志丢失且断点被无脑推进）。
-        // ① 有落盘 → 正常完成，推进断点。
-        if (appliedWrites > 0) {
-          state.lastSummarizedSeq = session.seq;
-          dbg("done", { round, mode: "written", appliedWrites });
-          return { ok: true, mode: "written" };
-        }
-        // ② 从未调用任何工具 → 模型判定本轮无实质内容（noop），推进断点。
-        if (toolAttempts === 0) {
-          state.lastSummarizedSeq = session.seq;
-          dbg("done", { round, mode: "noop" });
-          return { ok: true, mode: "noop" };
-        }
-        // ③ 命中过未知工具且零写入 → 回告工具清单 + 催促重试（预算 MAX_RETRY 次）。
-        if (unknownHits > 0 && retries < MAX_RETRY) {
-          retries++;
-          const names = [...unknownNames].join("、");
-          messages.push(createUserMessage({
-            content: [{ type: "text", text:
-              `你刚才调用了不存在的工具（${names}），且尚未向日志写入任何内容，任务未完成。\n` +
-              `本轮唯一可用的写入工具是 log_write_ops（ops 支持 append / new_section / mark_delete）；` +
-              `需要读取章节时用 log_read_section。请立即重新提交写入。\n` +
-              `若你重新判定本轮确实没有值得记录的内容，请输出一行纯文本说明后结束。` }],
-            source: { kind: "plugin:dsh-memory-palace" },
-          }));
-          dbgFail("retry after unknown tool", { retries, names });
-          continue;
-        }
-        // ④ 重试预算耗尽 / 已知工具用错后自主放弃 → 零写入，不推进断点（下一轮 turn/end 补蒸）。
-        dbgFail("no write applied", { round, toolAttempts, unknownHits, retries });
-        return { ok: false, mode: "no-write" };
-      }
-      if (finish.kind !== "tool-calls") {
-        // max-tokens 等异常收尾：返回失败，断点不推进——下一次 turn/end 子代理自动补蒸。
-        // v1.6.0 定案：不降级为轻量原文写入（无格式原文会破坏日志章节化结构），宁缺勿滥。
-        dbgFail(`finish ${finish.kind}`, { round });
-        return { ok: false, mode: `finish-${finish.kind}` };
-      }
-      messages.push(asm.message({ kind: "model", provider, model }));
-      const calls = asm.blocks().filter((b) => b.type === "tool-call");
-      dbg("tool-calls round", { round, calls: calls.length, names: calls.map((c) => c.name) });
-      for (const call of calls) {
-        toolAttempts++;
-        const result = await execLoopTool(call, logFiles, cfg);
-        if (result.unknown) {
-          unknownHits++;
-          unknownNames.add(call.name);
-        }
-        if (result.ok && result.applied > 0) appliedWrites += result.applied;
-        const body = result.ok && result.content !== undefined ? String(result.content) : JSON.stringify(result);
-        messages.push(
-          createToolResultMessage({
-            callId: call.id,
-            content: [{ type: "text", text: body }],
-            isError: !result.ok,
-          }),
-        );
-        if (!result.ok) dbgFail(`tool ${call.name} rejected`, { message: result.message, opApplied: result.applied });
-        else dbg("tool ok", { name: call.name, applied: result.applied, total: result.total });
-      }
-    }
-    dbgFail("max-rounds exceeded", { rounds: MAX_ROUNDS });
-    return { ok: false, mode: "max-rounds" };
-  } catch (e) {
-    if (e?.name === "TimeoutError" || /timeout|abort/i.test(String(e?.message))) {
-      dbgFail("timeout", { timeoutMs });
-      return { ok: false, mode: "timeout" };
-    }
-    dbgFail("error", { message: e?.message || String(e) });
-    return { ok: false, mode: "error", message: e?.message || String(e) };
-  }
-}
+// memory-palace v1.6.0 hybrid 模式：记忆子 agent（turn/end 触发的轻量工具循环）。
+// 职责（定案）：每轮必跑，判定+产出一体——无重点纯文本收尾（1 次调用）；有重点通过循环内
+// 白名单工具把格式化摘要写入今日工作日志（2-5 次调用）。只操作今日日志，三种操作：
+// 新增章节 / 章节内追加 / 标记删除（~~删除线~~ 墓碑），禁止覆盖整文件与物理删除。
+// 架构依据（v1.6.0 调研）：ctx.llm.stream 支持 GenerateOptions.tools，finish.kind ===
+// 'tool-calls' 时用 BlockAssembler.message() 回喂 assistant 消息 + createToolResultMessage
+// 回喂工具结果，自建循环；ctx.subagents 需活 Agent 作父，插件不可用。
+import { readFileSync } from "node:fs";
+import { writeFile, mkdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { BlockAssembler, createUserMessage, createToolResultMessage } from "@deepseek-ai/dsh-llm";
+import { todayISO, readMdSync } from "../common/text.mjs";
+import { eventsFrom } from "../common/session.mjs";
+import { appendToSectionText, upsertSectionText, createSectionText, markEntryDeletedText, parseSections, locateSection, ensureLogHeader } from "../common/sections.mjs";
+import { HYBRID_PROACTIVE, SUBAGENT_SYSTEM } from "./prompts.mjs";
+
+export { HYBRID_PROACTIVE };
+
+const MAX_ROUNDS = 6; // 循环轮次上限（含首轮）；超限降级
+const MAX_RETRY = 3;  // 未知工具触发的催促重试预算（v1.6.3 定为 3）
+const SURFACE = new Set(["user/message", "assistant/message", "tool/result"]);
+
+// 日志文件写锁（全局 promise 链串行化）：子 agent 落盘与手动蒸馏按钮/其他写路径并发防护。
+let logWriteChain = Promise.resolve();
+function withLogLock(file, fn) {
+  const run = logWriteChain.then(fn, fn);
+  logWriteChain = run.catch(() => {});
+  return run;
+}
+
+// 模型解析（与 distill.mjs resolveModel 同逻辑，改动须两处同步）：summaryModel 注册表反查
+// > 前缀兜底 > 会话 requestHeader 兜底。复制而非导出原因：hybrid 走独立模块定案，不碰 distill。
+async function resolveModel(cfg, ctx, session) {
+  const sm = (cfg.summaryModel || "").trim();
+  if (sm) {
+    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 === sm);
+          if (m) return { provider: m.provider, model: m.id };
+        } catch { /* 该 provider 无模型列表，跳过 */ }
+      }
+      const provider = sm.split("/")[0].trim();
+      if (provider && sm.includes("/")) return { provider, model: sm };
+    } catch { /* 注册表不可用，走会话兜底 */ }
+  }
+  const conf = session?.requestHeader?.()?.config;
+  if (conf && conf.provider && conf.model) return { provider: conf.provider, model: conf.model };
+  return null;
+}
+
+// 单次流式调用（带 tools）。finish.kind 为 error/aborted 时抛出由上层降级；tool-calls/stop 正常返回。
+async function streamTurn(ctx, params, timeoutMs) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  const res = ctx.llm.stream({ ...params, signal });
+  const asm = new BlockAssembler();
+  for await (const ch of res) {
+    signal.throwIfAborted();
+    asm.push(ch);
+  }
+  const finish = asm.finish;
+  if (finish.kind === "error" || finish.kind === "aborted") {
+    throw new Error(finish.failure?.message || finish.kind);
+  }
+  return { finish, asm };
+}
+
+// 把本轮 surface 事件投影为消息数组（seq >= fromSeq；与 distillSessionCore 同源逻辑）。
+// v1.6.2-alpha.4：eventsFrom 兼容层（宿主 0.1.2-alpha.4 删除 Session.events getter）。
+// v1.7.0 特性3（投影去噪）：user 侧排除【注入类消息】，只留真实用户对话。
+// 旧实现只看事件类型不看 source，导致首轮 lastSummarizedSeq 较小时把 agent-instructions
+// baseline（AGENTS.md，可达 ~19k 字符）、system-prompt 快照、skill-catalog、以及本插件
+// 自己的 E 投影全部当成"本轮对话"喂给子 agent（污染日志 + 白烧 token）。
+// 判定用【黑名单】而非白名单（fail-open）：source 存在且非 'user' 才排除——
+// 注入类消息（agent-instructions / plugin / skill-catalog / skill-invocation …）在 DSH 中
+// 必带 source.kind，故排除效果与白名单等价；而 source 缺失时保留，避免误丢真实用户请求
+// 导致子 agent 空转（与 index.mjs 的 turnBuffer 采集口径保持一致）。
+// assistant/message 与 tool/result 原样保留。
+// 导出供单测直接断言（tests/test-v1.7.0.mjs），运行时仍只在 runMemorySubagent 内调用。
+export function projectTurnMessages(session, fromSeq) {
+  const hist = [];
+  for (const e of eventsFrom(session, fromSeq)) {
+    if (!SURFACE.has(e.type)) continue;
+    const m = session.deriveEventMessage ? session.deriveEventMessage(e) : null;
+    if (!m) continue;
+    // deriveEventMessage 对 user/message 直接返回 event.data（含 source），故此处可安全读取。
+    const srcKind = m.source?.kind;
+    if (e.type === "user/message" && srcKind && srcKind !== "user") continue;
+    hist.push(m);
+  }
+  return hist;
+}
+
+// 今日日志回喂正文：≤ subagentLogBudget 全文；超出仅章节目录（标题 + 条目数 + 首条），
+// 由子 agent 用 log_read_section 按需拉取（定案）。空日志（跨零点新一天）明确告知。
+function buildLogBlock(dir, budget) {
+  const file = join(dir, `${todayISO()}.md`);
+  const text = readMdSync(file);
+  if (!text) {
+    return { file, oversized: false, body: "（今日日志为空——新的一天，直接用 append/new_section 建章节写入即可。）" };
+  }
+  if (text.length <= budget) {
+    return { file, oversized: false, body: text };
+  }
+  const { sections } = parseSections(text);
+  const toc = sections
+    .map((s) => {
+      const items = s.lines.slice(1).filter((l) => l.trim());
+      const first = items[0]?.trim().slice(0, 80) || "";
+      return `- ${s.title}（${items.length} 条，首条：${first}）`;
+    })
+    .join("\n");
+  return {
+    file,
+    oversized: true,
+    body:
+      `（日志过大（${text.length} 字符），以下仅目录；需要某章节完整内容时调用 log_read_section 读取）\n${toc}`,
+  };
+}
+
+// 循环内工具执行：仅两个白名单工具，其余一律报错（模型越权时结果回喂 isError，不中断循环）。
+async function execLoopTool(block, logFiles, cfg) {
+  const name = block.name;
+  let args = {};
+  try {
+    args = JSON.parse(block.arguments || "{}");
+  } catch {
+    return { ok: false, message: "工具参数不是合法 JSON。" };
+  }
+  try {
+    if (name === "log_read_section") {
+      // v1.6.0 A 改进：一次读取多个章节（sections 数组），合并返回；兼容旧单数 section 参数。
+      const file = logFiles[0];
+      const md = readMdSync(file) || "";
+      const wants = Array.isArray(args.sections)
+        ? args.sections.filter((s) => s && typeof s === "string")
+        : args.section
+          ? [args.section]
+          : [];
+      if (!wants.length) return { ok: false, message: "sections 不能为空（数组，可一次传多个章节标题）。" };
+      const parts = [];
+      const missing = [];
+      for (const s of wants) {
+        const loc = locateSection(md, String(s).trim());
+        if (!loc) {
+          missing.push(String(s).trim());
+          continue;
+        }
+        parts.push(loc.lines.slice(loc.start, loc.end).join("\n").trim());
+      }
+      if (!parts.length) {
+        return { ok: false, message: `未找到章节：${missing.join("、")}。可用章节：${parseSections(md).sections.map((s) => s.title).join("、") || "（日志为空）"}` };
+      }
+      const note = missing.length ? `\n\n（以下章节未找到：${missing.join("、")}）` : "";
+      return { ok: true, content: parts.join("\n\n---\n\n") + note };
+    }
+    if (name === "log_write_ops") {
+      const ops = Array.isArray(args.ops) ? args.ops : [];
+      if (!ops.length) return { ok: false, message: "ops 为空。" };
+      return await applyLogOps(logFiles, todayISO(), ops);
+    }
+    return {
+      ok: false,
+      unknown: true,
+      name,
+      message:
+        `工具 ${name} 不存在，调用已拒绝。本环境仅提供两个工具：\n` +
+        `- log_write_ops：写入今日日志（ops 数组，支持 append / new_section / mark_delete）\n` +
+        `- log_read_section：读取今日日志中指定章节（sections 数组）\n` +
+        `请立即改用 log_write_ops 提交 ops 完成本轮写入；不要调用其他工具，也不要直接结束。`,
+    };
+  } catch (e) {
+    return { ok: false, message: `执行失败：${e?.message || String(e)}` };
+  }
+}
+
+// 把 ops 序列应用到每个日志文件（读-改-写，经全局写锁串行化）。op → sections 纯函数：
+// append=upsert（存在追加/不存在新增章节，"不强行匹配"）、new_section=已存在拒绝、
+// mark_delete=删除线墓碑（结构行保护）。
+function applyLogOps(logFiles, dateStr, ops) {
+  const apply = (md) => {
+    let cur = md || "";
+    const results = [];
+    for (const op of ops) {
+      if (!op || typeof op !== "object") {
+        results.push({ op: "invalid", ok: false, message: "op 非对象" });
+        continue;
+      }
+      const section = String(op.section ?? "").trim();
+      if (!section) {
+        results.push({ op: op.op, ok: false, message: "section 不能为空" });
+        continue;
+      }
+      if (op.op === "append") {
+        const r = upsertSectionText(cur, section, op.entry);
+        results.push({ op: "append", section, ok: r.ok, message: r.reason });
+        if (r.ok) cur = r.text;
+      } else if (op.op === "new_section") {
+        const r = createSectionText(cur, section, op.entry);
+        results.push({ op: "new_section", section, ok: r.ok, message: r.reason });
+        if (r.ok) cur = r.text;
+      } else if (op.op === "mark_delete") {
+        const r = markEntryDeletedText(cur, section, op.oldText);
+        results.push({ op: "mark_delete", section, ok: r.ok, message: r.reason });
+        if (r.ok && r.text !== undefined) cur = r.text;
+      } else {
+        results.push({ op: op.op, ok: false, message: "未知 op（仅 append/new_section/mark_delete）" });
+      }
+    }
+    return { cur, results };
+  };
+  return withLogLock(logFiles[0], async () => {
+    const all = [];
+    for (const file of logFiles) {
+      let md = "";
+      try {
+        md = readFileSync(file, "utf8");
+      } catch { /* 文件尚不存在 */ }
+      const { cur, results } = apply(md);
+      // v1.7.0 特性4：落盘前确保文件头为规范 `# YYYY-MM-DD`（空文件/首行空/直接以 ## 开头
+      // 三种形态都会补上；已有同日标题则原样）。仅在写入时补齐，不回填历史文件。
+      const withHeader = ensureLogHeader(cur, dateStr);
+      if (withHeader !== md) {
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, withHeader, "utf8");
+      }
+      all.push(...results);
+    }
+    const applied = all.filter((r) => r.ok).length;
+    return { ok: true, applied, total: all.length, results: all, date: dateStr };
+  });
+}
+
+// 记忆子 agent 主入口。每轮必跑（定案：不走闸门）；plan 模式拦截由调用方（index.mjs _settle）负责。
+// 返回 { ok, mode }：mode = "noop"（无重点收尾）| "written"（有落盘）| "no-tool-support"；
+// ok=false 表示整体失败（不推进断点、下一次 turn/end 自动补蒸；不降级为任何轻量写入）。
+export async function runMemorySubagent({ ctx, getConfig, paths, state, session, dirs, isError, getSeq, setSeq }) {
+  const cfg = getConfig();
+  // 增量断点按会话取用：调用方（index.mjs）注入 getSeq/setSeq（按 sessionId 分桶）。
+  // 未注入时回落全局 state.lastSummarizedSeq，保持旧行为与向后兼容。
+  const readSeq = typeof getSeq === "function" ? getSeq : () => state.lastSummarizedSeq;
+  const writeSeq = typeof setSeq === "function" ? setSeq : (v) => { state.lastSummarizedSeq = v; };
+  // 调试日志（v1.6.0）：与 distill.mjs 同款门控。dbgFail=失败/跳过留痕（无条件输出，排障可观测）；
+  // dbg=受 distillDebugLog 开关控制的详单（模型解析/请求参数/流进度/ops 结果计数）。
+  // 隐私红线：只打计数/字符数/元数据/错误 message，绝不打印对话或日志正文文本。
+  const dbgFail = (why, extra) => console.error(`[memory-palace] subagent warn: ${why}`, extra ? JSON.stringify(extra) : "");
+  const dbg = (why, extra) => { if (!cfg.distillDebugLog) return; console.error(`[memory-palace][debug] subagent ${why}`, extra !== undefined ? JSON.stringify(extra) : ""); };
+  if (!cfg.enabled || !session || !dirs.length) {
+    dbgFail("disabled or no session/dirs", { enabled: !!cfg.enabled, hasSession: !!session, dirs: dirs.length });
+    return { ok: false, mode: "disabled" };
+  }
+  const resolved = await resolveModel(cfg, ctx, session);
+  if (!resolved) {
+    dbgFail("no model", { summaryModel: cfg.summaryModel });
+    return { ok: false, mode: "no-model" };
+  }
+  const { provider, model } = resolved;
+  dbg("entry", { sessionId: session.id, fromSeq: readSeq(), provider, model });
+
+  const hist = projectTurnMessages(session, readSeq());
+  if (!hist.length) {
+    dbg("no events in range", { fromSeq: readSeq() });
+    return { ok: true, mode: "noop" };
+  }
+
+  const log = buildLogBlock(dirs[0], cfg.subagentLogBudget || 20000);
+  const logFiles = dirs.map((dir) => join(dir, `${todayISO()}.md`));
+  dbg("log feed", { file: log.file, oversized: log.oversized, chars: log.body.length, logFiles: logFiles.length });
+
+  // 首轮 user 消息：本轮对话已在 hist 中逐条保留，末尾追加日志回喂 + 任务指令。
+  const brief = isError ? "\n\n（提示：本轮对话中出现过错误信号，错误现象值得记录。）" : "";
+  const kickoff = createUserMessage({
+    content: [
+      {
+        type: "text",
+        text:
+          `【今日工作日志（${todayISO()}）】\n${log.body}\n\n` +
+          `请按系统指令处理上面的本轮对话（对话见前文消息）：判定是否有实质内容需要写入日志，并执行。${brief}`,
+      },
+    ],
+    source: { kind: "plugin:dsh-memory-palace" },
+  });
+
+  const tools = [
+    {
+      name: "log_read_section",
+      description:
+        "读取今日工作日志中指定章节的完整内容（含标题行与全部条目）。sections 接受数组，可一次读取多个章节（合并返回，未找到的章节会注明）——需要多个章节时务必在单次调用中全部传入，避免多轮往返。仅在回喂为目录模式（日志过大）时需要调用；全文回喂时无需调用。",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          sections: {
+            type: "array",
+            description: "要读取的章节标题列表（不含 `## ` 前缀），可一次传多个。",
+            items: { type: "string" },
+          },
+        },
+        required: ["sections"],
+      },
+    },
+    {
+      name: "log_write_ops",
+      description:
+        "批量写入今日工作日志（只能操作今日日志）。ops 数组，每个元素：\n" +
+        '- {"op":"append","section":"章节名","entry":"条目文本（一行，结论先行+关键细节，【不带 - 前缀】——插件会自动补）"}：章节存在则末尾追加，不存在则自动新增章节（不要强行匹配语义不符的章节）；\n' +
+        '- {"op":"new_section","section":"新章节名","entry":"首条条目（不带 - 前缀）"}：显式新建章节（已存在会拒绝，改用 append）；\n' +
+        '- {"op":"mark_delete","section":"章节名","oldText":"日志中该条目原文（可带或不带 - 前缀）"}：把重复/过时/被推翻的旧条目标记为删除线墓碑（非物理删除），oldText 逐行匹配，匹配失败会被拒绝；\n' +
+        "一条消息可带多个 ops 一次提交；entry 为客观第三人称单行文本（不带列表符），禁止对话体与任何标签。",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          ops: {
+            type: "array",
+            description: "日志写操作数组（见 description）。",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                op: { type: "string", description: "append | new_section | mark_delete" },
+                section: { type: "string", description: "章节标题（不含 ## 前缀）。" },
+                entry: { type: "string", description: "append/new_section 的条目文本（一行）。" },
+                oldText: { type: "string", description: "mark_delete 的目标条目原文。" },
+              },
+              required: ["op", "section"],
+            },
+          },
+        },
+        required: ["ops"],
+      },
+    },
+  ];
+
+  const system = SUBAGENT_SYSTEM();
+  const messages = [...hist, kickoff];
+  const timeoutMs = cfg.summaryTimeoutMs || 60000;
+
+  try {
+    // v1.6.3：本轮工具执行统计——appliedWrites=成功落盘 ops 数、toolAttempts=调用过工具次数、
+    // unknownHits/unknownNames=误调未知工具次数与点名（供 stop 三态判定与催促重试文案）。
+    let appliedWrites = 0;
+    let toolAttempts = 0;
+    let unknownHits = 0;
+    let retries = 0;
+    const unknownNames = new Set();
+    for (let round = 0; round < MAX_ROUNDS; round++) {
+      const { finish, asm } = await streamTurn(ctx, { provider, model, system, messages, tools }, timeoutMs);
+      if (finish.kind === "stop") {
+        // v1.6.3 stop 三态判定（修复：误调未知工具后模型直接收尾 → 日志丢失且断点被无脑推进）。
+        // ① 有落盘 → 正常完成，推进断点。
+        if (appliedWrites > 0) {
+          writeSeq(session.seq);
+          dbg("done", { round, mode: "written", appliedWrites });
+          return { ok: true, mode: "written" };
+        }
+        // ② 从未调用任何工具 → 模型判定本轮无实质内容（noop），推进断点。
+        if (toolAttempts === 0) {
+          writeSeq(session.seq);
+          dbg("done", { round, mode: "noop" });
+          return { ok: true, mode: "noop" };
+        }
+        // ③ 命中过未知工具且零写入 → 回告工具清单 + 催促重试（预算 MAX_RETRY 次）。
+        if (unknownHits > 0 && retries < MAX_RETRY) {
+          retries++;
+          const names = [...unknownNames].join("、");
+          messages.push(createUserMessage({
+            content: [{ type: "text", text:
+              `你刚才调用了不存在的工具（${names}），且尚未向日志写入任何内容，任务未完成。\n` +
+              `本轮唯一可用的写入工具是 log_write_ops（ops 支持 append / new_section / mark_delete）；` +
+              `需要读取章节时用 log_read_section。请立即重新提交写入。\n` +
+              `若你重新判定本轮确实没有值得记录的内容，请输出一行纯文本说明后结束。` }],
+            source: { kind: "plugin:dsh-memory-palace" },
+          }));
+          dbgFail("retry after unknown tool", { retries, names });
+          continue;
+        }
+        // ④ 重试预算耗尽 / 已知工具用错后自主放弃 → 零写入，不推进断点（下一轮 turn/end 补蒸）。
+        dbgFail("no write applied", { round, toolAttempts, unknownHits, retries });
+        return { ok: false, mode: "no-write" };
+      }
+      if (finish.kind !== "tool-calls") {
+        // max-tokens 等异常收尾：返回失败，断点不推进——下一次 turn/end 子代理自动补蒸。
+        // v1.6.0 定案：不降级为轻量原文写入（无格式原文会破坏日志章节化结构），宁缺勿滥。
+        dbgFail(`finish ${finish.kind}`, { round });
+        return { ok: false, mode: `finish-${finish.kind}` };
+      }
+      messages.push(asm.message({ kind: "model", provider, model }));
+      const calls = asm.blocks().filter((b) => b.type === "tool-call");
+      dbg("tool-calls round", { round, calls: calls.length, names: calls.map((c) => c.name) });
+      for (const call of calls) {
+        toolAttempts++;
+        const result = await execLoopTool(call, logFiles, cfg);
+        if (result.unknown) {
+          unknownHits++;
+          unknownNames.add(call.name);
+        }
+        if (result.ok && result.applied > 0) appliedWrites += result.applied;
+        const body = result.ok && result.content !== undefined ? String(result.content) : JSON.stringify(result);
+        messages.push(
+          createToolResultMessage({
+            callId: call.id,
+            content: [{ type: "text", text: body }],
+            isError: !result.ok,
+          }),
+        );
+        if (!result.ok) dbgFail(`tool ${call.name} rejected`, { message: result.message, opApplied: result.applied });
+        else dbg("tool ok", { name: call.name, applied: result.applied, total: result.total });
+      }
+    }
+    dbgFail("max-rounds exceeded", { rounds: MAX_ROUNDS });
+    return { ok: false, mode: "max-rounds" };
+  } catch (e) {
+    if (e?.name === "TimeoutError" || /timeout|abort/i.test(String(e?.message))) {
+      dbgFail("timeout", { timeoutMs });
+      return { ok: false, mode: "timeout" };
+    }
+    dbgFail("error", { message: e?.message || String(e) });
+    return { ok: false, mode: "error", message: e?.message || String(e) };
+  }
+}

package/lib/hybrid/tools.mjs

@@ -11,6 +11,7 @@ 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";
+import { planModeOf } from "../common/planmode.mjs";
 
 const REORG_MARK = "memory-palace:last-reorg:";
 const REORG_MARK_RE = new RegExp(`\\n?<!--\\s*${REORG_MARK}[^>]*-->\\s*$`);
@@ -315,7 +316,8 @@ export function attachHybridGuards(ctx, getConfig, paths, state) {
   ctx.on("tools/pre-execute", async (exec, next) => {
     const name = exec?.name;
     if (!HYBRID_WRITE_TOOLS.has(name)) return next();
-    if (state.planModeActive) {
+    // 按**会话**判定（plan 模式是会话级状态，见 common/planmode.mjs）——别的会话进 plan 不该 deny 本会话
+    if (planModeOf(state, exec?.agent?.session)) {
       return { kind: "deny", reason: "plan 模式下禁止写入记忆" };
     }
     if (name !== "memory_reorganize") return next();

package/lib/index.js

@@ -30,6 +30,7 @@ import Schema from "@deepseek-ai/schemastery";
 // settingsNamespace，设置节注册改用 SettingsProvider 实例方法 installSection（经 ctx.inject(["settings"])）。
 import { extractText, extractToolErrorText } from "./common/text.mjs";
 import { createPaths } from "./common/paths.mjs";
+import { planModeOf } from "./common/planmode.mjs";
 import { createRecords } from "./common/records.mjs";
 import { createDistill } from "./distill.mjs";
 import { registerTools } from "./tools.mjs";
@@ -175,21 +176,29 @@ export function apply(ctx, config) {
   const state = {
     activeCwd: null,          // 最近活跃 session 的 cwd（session/event 更新）
     activeSession: null,      // 最近活跃 session 引用
-    turnBuffer: [],           // 每轮缓冲 {role,text}，role ∈ user/assistant/tool
-    sawErrorTurn: false,      // 跨 turn 累积的 request 级错误信号（作为 isError 传给记忆子代理）
-    settleTimer: null,        // debounce 计时器
-    // 记忆子代理的增量断点（session 事件 seq）——v1.8.0 核查确认：本字段**不是** smart 模式专属，
-    // hybrid 子代理自己用它（hybrid/subagent.mjs 读取 + 成功时推进），故保留。
-    lastSummarizedSeq: -1,
-    breakpointSessionId: null, // 断点所属会话（跨会话必须重置，见 session/event 处理）
-    planModeActive: false,    // 计划模式：禁写记忆（硬编码默认，无开关；仅经 session/event 的 plan/mode 翻转；未装 dsh-plan-mode 永不触发=不拦截）
+    // ---- 每会话状态分桶（修复：结算写入错项目）----
+    // 下面三者的语义都是「当前请求所属会话」，原实现放在进程级全局上，而 session/event 是无条件
+    // 覆盖的 → 多会话并发时必然互相污染：A 会话的内容被结算进 B 项目目录。按 sessionId 分桶后互不干扰。
+    // 被取代并删除的全局单值字段（勿再引回）：`turnBuffer` / `sawErrorTurn` / `settleTimer`
+    // 对应前三个 Map；`lastSummarizedSeq` / `breakpointSessionId` 对应 seqBySession。
+    // 注：seqBySession 是记忆子代理的**增量断点**（session 事件 seq），不是已删的 smart 模式残留
+    // ——`hybrid/subagent.mjs` 在调用方未注入 getSeq/setSeq 时仍会回落到全局 state.lastSummarizedSeq
+    // （单测 tests/test-hybrid.mjs 就走该回退路径）。
+    buffersBySession: new Map(), // sessionId -> { turnBuffer, sawErrorTurn, session }
+    settleTimers: new Map(),     // sessionId -> debounce timer
+    seqBySession: new Map(),     // sessionId -> 记忆子代理增量断点
+    // plan 模式：禁写记忆（硬编码默认，无开关）。
+    // 宿主是**会话级**状态（`session.append('plan/mode')`，见 common/planmode.mjs），故按会话记；
+    // `planModeActive` 仅作「拿不到会话上下文」时的兜底值。未装 dsh-plan-mode 则永不触发 = 不拦截。
+    planModeBySession: new Map(), // sessionId -> 该会话是否处于 plan 模式（判定优先看它）
+    planModeActive: false,        // 兜底：最近一次 plan/mode 事件的值，供拿不到会话上下文的场合使用
     // v1.7.2：会话 → agent 预设 id（仅"切换预设"事件写入；创建头另在 presetOfSession 里兜底读）。
     // 只增不减：会话结束后残留几条字符串，代价可忽略；切回同一 session 断言预设不变（宿主侧保证）。
     presetBySession: new Map(),
     // v1.7.0：injectedSessionIds 已删除——记忆正文改经 E 投影（src/projection.mjs）注入为
     // 常驻消息，compaction 后由投影自动重注，不再需要"仅首次注入"的会话级标记。
-    // v1.8.0：recentAgentWrote（原防闲聊闸门信号）与 lastSummarizedSeq / summarySessionId
-    // （原 smart 模式增量断点）随 plugin / smart 两模式一并删除。
+    // v1.8.0：recentAgentWrote（原防闲聊闸门信号）与 summarySessionId（原 smart 模式会话标记）
+    // 随 plugin / smart 两模式一并删除。
   };
   const TURN_BUFFER_MAX = 30;
   // v1.1.3：字符上限提升到 30k（长工具型 request 的工具结果动辄数千字符，6k 上限会触发
@@ -326,15 +335,29 @@ export function apply(ctx, config) {
   // 触发时 buffer 只剩残缺片段（无 user 请求、无 tool/result），工具期错误信号（extractToolErrorText）
   // 会取不到，传给记忆子代理的 isError 随之失准。
   // 结算策略：debounce（安静期后只结算一次）+ 新 user/message 时立即结算上一个 request。
+  // 取/建某会话的状态桶（sessionId 缺失时归入同一个兜底桶，保持旧行为不失效）。
+  function bucketOf(sessionId) {
+    const id = sessionId || "__nosession__";
+    let b = state.buffersBySession.get(id);
+    if (!b) {
+      b = { turnBuffer: [], sawErrorTurn: false, session: null };
+      state.buffersBySession.set(id, b);
+    }
+    return b;
+  }
+
   ctx.on("session/event", (session, event) => {
     if (session) state.activeSession = session;
     if (session?.header?.cwd) state.activeCwd = session.header.cwd;
+    const sid = session?.id || "__nosession__";
+    const bucket = bucketOf(sid);
+    if (session) bucket.session = session;
     // 切换 session 时重置记忆子代理的增量断点（新会话从 firstLiveSeq 起算）。
     // 必须做：seq 按会话独立编号，沿用上一会话的断点会让 projectTurnMessages 取到空区间 →
     // 子代理静默 noop、日志永不落盘（v1.6.0 起沿用至今；v1.8.0 核查确认此处不是 smart 残留）。
-    if (session && session.id !== state.breakpointSessionId) {
-      state.breakpointSessionId = session.id;
-      state.lastSummarizedSeq = session.firstLiveSeq;
+    // 断点同样按会话分桶：全局单值会让并发会话互相重置。
+    if (session && !state.seqBySession.has(sid)) {
+      state.seqBySession.set(sid, session.firstLiveSeq);
     }
     const type = event?.type;
     // v1.7.2：预设切换（仅空会话可切；宿主在切换提交后追加该事件）。记进 Map 供 isSessionSilent 读取。
@@ -349,13 +372,20 @@ export function apply(ctx, config) {
     }
     // 计划模式：禁写记忆（硬编码默认行为，无开关；不依赖 dsh-plan-mode 服务，未装则永不触发=安全降级=不拦截）
     if (type === "plan/mode") {
-      state.planModeActive = !!(event?.data?.active);
+      // plan 模式是**会话级**事实（宿主 `session.append('plan/mode')`）→ 必须按会话记：
+      // 用全局单值会让 A 的 plan 状态波及 B —— B 记忆不落盘 / B 的 prompt 被注入 plan 提示 / B 写工具被拒。
+      const on = !!(event?.data?.active);
+      // 兜底值【始终】跟随最近一次事件：工具闸门等拿不到会话上下文的场合靠它判定
+      // （若只在"无会话事件"时才写，兜底会恒为 false → 那些场合漏拦）。
+      state.planModeActive = on;
+      // 会话级精确记录：有会话身份时判定只看这张表（无记录 = 该会话未进 plan = false，不回落全局）。
+      if (session?.id) state.planModeBySession.set(session.id, on);
       return;
     }
     if (type === "user/message" || type === "assistant/message" || type === "tool/result") {
       // v1.7.0 特性1 连带修复：turnBuffer 只采集【真实用户消息】。
       // E 投影的 user/message（source.kind === 'plugin:dsh-memory-palace'）也在 SURFACE 里，若不过滤
-      // 会被采集进 buffer，并触发下方 `type === "user/message" && state.turnBuffer.length` 的
+      // 会被采集进 buffer，并触发下方 `type === "user/message" && bucket.turnBuffer.length` 的
       // _flushTurn() —— 打乱 request 边界、污染回喂子代理的对话内容。
       // 判定用【黑名单】而非白名单（fail-open）：只在 source 明确存在且非 'user' 时排除。
       // 理由：source 缺失时若按"非 user"丢弃，真实用户消息会被漏掉 → request 边界与错误信号全错
@@ -366,21 +396,23 @@ export function apply(ctx, config) {
       if (text) {
         const role = type === "tool/result" ? "tool" : type === "user/message" ? "user" : "assistant";
         // 新用户请求到来：先结算并清空上一个 request（若存在），避免与本请求混淆。
-        if (type === "user/message" && state.turnBuffer.length) _flushTurn();
-        state.turnBuffer.push({ role, text });
-        if (state.turnBuffer.length > TURN_BUFFER_MAX) state.turnBuffer = state.turnBuffer.slice(-TURN_BUFFER_MAX);
-        const total = state.turnBuffer.reduce((n, b) => n + b.text.length, 0);
+        // 缓冲按会话分桶：否则 A 会话的消息会混进 B 会话的结算，连同内容一起写错项目。
+        if (type === "user/message" && bucket.turnBuffer.length) _flushTurn(sid, bucket);
+        bucket.turnBuffer.push({ role, text });
+        if (bucket.turnBuffer.length > TURN_BUFFER_MAX) bucket.turnBuffer = bucket.turnBuffer.slice(-TURN_BUFFER_MAX);
+        const total = bucket.turnBuffer.reduce((n, b) => n + b.text.length, 0);
         if (total > TURN_BUFFER_CHAR_CAP) {
           // v1.1.3 修复：溢出时【保留尾部最近内容】而非替换成占位——占位会让工具期错误检测
           // （extractToolErrorText）失效，传给记忆子代理的 isError 失准、错误现象漏记。
-          state.turnBuffer = state.turnBuffer.slice(-8);
+          bucket.turnBuffer = bucket.turnBuffer.slice(-8);
         }
       }
     } else if (type === "turn/end") {
       // 累积 request 级错误信号（跨 turn 合并），供结算时统一判定并传给记忆子代理。
-      if (event?.data?.reason?.kind === "error") state.sawErrorTurn = true;
-      // 不清空 buffer；用 debounce 在整段请求安静后结算一次。
-      _scheduleSettle();
+      // 同样按会话分桶：全局标志会让 A 会话的错误把 B 会话的日志标成 isError。
+      if (event?.data?.reason?.kind === "error") bucket.sawErrorTurn = true;
+      // 不清空 buffer；用 debounce 在整段请求安静后结算一次（定时器按会话独立）。
+      _scheduleSettle(sid);
     } else if (type === "compaction" || type?.startsWith?.("compaction/")) {
       // v1.7.0：无需再清"已注入标记"（该机制已删）——记忆正文改经 E 投影注入，
       // compaction 把投影消息移出 surface 后，后续 step 的去重扫描找不到它 → 自动重注。
@@ -425,8 +457,9 @@ export function apply(ctx, config) {
           "写入记忆：项目级约定用 memory_note 工具，跨项目个人偏好用 memory_note_user 工具；读取记忆用 memory_read 工具，scope 默认 'memory'（用户级 + 项目级 MEMORY.md），需要今日/历史日志时显式传 scope:'daily' 或 'all'（不要手动 glob/read 记忆文件）。用它保持跨 session 一致性；看不到的内容不要编造。" +
           "注意：上下文中的记忆是**会话起始快照**，不随记忆文件之后的更新自动刷新；需要以当前状态为依据时（改记忆前、或据记忆作答前）用 memory_read 重读。" +
           antiMangle + proactive;
-      // 计划模式禁写提示（硬编码默认行为，无开关）：让 agent 自觉不写（网关物理兜底仍生效）
-      const planNote = state.planModeActive
+      // 计划模式禁写提示（硬编码默认行为，无开关）：让 agent 自觉不写（网关物理兜底仍生效）。
+      // 按**会话**判定：plan 模式是会话级状态，别的会话进 plan 不该往本会话 prompt 里塞这条提示。
+      const planNote = planModeOf(state, context?.agent?.session)
         ? "\n\n[plan 模式] 当前处于 plan 模式，不要调用 memory_note / memory_note_user 写入记忆，也不要请求删除记忆（读取记忆用 memory_read，仍可用）。"
         : "";
       const introFull = intro + planNote;
@@ -443,14 +476,17 @@ export function apply(ctx, config) {
   // ---------- 结算一个完整 request：交给记忆子代理写今日日志（不在此处做任何直接写入） ----------
   // v1.8.0：原「防闲聊闸门 + 轻量兜底 + 错误捕获」（plugin）、「LLM 摘要分派」（smart）
   // 与「记忆写入总开关」(summarize) 均已删除，本函数收敛为单一路径：前置闸门 → 算错误信号 → 子代理。
-  async function _settle(capturedTurn, isError) {
-    // 计划模式禁写（硬编码默认，无开关）：写入路径在此一处拦截
-    if (state.planModeActive) return;
+  async function _settle(capturedTurn, isError, sid, boundSession) {
+    // 会话身份由入参显式传入（原实现读全局 state.activeSession，多会话并发时会写到别的项目目录）。
+    // boundSession 缺失时兜底用全局，保持旧行为不失效。
+    const session = boundSession || state.activeSession;
+    // 计划模式禁写（硬编码默认，无开关）：plan 模式是**会话级**状态 → 只拦该会话本身；写入路径在此一处拦截
+    if (planModeOf(state, session)) return;
     const cfg = source();
     if (!cfg.enabled) return;
     // v1.7.2：静默会话（极简等预设）不写任何记忆——记忆子代理在此一处提前返回。
-    if (isSessionSilent(state.activeSession)) return;
-    const cwd = state.activeSession?.header?.cwd ?? null;
+    if (isSessionSilent(session)) return;
+    const cwd = session?.header?.cwd ?? null;
     const dirs = paths.writeDirs(cwd);
     if (!dirs.length) return;
 
@@ -465,26 +501,45 @@ export function apply(ctx, config) {
     // 失败【不】降级为任何轻量写入（v1.6.0 定案：无格式原文会破坏日志章节化结构）——
     // 子代理内部不推进断点，下一次 turn/end 自动补蒸。
     void hybrid
-      .runMemorySubagent({ ctx, getConfig: () => source(), paths, records, state, session: state.activeSession, dirs, isError: effectiveIsError })
+      .runMemorySubagent({
+        ctx,
+        getConfig: () => source(),
+        paths,
+        records,
+        state,
+        session,
+        dirs,
+        isError: effectiveIsError,
+        // 断点按会话分桶：全局单值在并发会话下会被互相重置，导致子代理静默 noop、日志不落盘。
+        getSeq: () => state.seqBySession.get(sid) ?? session?.firstLiveSeq ?? 0,
+        setSeq: (v) => state.seqBySession.set(sid, v),
+      })
       .catch(() => {});
   }
 
   // 立即结算并清空当前缓冲（供 debounce 到点、或收到新 user/message 时调用）。
-  function _flushTurn() {
-    const capturedTurn = state.turnBuffer;
-    const wasErrorTurn = state.sawErrorTurn;
-    state.turnBuffer = [];
-    state.sawErrorTurn = false;
+  function _flushTurn(sid, bucket) {
+    // 结算归属由入参会话决定（不再读全局 state.activeSession）。
+    const bound = bucket || bucketOf(sid);
+    const capturedTurn = bound.turnBuffer;
+    const wasErrorTurn = bound.sawErrorTurn;
+    bound.turnBuffer = [];
+    bound.sawErrorTurn = false;
     if (!capturedTurn.length) return;
-    void _settle(capturedTurn, wasErrorTurn).catch(() => {});
+    void _settle(capturedTurn, wasErrorTurn, sid, bound.session).catch(() => {});
   }
 
   // debounce：每次 turn/end 重置计时器；SETTLE_DELAY 内无新 turn/end（即整段请求安静）才结算一次。
-  function _scheduleSettle() {
-    if (state.settleTimer) clearTimeout(state.settleTimer);
-    state.settleTimer = setTimeout(() => {
-      state.settleTimer = null;
-      _flushTurn();
+  function _scheduleSettle(sid) {
+    // 每个会话独立计时：共用单一定时器时，B 的 turn/end 会把 A 的待结算 clearTimeout 掉 → A 整段丢失。
+    const id = sid || "__nosession__";
+    const prev = state.settleTimers.get(id);
+    if (prev) clearTimeout(prev);
+    const t = setTimeout(() => {
+      state.settleTimers.delete(id);
+      const bound = state.buffersBySession.get(id);
+      if (bound) _flushTurn(id, bound);
     }, SETTLE_DELAY);
+    state.settleTimers.set(id, t);
   }
 }

package/lib/tools.mjs

@@ -5,6 +5,7 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 import { join } from "node:path";
 import { todayISO, isoDaysAgo, expandHome, toHomeShort, readMdSync, budgetClip, stripDeletedLines } from "./common/text.mjs";
 import { appendLineDedup, findMatches, removeLineByMatch, recentLogDates } from "./common/records.mjs";
+import { planModeOf } from "./common/planmode.mjs";
 
 /**
  * @param {{ ctx: object, getConfig: () => object, paths: object, state: object }} deps
@@ -409,8 +410,9 @@ export function registerTools({ ctx, getConfig, paths, state }) {
   const WRITE_TOOLS = new Set(["memory_note", "memory_note_user", "memory_delete"]);
   ctx.on("tools/pre-execute", async (exec, next) => {
     const name = exec?.name;
-    // plan 模式禁写：三个写工具一律 deny，连预览/确认都拦
-    if (state.planModeActive && WRITE_TOOLS.has(name)) {
+    // plan 模式禁写：三个写工具一律 deny，连预览/确认都拦。
+    // 按**会话**判定（plan 模式是会话级状态，见 common/planmode.mjs）——别的会话进 plan 不该 deny 本会话。
+    if (planModeOf(state, exec?.agent?.session) && WRITE_TOOLS.has(name)) {
       return { kind: "deny", reason: "plan 模式下禁止写入记忆" };
     }
     if (name !== "memory_delete") return next();

package/package.json

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