dsh-mem0-memory 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -5,6 +5,30 @@
 
 ## [Unreleased]
 
+### 0.1.6（2026-10-29）
+
+- **跟随 DSH 0.2.x 的 v4 会话格式与工作区身份判定**，四处修复（前两处是用户可感知的静默失效）：
+  1. **会话文件定位（G1）**：旧实现只认 `session.jsonl.zstd`；DSH 0.2.x 写 `session.v4.jsonl.zstd` → 升级后**所有新会话对解析器不可见**，DSH 侧素材静默断流。改为「同一会话目录取 mtime 最新的 `session*.jsonl(.zstd)`，同 mtime 取格式版本高的」。
+  2. **注入过滤（G1）**：v4 把消息来源从 `{kind:"plugin",plugin:"x"}` 改成生产者自有 kind（`plugin:<name>` / `time-context` / `user-approval` / `agent-instructions` …），旧黑名单全部漏网 → 插件自己注入的召回块会被当作真实用户消息**回灌记忆库**（自我污染循环）。改为**白名单**：只有 `kind:"user"`（或无 source 的历史消息）算真实用户，其余丢弃并计数，未知 kind 打 WARN。
+  3. **工作区身份判定（G1）**：`projectKey` 是 cwd 的有损编码（`: / \`→`-`，但不转义原有的 `-`），含连字符的路径会被切碎 → 台账精确匹配与 `0_` 前缀双失效。改为读**会话 header 的 `cwd`** 作权威路径；解码只作展示与兜底；**移除 basename 兜底**（连字符下只剩碎片，可能误命中别的区 → 误排除）。
+  4. **召回侧工作区排除（插件）**：原读 `agent.session.cwd`——该属性在 DSH 中**不存在**，排除判定恒为 false（自 0.1.3 上线起从未生效）。改为 `session.header.cwd` → 兜底 `ctx.workingDirectory.get(session)`；`inject` 增加 `workingDirectory`。
+- **工作区排除新增第三个渠道：台账标题**。`$DSH_HOME/storages/workspace.json` 的 `title` 以 `0_` 开头即排除——支持「只在 DSH 界面里把工作区改名成 `0_`、目录名不变」的用法（插件侧读台账并按 mtime 缓存，缺失时 fail-open）。
+- 兼容性：以上改动对 0.1.x 的会话格式与台账结构向后兼容（无 source 的历史消息仍视为真实用户；旧文件名仍在候选列表里）。
+- 影响面：`scripts/g1-session-parser.mjs`、`lib/index.js`、`package.json`；server / 导入命令未改动。
+- 验证：v4 会话识别（候选文件数上升、窗口内素材由 0 → 非 0）；同一 v4 会话旧版 26 turn/43 消息 → 新版 17 turn/34 消息（滤掉注入）；落盘批次零注入痕迹；插件假 ctx 六用例（目录名 `0_` / 台账标题 `0_` / 名单 / workingDirectory 兜底 / 普通区仍注入）全过。
+
+### 0.1.5（2026-10-18）
+
+- **适配 DSH 0.2.x（0.2.1-rc.2 实测）**，两处改动，缺一不可：
+  1. **peer 范围放宽**：`@deepseek-ai/dsh-agent-loop` 由 `^0.1.0-rc.6`（= `>=0.1.0-rc.6 <0.2.0`）改为 **`^0.1.0-rc.6 || ^0.2.1-rc.2`**。0.2.1 起底座新增「插件兼容性硬校验」，旧范围会被判为不兼容并**拒绝安装 + 回滚**（`installation rejected: Plugin dsh-mem0-memory@0.1.4 is incompatible with dsh 0.2.1-rc.2`）。
+      - 选**有界区间**而非 `*`/`>=`：本插件会向会话写入事件，声明「任何版本都支持」会在 DSH 大版本再变时静默踩雷（参见 2026-08-19 会话损坏事故）。0.3.x 起需重新验证后再放宽。
+      - 覆盖：0.1.5-rc.3（旧线）✅、0.2.1-rc.2（新线）✅、0.2.x 后续 rc/补丁 ✅。
+  2. **注入消息的 `source.kind` 改写**：`{ kind: "plugin", plugin: "dsh-mem0-memory", form: "recall" }` → **`{ kind: "plugin:dsh-mem0-memory", form: "recall" }`**。
+      - 根因：0.2.x 引入 session format **v4**，其 `source()` 校验**明确禁止 `kind:"plugin"`**（要求生产者自有 kind，`plugin:<name>` 即 V3→V4 迁移器对未知插件的标准映射）。若只放宽 peer 不改这里，结果是「装得上、但每轮对话在注入后报 `format v4 message requires a producer-owned source kind` 而失败」——比装不上更糟。
+      - 兼容性：0.1.x 的写入门槛只要求「kind 为非空字符串」，`kind:"plugin"` 的强校验仅针对 `system/message`，`user/message` 不受限 → 同一份代码在 0.1.x 与 0.2.x 上都能跑，无需按底座版本分支。
+- 影响面：`lib/index.js`（注入点一处）、`package.json`（版本 + peer）；server / G1 解析器 / 导入命令未改动。
+- 验证：0.2.1-rc.2 真实环境实跑（安装通过、注入链完整、会话可关闭重开、转录 v4 事件形态正确）。
+
 ### 0.1.4（2026-08-23）
 
 - **server 自动拉起（autoStartServer）**：DSH 启动时插件探测 mem0 server 的 `/health`（3s 超时）——未在跑则自动 spawn 一次（`detached` 子进程，不随 DSH 退出）；已在跑则不动。用户装了插件 = 期望「与平台同步启动」，忘记手动开 server 也能工作。

package/README.md

@@ -152,6 +152,10 @@ python scripts/mem0-server.py --port 18200 # 启动服务
 > 重启后，**跑一次首次导入（见下节）**，历史会话就进记忆库了——之后自动增量，不用再管。
 >
 > **peer 依赖警告可忽略**：安装时 pnpm 可能提示 `missing peer @deepseek-ai/cordis` / `@deepseek-ai/dsh-agent-loop`——这是声明性警告，插件运行时会从 DSH 的 bundle 安装处解析这些依赖，无需处理。
+>
+> **兼容的 DSH 版本**：`dsh-agent-loop` peer 范围 = `^0.1.0-rc.6 || ^0.2.1-rc.2`（0.1.5-rc.3 与 0.2.1-rc.2 均已验证）。DSH 0.2.1 起底座会做插件兼容性硬校验，版本号不在范围内会被**拒绝安装**；若你用的是更晚的大版本（0.3.x 起），请先确认插件已跟进再装。
+>
+> **DSH 0.2.x 的会话格式**：0.2.x 起会话转录改名为 `session.v4.jsonl.zstd`（旧名 `session.jsonl.zstd` 仍兼容），消息来源字段由 `{kind:"plugin",plugin:"x"}` 改为生产者自有 kind。本版（0.1.6+）同时支持两种格式；**0.1.5 及更早版本在 0.2.x 上会「看不到升级后的新会话」并且「把召回块当用户消息回灌」**，请勿在 0.2.x 上使用旧版。工作区排除现在支持三种标记：目录名 `0_` 开头、`excludeWorkspaces` 名单、**以及在 DSH 界面里把工作区改名成 `0_` 开头**。
 
 ## 首次导入：把你的历史会话装进记忆库
 

package/lib/index.js

@@ -208,16 +208,77 @@ function extractLastUserText(messages) {
 
 // ─── 插件入口 ────────────────────────────────────────────────────────────
 export const name = "dsh-mem0-memory";
-export const inject = ["agents"];
+// 2026-10-29：新增 workingDirectory（官方服务，同步无 IO）作为 cwd 兜底。
+// 只用 agents 时拿不到会话目录（session.cwd 不存在，见 pre-step 内注释）。
+export const inject = ["agents", "workingDirectory"];
 
-// ─── 工作区排除（2026-08-22，与 G1 判定一致）────────────────────────────
+// ─── 工作区排除（2026-08-22 上线；2026-10-29 对齐 G1 三渠道）─────────────
 // 排除工作区的会话：不召回也不注入（该区内容本就不入库，召回只会带来延时开销）。
-// 判定：① cwd 路径任一段以 `0_` 开头（写死约定，与 G1 EXCLUDE_PREFIX 一致）
-//       ② config.excludeWorkspaces 名单子串匹配（对应 G1 excluded-workspaces.json）
-function isExcludedWorkspace(cwd, list) {
-  if (!cwd) return false;
-  if (String(cwd).split(/[\\/]/).some((s) => s.startsWith("0_"))) return true;
-  return (list ?? []).some((e) => e && String(cwd).includes(String(e)));
+// 判定（与 G1 对齐，任一命中即排除）：
+//   ① cwd 路径任一段以 `0_` 开头（目录名的写死约定，与 G1 EXCLUDE_PREFIX 一致）
+//   ② config.excludeWorkspaces 名单子串匹配（对应 G1 excluded-workspaces.json）
+//   ③ **台账标题**以 `0_` 开头（$DSH_HOME/storages/workspace.json 的 title——
+//      只在 UI 里改名、目录名不变的场景下，①② 都命不中，只有这条能拦住）
+const EXCLUDE_PREFIX = "0_";
+
+function normalizeWsPath(p) {
+  return String(p).replace(/[\\/]+$/, "").toLowerCase();
+}
+
+// 台账缓存：按文件 mtime 失效，避免每轮都读盘（读一次几百字节，成本可忽略）
+const _ledgerCache = { mtimeMs: -1, map: new Map() };
+
+async function loadWorkspaceLedger() {
+  try {
+    const fs = await import("node:fs");
+    const os = await import("node:os");
+    const path = await import("node:path");
+    const home = process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+    const file = path.join(home, "storages", "workspace.json");
+    const st = fs.statSync(file);
+    if (st.mtimeMs === _ledgerCache.mtimeMs) return _ledgerCache.map;
+    const cfg = JSON.parse(fs.readFileSync(file, "utf8"));
+    const table = cfg?.tables?.workspaces ?? {};
+    const map = new Map();
+    for (const rec of Object.values(table)) {
+      if (!rec || typeof rec.path !== "string" || typeof rec.title !== "string") continue;
+      map.set(normalizeWsPath(rec.path), rec.title);
+    }
+    _ledgerCache.mtimeMs = st.mtimeMs;
+    _ledgerCache.map = map;
+    return map;
+  } catch {
+    return _ledgerCache.map;   // 台账缺失/损坏 → fail-open（不影响召回主流程）
+  }
+}
+
+/** 按 cwd 查台账标题：先精确匹配，再取「路径是 cwd 前缀」的最长一条（兼容子目录会话） */
+function ledgerTitleFor(cwd, ledger) {
+  if (!ledger || ledger.size === 0 || !cwd) return "";
+  const key = normalizeWsPath(cwd);
+  if (ledger.has(key)) return ledger.get(key);
+  let bestLen = -1, bestTitle = "";
+  for (const [p, title] of ledger) {
+    if (key === p || key.startsWith(p + "\\") || key.startsWith(p + "/")) {
+      if (p.length > bestLen) { bestLen = p.length; bestTitle = title; }
+    }
+  }
+  return bestTitle;
+}
+
+/** @returns {{excluded:boolean, reason:string}} —— reason 仅用于日志/探针 */
+async function exclusionVerdict(cwd, list) {
+  if (!cwd) return { excluded: false, reason: "" };
+  if (String(cwd).split(/[\\/]/).some((s) => s.startsWith(EXCLUDE_PREFIX))) {
+    return { excluded: true, reason: "0_ 前缀（目录名）" };
+  }
+  const hit = (list ?? []).find((e) => e && String(cwd).includes(String(e)));
+  if (hit) return { excluded: true, reason: `名单命中「${hit}」` };
+  const title = ledgerTitleFor(cwd, await loadWorkspaceLedger());
+  if (title && String(title).startsWith(EXCLUDE_PREFIX)) {
+    return { excluded: true, reason: `0_ 前缀（台账标题「${title}」）` };
+  }
+  return { excluded: false, reason: "" };
 }
 
 // ─── server ensure（2026-08-23）：DSH 启动时确保 mem0 server 在跑 ─────────
@@ -319,17 +380,35 @@ export async function apply(ctx, config = {}) {
 
     if (decision.kind !== "enter" || !Array.isArray(decision.messages)) return decision;
 
-    // 工作区排除（2026-08-22）：当前会话 cwd 属于排除工作区 → 跳过召回（不注入）。
-    // 判定与 G1 一致（0_ 前缀 + excludeWorkspaces 名单子串）；拿不到 cwd 则不排除。
+    // 工作区排除（2026-08-22 上线；2026-10-29 修复取值）：
+    // 之前读 `agent.session.cwd` —— 该属性在 DSH 里**不存在**，cwd 恒为 ""，
+    // `isExcludedWorkspace()` 首行 `if (!cwd) return false` 使排除从未生效（fail-open）。
+    // 现改为两级取法（都来自官方 API）：① session.header.cwd（会话创建时的项目目录，稳定）
+    // ② ctx.workingDirectory.get(session)（当前目录，跟随 cd）
     let cwd = "";
+    let cwdSource = "unknown";
     try {
       const agent = ctx.agents?.requireInitiator?.();
-      cwd = agent?.session?.cwd ?? "";
-    } catch (e) {}
-    await probe(`workspace cwd=${cwd || "unknown"}`);
-    if (isExcludedWorkspace(cwd, cfg.excludeWorkspaces)) {
-      ctx.logger?.info(`[mem0-memory] workspace excluded (skip recall): ${cwd || "(unknown)"}`);
-      await probe("workspace excluded, skip recall");
+      const session = agent?.session;
+      const headerCwd = session?.header?.cwd;
+      if (typeof headerCwd === "string" && headerCwd.trim() !== "") {
+        cwd = headerCwd;
+        cwdSource = "header.cwd";
+      } else if (session) {
+        const current = ctx.workingDirectory?.get?.(session);
+        if (typeof current === "string" && current.trim() !== "") {
+          cwd = current;
+          cwdSource = "workingDirectory";
+        }
+      }
+    } catch (e) {
+      await probe(`workspace cwd 取值异常: ${e.message}`);
+    }
+    await probe(`workspace cwd=${cwd || "unknown"} (source=${cwdSource})`);
+    const verdict = await exclusionVerdict(cwd, cfg.excludeWorkspaces);
+    if (verdict.excluded) {
+      ctx.logger?.info(`[mem0-memory] workspace excluded (skip recall): ${cwd || "(unknown)"} ← ${verdict.reason}`);
+      await probe(`workspace excluded, skip recall (${verdict.reason})`);
       return decision;
     }
 
@@ -350,13 +429,21 @@ export async function apply(ctx, config = {}) {
       // 注入：在最后一条 claimed 消息之后插入记忆块。
       // 必须带消息 id 且 content 用文本块数组 —— DSH 的 user/message 事件校验要求
       // message.id 为非空字符串、content 为块数组，缺失会把整个 session 持久化日志判为损坏。
+      //
+      // source.kind（2026-10-18 适配 DSH 0.2.x / session format v4）：
+      //   0.2.x 的 v4 格式禁止 `kind:"plugin"` 这个 catch-all 包装
+      //   （dsh-session-format-v3-to-v4 的 source() 校验：kind 必须非空且 ≠ "plugin"），
+      //   要求生产者声明自有 kind；V3→V4 迁移器对未知插件的映射结果就是 `plugin:<name>`，
+      //   此处直接用同一命名，保证新写记录与迁移后的历史记录同形。
+      //   兼容性：0.1.x 的写入门槛只要求「kind 是非空字符串」，`kind:"plugin"` 的强校验
+      //   仅针对 system/message，user/message 不受限制 → 该写法 0.1.x 与 0.2.x 同时合法。
       const lastClaimedIndex = decision.messages.findLastIndex((message) => messages.includes(message));
       await probe(`lastClaimedIndex=${lastClaimedIndex}`);
       const injected = {
         role: "user",
         id: randomUUID(),
         content: [{ type: "text", text: result.block }],
-        source: { kind: "plugin", plugin: "dsh-mem0-memory", form: "recall" },
+        source: { kind: "plugin:dsh-mem0-memory", form: "recall" },
       };
       const finalMessages = decision.messages.toSpliced(lastClaimedIndex + 1, 0, injected);
       await probe(`injected! finalMessages=${finalMessages.length}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mem0-memory",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Thin bridge: recall Mem0 memories into DSH agent context via agent/pre-step injection.",
   "type": "module",
   "main": "lib/index.js",
@@ -32,7 +32,7 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent-loop": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-agent-loop": "^0.1.0-rc.6 || ^0.2.1-rc.2"
   },
   "license": "MIT",
   "repository": {

package/scripts/g1-session-parser.mjs

@@ -6,7 +6,9 @@
  *   DSH session（原始日志）→ G1 解析器 → 增量窗口 → mem0（唯一事实源）。
  *   本脚本是 G1 解析器主实现，负责把 DSH 的对话日志翻译成记忆批次。
  *
- * 【输入】  ~/.dsh/sessions/<projectKey>/<sessionId>/session.jsonl.zstd
+ * 【输入】  ~/.dsh/sessions/<projectKey>/<sessionId>/session*.jsonl.zstd
+ *           （0.1.x 写 session.jsonl.zstd；0.2.x 起写 session.v4.jsonl.zstd，
+ *            同目录取 mtime 最新者，见 resolveSessionFile）
  *          （zstd 帧容器：header 帧 + append 帧；事件 JSONL）
  * 【输出】  与 mem0 对话批次同构的数组 batch：
  *          <out>/<YYYY-MM-DD>/P0_NNN.json
@@ -70,6 +72,33 @@ const EXCLUDED_WORKSPACES_FILE = path.join(SCRIPT_DIR, "excluded-workspaces.json
 /** 不入库的工作区命名前缀（写死约定：未来新建不入库的工作区以此命名） */
 const EXCLUDE_PREFIX = "0_";
 
+// ─── 会话文件定位（2026-10-29 修复：DSH 0.2.x 写 session.v4.jsonl.zstd）────
+// 旧实现只认 `session.jsonl.zstd`；DSH 0.2.x 起写 `session.v4.jsonl.zstd`
+// （升级器还会为旧会话保留 v3/legacy 副本）——只认旧名会让升级后所有新会话
+// 对解析器不可见（DSH 侧素材静默断流）。
+// 规则：同一会话目录内取 mtime 最新的 session*.jsonl(.zstd)；mtime 相同取格式版本高的。
+const SESSION_FILE_PATTERN = /^session(?:\.v(\d+))?\.jsonl(?:\.zstd)?$/;
+
+/** 一个会话目录里应解析的转录文件；没有则返回 null。 */
+function resolveSessionFile(sessionDir) {
+  let names;
+  try { names = fs.readdirSync(sessionDir); } catch { return null; }
+  const candidates = [];
+  for (const name of names) {
+    const m = SESSION_FILE_PATTERN.exec(name);
+    if (!m) continue;
+    const full = path.join(sessionDir, name);
+    try {
+      const st = fs.statSync(full);
+      if (!st.isFile()) continue;
+      candidates.push({ full, mtime: st.mtimeMs, rank: m[1] ? Number(m[1]) : 0 });
+    } catch { /* 读写竞态跳过 */ }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => (b.mtime - a.mtime) || (b.rank - a.rank));
+  return candidates[0].full;
+}
+
 function loadExcludedWorkspaces() {
   if (!fs.existsSync(EXCLUDED_WORKSPACES_FILE)) {
     throw new Error(`工作区排除配置文件缺失: ${EXCLUDED_WORKSPACES_FILE}（fail-closed，拒绝无保护运行）`);
@@ -98,26 +127,34 @@ function decodeProjectKey(key) {
   return decoded.split("-").filter(Boolean).join("\\");
 }
 
-function isWorkspaceExcluded(projectKey, decoded, excluded) {
-  return excluded.some((e) => projectKey.includes(e) || decoded.includes(e));
+/** 名单匹配：原始 projectKey / 解码路径 / 真实路径（header.cwd，2026-10-29 新增）任一命中即排除。
+ *  @param realPath 会话 header.cwd 给出的绝对路径（权威）；缺失时传 null/undefined 只按前两者判 */
+function isWorkspaceExcluded(projectKey, decoded, excluded, realPath) {
+  const real = realPath ? String(realPath) : "";
+  return excluded.some((e) => projectKey.includes(e) || decoded.includes(e) || (real !== "" && real.includes(e)));
 }
 
 /** 前缀规则（写死约定）：不入库的工作区 = 名称以 `0_` 开头。名称有两处
  *  载体：①目录名（= 创建时的默认 title，路径派生 projectKey）；②台账标题
  *  （~/.dsh/storages/workspace.json 的 title，UI 可改名，不影响磁盘目录）。
- *  三个命中渠道：解码路径任一段 / 原始 projectKey 任一段 / 台账标题，
- *  任一命中即排除。
+ *  四个命中渠道：真实路径任一段（header.cwd）/ 解码路径任一段 / 原始 projectKey
+ *  任一段 / 台账标题，任一命中即排除。
+ *  2026-10-29：新增 cwd 渠道——`decodeProjectKey()` 把 `-` 当分隔符，含连字符的
+ *  路径会被切碎（OKR-DSH-Trial-20261024 → OKR\DSH\Trial\20261024），解出的路径
+ *  既查不到台账（标题渠道失效）也不含 `0_`（路径渠道失效）。
  *  @returns 命中渠道数组（空数组 = 未命中） */
-function prefixedChannels(projectKey, decoded, record) {
+function prefixedChannels(projectKey, decoded, record, realPath) {
   const ch = [];
-  if (decoded.split("\\").some((s) => s.startsWith(EXCLUDE_PREFIX))) ch.push("前缀0_(路径)");
+  const pathSegs = String(realPath || decoded).split(/[\\/]/).filter(Boolean);
+  if (pathSegs.some((s) => s.startsWith(EXCLUDE_PREFIX))) ch.push(realPath ? "前缀0_(cwd)" : "前缀0_(路径)");
+  if (realPath && decoded.split("\\").some((s) => s.startsWith(EXCLUDE_PREFIX))) ch.push("前缀0_(路径)");
   if (projectKey.split("-").some((s) => s.startsWith(EXCLUDE_PREFIX))) ch.push("前缀0_(projectKey)");
   if (record && String(record.title).startsWith(EXCLUDE_PREFIX)) ch.push("前缀0_(标题)");
   return ch;
 }
 
-function isPrefixedWorkspace(projectKey, decoded, record) {
-  return prefixedChannels(projectKey, decoded, record).length > 0;
+function isPrefixedWorkspace(projectKey, decoded, record, realPath) {
+  return prefixedChannels(projectKey, decoded, record, realPath).length > 0;
 }
 
 // ─── DSH 工作区台账（名称的权威载体）─────────────────────────────────────
@@ -150,18 +187,17 @@ function loadWorkspaceRegistry() {
   return _workspaceRegistry;
 }
 
-/** 由解码后的工作区路径查台账记录；basename 兜底（路径大小写/尾斜杠差异） */
+/** 由 header.cwd 给出的真实路径精确查台账（权威通道，无解码歧义） */
+function registryRecordForPath(realPath) {
+  if (!realPath) return null;
+  return loadWorkspaceRegistry().get(normalizeWsPath(realPath)) ?? null;
+}
+
+/** 由解码后的工作区路径查台账记录（仅 header.cwd 缺失时的兜底）。
+ *  2026-10-29 移除 basename 兜底：连字符路径下解码只剩碎片（如 `20261028`），
+ *  basename 兜底可能误命中别的工作区标题 → 误排除，比误入库更难发现。 */
 function registryRecordFor(decoded) {
-  const rec = loadWorkspaceRegistry().get(normalizeWsPath(decoded));
-  if (rec) return rec;
-  const last = decoded.split("\\").filter(Boolean).pop();
-  if (!last) return null;
-  const lc = last.toLowerCase();
-  for (const r of loadWorkspaceRegistry().values()) {
-    const rLast = r.path.split("\\").filter(Boolean).pop();
-    if (rLast && rLast.toLowerCase() === lc) return r;
-  }
-  return null;
+  return loadWorkspaceRegistry().get(normalizeWsPath(decoded)) ?? null;
 }
 
 // ─── Logger（复杂管线工程守则：必须有足够追查问题根因的 log）─────────────
@@ -314,7 +350,10 @@ function parseEvents(text) {
   return events;
 }
 
-// ─── session header 读取（depth/origin 判断）─────────────────────────────
+// ─── session header 读取（depth/origin/cwd 判断）─────────────────────────
+// cwd：DSH 写入 header 的绝对工作目录（SessionHeader.cwd，「会话创建时的目录」）。
+// 2026-10-29 起作为工作区身份判定的权威来源——projectKey 是路径的有损编码，
+// 含连字符时无法还原（见 prefixedChannels 注释）。
 function readSessionHeader(file) {
   try {
     const buf = fs.readFileSync(file);
@@ -330,6 +369,8 @@ function readSessionHeader(file) {
       delegationDepth: typeof h.delegationDepth === "number" ? h.delegationDepth : 0,
       origin: h.origin,
       parentSession: h.parentSession,
+      cwd: typeof h.cwd === "string" && h.cwd.trim() !== "" ? h.cwd : undefined,
+      version: typeof h.version === "number" ? h.version : undefined,
       empty: false,
     };
   } catch {
@@ -337,6 +378,16 @@ function readSessionHeader(file) {
   }
 }
 
+/** 一个工作区目录里任一会话 header 给出的 cwd（绝对路径，权威）。
+ *  只读各会话文件的第一帧，成本远低于全量解析；全部缺失则返回 undefined。 */
+function firstHeaderCwd(sessionFiles) {
+  for (const { file } of sessionFiles) {
+    const h = readSessionHeader(file);
+    if (!h.empty && h.cwd) return h.cwd;
+  }
+  return undefined;
+}
+
 // ─── 文本提取 ────────────────────────────────────────────────────────────
 function flattenText(content) {
   if (typeof content === "string") return content;
@@ -398,16 +449,39 @@ function hasSecret(c) {
 }
 
 // ─── 消息提取（核心：user 锚点分组 + 每 turn 取最后一条 assistant）───────
-const INJECTION_KINDS = new Set([
-  "plugin", "system", "goal", "agent-instructions", "skill-catalog",
-  "subagent-settled", "subagent-report", "hook", "compaction",
+// 2026-10-29 修复（v4 源类型改造）：
+//   DSH 0.2.x 的 session format v4 把 source 从 `{kind:"plugin", plugin:"x"}`
+//   改成「生产者自有 kind」：插件注入 = `plugin:<name>`，系统注入 = `time-context`
+//   / `agent-instructions` / `skill-catalog` / `user-approval` / `runtime-context`
+//   / `subagent-*` / `compact-checkpoint` / `tool-*` / `goal` / `model-selection` …
+//   旧实现是黑名单，v4 新 kind 全部漏网 —— 实测 36 个 v4 会话里插件自己的注入块
+//   （`plugin:dsh-mem0-memory` / `plugin:dsh-mem0-bridge`）会被当成真实用户消息回灌
+//   记忆库（自我污染循环）。改为**白名单**：只有 `kind:"user"` 与无 source 的历史
+//   消息算真实用户；其余一律视为注入并计数，未知 kind 打 WARN 便于发现新渠道。
+const REAL_USER_KINDS = new Set(["user"]);
+const KNOWN_INJECTION_KINDS = new Set([
+  "plugin",   // 0.1.x 的 catch-all 包装（v4 已废止，历史会话里仍会出现）
+  "system", "developer", "goal", "agent-instructions", "skill-catalog",
+  "subagent-settled", "subagent-report", "hook", "compaction", "compact-checkpoint",
+  "time-context", "runtime-context", "tmux-context", "model-selection", "plan-mode",
+  "user-approval", "repeat-tool-reminder", "tool-jobs", "tool-goal", "tool-cordis",
+  "agent-message", "team-message", "coordinator", "schedule", "webhook",
+  "session-reference", "system-prompt", "cordis-host-runner", "dsh-session-title-llm",
+  "ptc-mode", "compact-basic",
 ]);
+const _warnedKinds = new Set();
 
 function isRealUserEvent(ev) {
   if (ev.type !== "user/message") return false;
   const kind = ev.data?.source?.kind;
-  if (kind === undefined) return true; // 无 source 视为真实用户（兼容旧格式）
-  return !INJECTION_KINDS.has(kind);
+  if (kind === undefined) return true;              // 无 source：兼容 0.1.x 之前的历史格式
+  if (REAL_USER_KINDS.has(kind)) return true;
+  const isPluginProducer = typeof kind === "string" && kind.startsWith("plugin:");
+  if (!isPluginProducer && !KNOWN_INJECTION_KINDS.has(kind) && !_warnedKinds.has(kind)) {
+    _warnedKinds.add(kind);
+    log("WARN", "filter", `未知 source.kind=${kind}：按注入丢弃（若这是真实用户消息，请把该 kind 加进 REAL_USER_KINDS）`);
+  }
+  return false;
 }
 
 /**
@@ -613,9 +687,11 @@ async function main() {
       const sk = path.basename(path.dirname(path.dirname(args.session)));
       const excluded = loadExcludedWorkspaces();
       const decoded = decodeProjectKey(sk);
-      const record = registryRecordFor(decoded);
-      if (isWorkspaceExcluded(sk, decoded, excluded) || isPrefixedWorkspace(sk, decoded, record)) {
-        log("ERROR", "filter", `--session 属于排除工作区，拒绝解析: ${sk} (${decoded})`);
+      const realPath = readSessionHeader(args.session).cwd;   // 权威路径（header.cwd）
+      const record = registryRecordForPath(realPath) ?? registryRecordFor(decoded);
+      const prefixCh = prefixedChannels(sk, decoded, record, realPath);
+      if (isWorkspaceExcluded(sk, decoded, excluded, realPath) || prefixCh.length > 0) {
+        log("ERROR", "filter", `--session 属于排除工作区，拒绝解析: ${sk} (${realPath || decoded})`);
         process.exit(1);
       }
       files = [{ file: args.session, dir: path.basename(path.dirname(args.session)) }];
@@ -625,20 +701,31 @@ async function main() {
         const pd = path.join(SESSIONS_ROOT, projectDir);
         if (!fs.statSync(pd).isDirectory()) continue;
         if (projectDir === "Archived") continue;
+        // 先定位该工作区下所有可解析的会话文件（0.2.x 是 session.v4.jsonl.zstd）
+        const projectFiles = [];
+        for (const sessionDir of fs.readdirSync(pd)) {
+          const f = resolveSessionFile(path.join(pd, sessionDir));
+          if (f) projectFiles.push({ file: f, dir: sessionDir });
+        }
         const decoded = decodeProjectKey(projectDir);
-        const prefixCh = prefixedChannels(projectDir, decoded, registryRecordFor(decoded));
-        if (isWorkspaceExcluded(projectDir, decoded, excluded) || prefixCh.length > 0) {
+        // 权威路径：优先会话 header.cwd（绝对路径，不受 projectKey 有损编码影响）
+        const realPath = firstHeaderCwd(projectFiles);
+        const record = registryRecordForPath(realPath) ?? registryRecordFor(decoded);
+        const prefixCh = prefixedChannels(projectDir, decoded, record, realPath);
+        const listHit = isWorkspaceExcluded(projectDir, decoded, excluded, realPath);
+        if (listHit || prefixCh.length > 0) {
           filtered.workspace++;
           const reasons = [];
           if (prefixCh.length > 0) reasons.push(prefixCh.join(";"));
-          if (isWorkspaceExcluded(projectDir, decoded, excluded)) reasons.push("排除名单");
-          log("INFO", "filter", `工作区排除: ${projectDir} (${decoded}) [${reasons.join(";")}]`);
+          if (listHit) reasons.push("排除名单");
+          log("INFO", "filter", `工作区排除: ${projectDir} (${realPath || decoded}) [${reasons.join(";")}]`);
           continue;
         }
-        for (const sessionDir of fs.readdirSync(pd)) {
-          const f = path.join(pd, sessionDir, "session.jsonl.zstd");
-          if (fs.existsSync(f)) files.push({ file: f, dir: sessionDir });
+        if (projectFiles.length === 0) {
+          log("INFO", "filter", `无转录文件跳过: ${projectDir} (${realPath || decoded})`);
+          continue;
         }
+        files.push(...projectFiles);
       }
     }
     if (files.length === 0) {