dsh-mem0-memory 0.1.0

package/bin/dsh-mem0-import.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+/**
+ * dsh-mem0-import — DSH 会话记忆导入命令（dsh-mem0-memory 三件套之一）
+ *
+ * 链条：G1 解析（per-session 增量窗口）→ 收集批次 → POST server /import
+ *       → 全部成功才落 checkpoint（失败不更新，下次重跑，mem0 hash 去重兜底）。
+ *
+ * 用法：
+ *   node dsh-mem0-import.mjs                # --since-last（默认）：读 checkpoint 增量导入
+ *   node dsh-mem0-import.mjs --full         # 全量首导（忽略 checkpoint，导入后建立）
+ *   node dsh-mem0-import.mjs --session <f>  # 只导指定 session 文件
+ *   node dsh-mem0-import.mjs --dry-run      # 只解析统计，不 POST 不落 checkpoint
+ *
+ * 并发安全：运行前抢 .import.lock（checkpoint 同级）。锁文件只写不删——
+ *   下次运行按 PID 存活检测：持有者还活着 = 真锁，本次跳过；已死 = 残留锁，覆盖接管。
+ * 失败语义：任一批次 POST 失败 → 退出码 1，checkpoint 不动。
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const DEFAULT_G1 = path.join(SCRIPT_DIR, "..", "scripts", "g1-session-parser.mjs");
+const DEFAULT_SERVER = "http://127.0.0.1:18200";
+const DEFAULT_DSH_HOME = process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+const BATCH_TIMEOUT_MS = 120000;
+
+function parseArgs(argv) {
+  const get = (k) => { const i = argv.indexOf(k); return i >= 0 ? argv[i + 1] : undefined; };
+  return {
+    help: argv.includes("--help") || argv.includes("-h"),
+    full: argv.includes("--full"),
+    dryRun: argv.includes("--dry-run"),
+    force: argv.includes("--force"),
+    session: get("--session"),
+    server: get("--server") ?? DEFAULT_SERVER,
+    dshHome: get("--dsh-home") ?? DEFAULT_DSH_HOME,
+    out: get("--out"),
+    logDir: get("--log-dir"),
+    script: get("--script") ?? DEFAULT_G1,
+    timeoutMs: Number(get("--timeout-ms") ?? BATCH_TIMEOUT_MS),
+  };
+}
+
+const USAGE = `dsh-mem0-import — DSH 会话记忆导入命令（G1 → mem0-server /import → checkpoint）
+
+用法:
+  node dsh-mem0-import.mjs [选项]
+
+选项:
+  --since-last（默认）  读 checkpoint 增量导入（无 checkpoint = 全量首导）
+  --full                全量导入（忽略 checkpoint，导入后建立）
+  --session <file>      只导入指定 session 文件
+  --server <url>        mem0-server 地址（默认 http://127.0.0.1:18200）
+  --dsh-home <dir>      DSH 数据根（默认 $DSH_HOME 或 ~/.dsh）
+  --out <dir>           G1 批次输出目录（默认 $DSH_HOME/tmp/dsh-memory-g1）
+  --log-dir <dir>       G1 日志目录（默认 $DSH_HOME/logs）
+  --script <path>       g1-session-parser.mjs 路径（默认同包 scripts/ 下）
+  --timeout-ms <N>      单批次 POST 超时（默认 120000）
+  --force               接管残留 .import.lock（PID 已死的锁）
+  --dry-run             只解析统计，不 POST 不落 checkpoint
+  -h, --help            显示本帮助
+
+checkpoint: <dsh-home>/mem0/import-state.json（{sessionId: lastSeq}）
+`;
+
+const log = (level, phase, msg) => console.log(`[${new Date().toISOString()}] [${level}] [${phase}] ${msg}`);
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(USAGE);
+    return 0;
+  }
+  // 统一绝对路径（G1 由子进程继承 cwd，但 checkpoint/锁必须在稳定位置）
+  args.dshHome = path.resolve(args.dshHome);
+  if (args.out) args.out = path.resolve(args.out);
+  if (args.logDir) args.logDir = path.resolve(args.logDir);
+  if (args.session) args.session = path.resolve(args.session);
+  if (args.script) args.script = path.resolve(args.script);
+
+  const checkpointPath = path.join(args.dshHome, "mem0", "import-state.json");
+  const lockPath = `${checkpointPath}.lock`;
+  const pendingPath = `${checkpointPath}.pending.json`;
+
+  // ── 锁（只写不删；PID 存活检测区分真锁/残留锁）──
+  if (fs.existsSync(lockPath)) {
+    let holderPid = null;
+    try { holderPid = JSON.parse(fs.readFileSync(lockPath, "utf8")).pid ?? null; } catch {}
+    const alive = holderPid != null && (() => { try { process.kill(holderPid, 0); return true; } catch { return false; } })();
+    if (alive && !args.force) {
+      log("WARN", "lock", `另一导入进程在跑（pid=${holderPid}），本次跳过；确认无进程后可 --force 接管`);
+      return 0;
+    }
+    log("WARN", "lock", alive ? "--force 接管运行中的导入" : `残留锁（pid=${holderPid} 已死），接管`);
+  }
+  fs.mkdirSync(path.dirname(checkpointPath), { recursive: true });
+  fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, at: new Date().toISOString() }));
+
+  try {
+    // ── 构造 G1 调用 ──
+    const g1Args = ["--result-file", pendingPath];
+    if (args.session) g1Args.push("--session", args.session);
+    if (!args.full && fs.existsSync(checkpointPath)) g1Args.push("--checkpoint", checkpointPath);
+    if (args.out) g1Args.push("--out", args.out);
+    if (args.logDir) g1Args.push("--log-dir", args.logDir);
+    if (args.dryRun) g1Args.push("--dry-run");
+
+    log("INFO", "import", `G1: node ${args.script} ${g1Args.join(" ")}`);
+    // 把 --dsh-home 传给 G1（DSH_HOME env 控制 sessions 扫描根）
+    const g1 = spawnSync(process.execPath, [args.script, ...g1Args], {
+      encoding: "utf8",
+      timeout: 600000,
+      env: { ...process.env, DSH_HOME: args.dshHome },
+    });
+    if (g1.status !== 0) {
+      log("ERROR", "import", `G1 失败（exit=${g1.status}）: ${(g1.stderr || g1.stdout || "").slice(-1000)}`);
+      return 1;
+    }
+    const g1Tail = (g1.stdout || "").trim().split("\n").slice(-5).join("\n");
+    if (g1Tail) log("INFO", "import", `G1 输出尾:\n${g1Tail}`);
+    if (args.dryRun) {
+      log("INFO", "import", "[dry-run] 不 POST 不落 checkpoint。");
+      return 0;
+    }
+
+    // ── 读 G1 result（lastSeq + 本次批次清单）──
+    let result;
+    try {
+      result = JSON.parse(fs.readFileSync(pendingPath, "utf8"));
+    } catch (e) {
+      log("ERROR", "import", `G1 result 缺失/损坏（${pendingPath}）: ${e.message}`);
+      return 1;
+    }
+    const batches = Array.isArray(result.batches) ? result.batches : [];
+    const lastSeqMap = (result.lastSeq && typeof result.lastSeq === "object") ? result.lastSeq : {};
+    log("INFO", "import", `G1 产出 ${batches.length} 个批次（${Object.keys(lastSeqMap).length} 个 session）`);
+
+    if (batches.length === 0) {
+      // 无新内容：仍把 lastSeq 落为 checkpoint（跟进文件末尾，避免重复解析）
+      writeCheckpoint(checkpointPath, lastSeqMap);
+      log("INFO", "import", "无新批次，checkpoint 已跟进（无事实变化）");
+      return 0;
+    }
+
+    // ── 逐个 POST /import（source=DSH：发布版只有 G1 来源）──
+    const outRoot = path.resolve(args.out || path.join(args.dshHome, "tmp", "dsh-memory-g1"));
+    let posted = 0, addTotal = 0;
+    for (const rel of batches) {
+      const batchFile = path.join(outRoot, rel);
+      let messages;
+      try {
+        messages = JSON.parse(fs.readFileSync(batchFile, "utf8"));
+      } catch (e) {
+        log("ERROR", "import", `批次读取失败 ${rel}: ${e.message}`);
+        return 1;
+      }
+      const body = JSON.stringify({ messages, source: "DSH" });
+      log("INFO", "import", `POST /import ${rel}（${messages.length} 条消息）...`);
+      const resp = await awaitPost(`${args.server}/import`, body, args.timeoutMs);
+      if (!resp.ok) {
+        log("ERROR", "import", `POST 失败 ${rel}: ${resp.error}`);
+        return 1;
+      }
+      posted++;
+      addTotal += resp.add_count ?? 0;
+      log("INFO", "import", `  → add=${resp.add_count ?? "?"} total=${resp.total ?? "?"}`);
+    }
+
+    // ── 全部成功 → 落 checkpoint ──
+    writeCheckpoint(checkpointPath, lastSeqMap);
+    log("INFO", "import", `完成: ${posted}/${batches.length} 批次导入（add=${addTotal}），checkpoint 已更新`);
+    return 0;
+  } finally {
+    // 锁文件只写不删（AGENTS 红线）；下次按 PID 存活检测接管
+    log("INFO", "lock", `锁留在 ${lockPath}（pid=${process.pid}，下次运行自动判定）`);
+  }
+}
+
+function writeCheckpoint(checkpointPath, lastSeqMap) {
+  const tmp = `${checkpointPath}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(lastSeqMap, null, 2), "utf8");
+  const parsed = JSON.parse(fs.readFileSync(tmp, "utf8")); // 写后校验
+  if (!parsed || typeof parsed !== "object") throw new Error("checkpoint 自校验失败");
+  fs.renameSync(tmp, checkpointPath);
+  log("INFO", "import", `checkpoint 已落盘: ${checkpointPath}（${Object.keys(lastSeqMap).length} session）`);
+}
+
+function awaitPost(url, body, timeoutMs) {
+  return new Promise((resolve) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      signal: controller.signal,
+    })
+      .then(async (r) => {
+        const data = await r.json().catch(() => ({}));
+        resolve({ ok: r.ok && data.ok !== false, add_count: data.add_count, total: data.total, error: data.error || `HTTP ${r.status}` });
+      })
+      .catch((e) => resolve({ ok: false, error: e.name === "AbortError" ? "timeout" : e.message }))
+      .finally(() => clearTimeout(timer));
+  });
+}
+
+main().then((code) => { process.exitCode = code; }).catch((e) => { console.error(e); process.exitCode = 1; });

package/bin/dsh-mem0-search.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * dsh-mem0-search — 主动搜索记忆命令（dsh-mem0-memory 三件套之一）
+ *
+ * 对 mem0-server /search 的 CLI 封装：像用搜索引擎一样查记忆库。
+ * 支持 source 过滤（多源场景）、日期窗口、条数、降级模式标记展示。
+ *
+ * 用法：
+ *   dsh-mem0-search "关键词"                    # 默认搜全部来源，top 5
+ *   dsh-mem0-search "关键词" --limit 10         # 条数
+ *   dsh-mem0-search "关键词" --source DSH       # 只搜指定来源
+ *   dsh-mem0-search "关键词" --from 2026-08-01 --to 2026-08-19   # 日期窗口
+ *   dsh-mem0-search "关键词" --json             # 原始 JSON 输出（脚本友好）
+ *   dsh-mem0-search --server http://127.0.0.1:18200 "关键词"     # 自定义服务
+ *
+ * 输出：每条记忆一行（分数 + 来源 + 内容前 N 字）；degraded 时标注
+ *       [降级=关键词模式]，topup 时标注 [含关键词补捞]。
+ */
+
+import { fileURLToPath } from "node:url";
+
+const DEFAULT_SERVER = "http://127.0.0.1:18200";
+const DEFAULT_LIMIT = 5;
+// 日期窗口查询走 scroll+重排（慢路径，20-60s），超时要给足——普通查询远快于此
+const TIMEOUT_MS = 60000;
+
+function usage() {
+  return `dsh-mem0-search — 主动搜索记忆（mem0-server /search 的 CLI 封装）
+
+用法:
+  dsh-mem0-search <关键词> [选项]
+
+选项:
+  --limit <N>          返回条数（默认 5）
+  --source <src>       只搜指定来源（如 DSH；默认全部）
+  --from <YYYY-MM-DD>  日期窗口起（含）
+  --to <YYYY-MM-DD>    日期窗口止（含）
+  --server <url>       mem0-server 地址（默认 ${DEFAULT_SERVER}）
+  --json               输出原始 JSON（脚本友好，含 degraded/topup 标记）
+  -h, --help           显示本帮助
+
+示例:
+  dsh-mem0-search "上次说的消息格式规范"
+  dsh-mem0-search "项目技术栈" --source DSH --limit 10
+  dsh-mem0-search "8月的决定" --from 2026-08-01 --to 2026-08-31 --json
+`;
+}
+
+function parseArgs(argv) {
+  const args = { query: "", limit: DEFAULT_LIMIT, source: undefined, from: undefined, to: undefined, server: DEFAULT_SERVER, json: false, help: false };
+  const positional = [];
+  const valueOpts = new Set(["--limit", "--source", "--from", "--to", "--server"]);
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (valueOpts.has(a)) {
+      const v = argv[i + 1];
+      if (v !== undefined) {
+        if (a === "--limit") args.limit = Number(v);
+        else if (a === "--source") args.source = v;
+        else if (a === "--from") args.from = v;
+        else if (a === "--to") args.to = v;
+        else if (a === "--server") args.server = v;
+        i++; // 消费选项值，避免被当作位置参数
+      }
+    } else if (a === "--json") args.json = true;
+    else if (a === "--help" || a === "-h") args.help = true;
+    else if (!a.startsWith("-")) positional.push(a);
+  }
+  args.query = positional.join(" ").trim();
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help || !args.query) {
+    console.log(usage());
+    return args.help ? 0 : 1;
+  }
+
+  const body = { query: args.query, limit: args.limit };
+  if (args.source) body.source = args.source;
+  if (args.from) body.date_from = args.from;   // 纯日期 YYYY-MM-DD（server 按 ts_day 前缀比较）
+  if (args.to) body.date_to = args.to;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    const resp = await fetch(`${args.server}/search`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    const data = await resp.json().catch(() => ({}));
+    if (!resp.ok || data.ok === false) {
+      console.error(`搜索失败: ${data.error || `HTTP ${resp.status}`}`);
+      return 1;
+    }
+
+    if (args.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return 0;
+    }
+
+    const results = data.results || [];
+    console.log(`「${args.query}」→ ${results.length} 条记忆` +
+      (data.mode === "keyword" ? "（[降级] 关键词模式）" : "") +
+      ((data.topup || 0) > 0 ? `（含关键词补捞 +${data.topup}）` : "") +
+      `，耗时 ${data.elapsed_ms}ms`);
+    for (const r of results) {
+      const src = (r.metadata && r.metadata.source) ? `[${r.metadata.source}]` : "";
+      const ts = (r.metadata && r.metadata.timestamp) ? r.metadata.timestamp.slice(0, 10) : "";
+      console.log(`  ${String(r.score).slice(0, 5)} ${src} ${ts} ${String(r.memory || "").slice(0, 80)}`);
+    }
+    return 0;
+  } catch (e) {
+    console.error(`请求失败: ${e.name === "AbortError" ? "超时" : e.message}`);
+    return 1;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+main().then((code) => { process.exitCode = code; }).catch((e) => { console.error(e); process.exitCode = 1; });

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# dsh-mem0-memory: recall Mem0 memories via agent/pre-step injection.
+- insert:
+    - id: mem0-memory
+      name: 'dsh-mem0-memory'

package/excluded-workspaces.example.json

@@ -0,0 +1,4 @@
+{
+  "note": "G1 工作区排除名单模板（复制为 excluded-workspaces.json 后生效）。【规则优先级】①前缀约定（写死于 g1-session-parser.mjs）：工作区目录名以 0_ 开头 = 不入库（未来新建不入库的工作区按此命名，零维护）；②本文件 excluded 数组：仅历史遗留区（名称无 0_ 前缀但必须排除）。匹配：excluded 每条按「子串」匹配「解码后的工作区路径」或「原始 projectKey」，任一命中即整体排除该工作区。配置文件缺失或损坏时 G1 直接报错退出（fail-closed，拒绝无保护运行）。",
+  "excluded": []
+}

package/lib/index.js

@@ -0,0 +1,299 @@
+/**
+ * dsh-mem0-memory — DSH 薄桥插件
+ *
+ * 监听 `agent/pre-step`，取进入步骤的最后一条真实 user 消息作查询，
+ * 调 mem0-server（127.0.0.1:18200 /search）召回相关记忆，
+ * 把 <relevant-memories> 块注入到步骤消息批次（在 claimed 消息之后插入），
+ * 等效 OpenClaw mem0-memory 插件的 before_prompt_build + appendSystemContext。
+ *
+ * 后处理移植自 OpenClaw 侧 recall.js（🔵 已读源码）：
+ *   - 词法重叠 boost（≤0.2）
+ *   - 精确去重 + 中文 bigram Jaccard 语义去重（阈值 0.4）
+ *   - scoreThreshold 过滤（默认 0.15）+ limit（默认 5）+ tokenBudget（默认 2000）
+ *
+ * 设计原则（主文档 §3.3）：**薄**——单次 HTTP + 纯 JS 后处理，不做多轮 agent 循环。
+ * （OpenClaw active-memory 死于过度设计，mem0-memory 活是因为简单直接。）
+ *
+ * 配置（profile cordis.patch.yml 覆盖）：
+ *   - id: mem0-memory
+ *     config:
+ *       serverUrl: http://127.0.0.1:18200
+ *       enabled: true
+ *       limit: 5            # 注入条数上限
+ *       scoreThreshold: 0.15
+ *       tokenBudget: 2000
+ *       source: DSH         # 可选：仅召回指定 source（G4）
+ *       probePath: ""       # 可选：排障探针日志文件路径（默认空=关闭；设置后才写文件）
+ *       autoImport: true    # 会话结束自动增量导入（默认开；关 = 手动 dsh-mem0-import）
+ */
+
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+
+const PKG_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+const MEM0_SERVER = "http://127.0.0.1:18200";
+// 召回超时对齐 OpenClaw mem0-memory 插件（index.js timeoutMs: 20000）。
+// 实测 mem0 /search 冷/热态 5-10s（embedding 走 SiliconFlow），5s 必超时。
+const MEM0_SEARCH_TIMEOUT_MS = 20000;
+const MAX_BLOCK_CHARS = 8000;          // 注入块字符上限（约 tokenBudget*4 的保险）
+
+// ─── 后处理（移植 OpenClaw recall.js）────────────────────────────────────
+const RECALL_STOPWORDS = new Set([
+  "what", "when", "where", "which", "who", "whom", "whose", "why", "how",
+  "did", "does", "is", "are", "was", "were", "the", "and", "for", "with",
+  "from", "that", "this", "your", "you",
+]);
+const RECALL_TOKEN_RE = /[a-z0-9\u4e00-\u9fa5]{2,}/gi;
+
+function buildQueryProfile(queryText) {
+  const text = String(queryText || "").trim();
+  const allTokens = text.toLowerCase().match(RECALL_TOKEN_RE) ?? [];
+  return { tokens: allTokens.filter((t) => !RECALL_STOPWORDS.has(t)) };
+}
+
+function lexicalOverlapBoost(tokens, text) {
+  if (tokens.length === 0 || !text) return 0;
+  const haystack = ` ${text.toLowerCase()} `;
+  let matched = 0;
+  for (const token of tokens.slice(0, 8)) {
+    if (haystack.includes(` ${token} `) || haystack.includes(token)) matched += 1;
+  }
+  return Math.min(0.2, (matched / Math.min(tokens.length, 4)) * 0.2);
+}
+
+function extractContentWords(text) {
+  const normalized = String(text || "").toLowerCase().replace(/[^\p{L}\p{N}]/gu, " ").trim();
+  const words = normalized.split(/\s+/).filter((w) => w.length >= 2);
+  const ngrams = new Set();
+  for (const word of words) {
+    if (/[\p{Script=Han}]/u.test(word)) {
+      for (let i = 0; i < word.length - 1; i++) ngrams.add(word.slice(i, i + 2));
+    } else {
+      ngrams.add(word);
+    }
+  }
+  return ngrams;
+}
+
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const w of a) if (b.has(w)) inter++;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+
+function semanticDedup(items, threshold = 0.4) {
+  const result = [];
+  const sets = items.map((i) => extractContentWords(i.memory ?? ""));
+  for (let i = 0; i < items.length; i++) {
+    let dup = false;
+    for (const kept of result) {
+      const idx = items.indexOf(kept);
+      if (jaccard(sets[i], sets[idx]) >= threshold) { dup = true; break; }
+    }
+    if (!dup) result.push(items[i]);
+  }
+  return result;
+}
+
+function pickMemories(items, query, limit, scoreThreshold) {
+  const profile = buildQueryProfile(query);
+  const sorted = [...items].sort((a, b) => {
+    const sa = (a.score ?? 0) + lexicalOverlapBoost(profile.tokens, a.memory ?? "");
+    const sb = (b.score ?? 0) + lexicalOverlapBoost(profile.tokens, b.memory ?? "");
+    return sb - sa;
+  });
+  const seen = new Set();
+  const deduped = [];
+  for (const item of sorted) {
+    const key = `memory:${String(item.memory ?? "").toLowerCase().replace(/\s+/g, " ").slice(0, 200)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(item);
+  }
+  return semanticDedup(deduped)
+    .filter((item) => (item.score ?? 0) >= scoreThreshold)
+    .slice(0, limit);
+}
+
+function formatBlock(items) {
+  if (items.length === 0) return "";
+  const lines = [
+    "[MEM0-RECALL]",
+    "<relevant-memories>",
+    "以下是从 Mem0 长期记忆中召回的相关记忆，优先参考这些内容回答用户问题。",
+  ];
+  let used = 0;
+  for (const item of items) {
+    const content = String(item.memory ?? "").trim();
+    if (!content) continue;
+    const entry = `<memory id="${item.id}">\n${content}\n</memory>`;
+    if (used + entry.length + 1 > MAX_BLOCK_CHARS) break;
+    lines.push(entry);
+    used += entry.length + 1;
+  }
+  if (lines.length <= 3) return "";
+  lines.push("</relevant-memories>");
+  return lines.join("\n");
+}
+
+// ─── 召回（单次 HTTP，薄）────────────────────────────────────────────────
+async function recallMemories(config, query) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), config.timeoutMs ?? MEM0_SEARCH_TIMEOUT_MS);
+  try {
+    const body = { query, limit: 20 };
+    if (config.source) body.source = config.source;   // G4: 按来源过滤
+    const resp = await fetch(`${config.serverUrl ?? MEM0_SERVER}/search`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!resp.ok) return { ok: false, error: `HTTP ${resp.status}` };
+    const data = await resp.json();
+    if (!data.ok) return { ok: false, error: data.error || "search failed" };
+    const picked = pickMemories(data.results ?? [], query, config.limit ?? 5, config.scoreThreshold ?? 0.15);
+    const block = formatBlock(picked);
+    return { ok: true, block, count: picked.length, results: picked };
+  } catch (e) {
+    return { ok: false, error: e.name === "AbortError" ? "timeout" : e.message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── 消息提取（取最后一条真实 user 消息）─────────────────────────────────
+function flattenMessageContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => {
+      if (typeof b === "string") return b;
+      if (b && typeof b === "object") {
+        if (typeof b.text === "string") return b.text;
+        if (typeof b.content === "string") return b.content;
+      }
+      return "";
+    }).join("");
+  }
+  if (content && typeof content === "object") {
+    if (typeof content.text === "string") return content.text;
+  }
+  return "";
+}
+
+function extractLastUserText(messages) {
+  if (!Array.isArray(messages)) return null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg || msg.role !== "user") continue;
+    const text = flattenMessageContent(msg.content).trim();
+    if (text && !text.includes("<relevant-memories>")) return text;
+  }
+  return null;
+}
+
+// ─── 插件入口 ────────────────────────────────────────────────────────────
+export const name = "dsh-mem0-memory";
+export const inject = ["agents"];
+
+export async function apply(ctx, config = {}) {
+  // 探针（排障用，默认关闭）：设置 config.probePath 后，apply 执行即写文件——
+  // 用于区分「插件未加载」vs「加载了但 pre-step 未触发」。默认不写任何文件。
+  const probePath = config.probePath ? path.resolve(String(config.probePath)) : "";
+  const probe = async (msg) => {
+    if (!probePath) return;
+    try {
+      const fs = await import("node:fs");
+      fs.appendFileSync(probePath, `[${new Date().toISOString()}] ${msg}\n`, "utf8");
+    } catch (e) {}
+  };
+  await probe(`apply() executed, config=${JSON.stringify(config)}`);
+
+  const cfg = {
+    enabled: config.enabled !== false,
+    serverUrl: config.serverUrl ?? MEM0_SERVER,
+    limit: config.limit ?? 5,
+    scoreThreshold: config.scoreThreshold ?? 0.15,
+    tokenBudget: config.tokenBudget ?? 2000,
+    timeoutMs: config.timeoutMs ?? MEM0_SEARCH_TIMEOUT_MS,
+    source: config.source,   // 可选
+    autoImport: config.autoImport !== false,  // 会话结束自动增量导入（默认开，三档机制①）
+  };
+  if (!cfg.enabled) {
+    ctx.logger?.info("[mem0-memory] disabled");
+    return;
+  }
+
+  // ─── 会话结束自动增量导入（P2.4：session/disposed 钩子）───────────────
+  // fire-and-forget：不阻塞 dispose；子进程间有 .import.lock 互斥（并发安全）。
+  // import 脚本定位：插件包内 bin/dsh-mem0-import.mjs（无需用户配置路径）。
+  if (cfg.autoImport) {
+    const importCmd = path.join(PKG_DIR, "bin", "dsh-mem0-import.mjs");
+    ctx.on("session/disposed", (session) => {
+      const sessionId = session?.id ?? session?.sessionId ?? "";
+      probe(`session/disposed fired: ${sessionId}`);
+      spawn(process.execPath, [importCmd, "--since-last"], {
+        stdio: "ignore",
+        detached: false,
+      }).on("error", (e) => {
+        ctx.logger?.warn(`[mem0-memory] auto-import spawn failed: ${e.message}`);
+      });
+      ctx.logger?.info(`[mem0-memory] auto-import triggered (session ${sessionId || "?"})`);
+    });
+    ctx.logger?.info("[mem0-memory] auto-import armed (session/disposed)");
+  }
+
+  ctx.on("agent/pre-step", async ({ messages, signal }, next) => {
+    // 探针（排障用）：pre-step 触发即写文件
+    await probe(`pre-step fired, messages=${Array.isArray(messages) ? messages.length : "?"}, roles=${Array.isArray(messages) ? messages.map(m => m.role).join(",") : "?"}`);
+
+    // 先让下游决定本步骤的消息批次
+    const decision = await next();
+    await probe(`decision kind=${decision.kind}, decision.messages=${Array.isArray(decision.messages) ? decision.messages.length : "?"}`);
+
+    if (decision.kind !== "enter" || !Array.isArray(decision.messages)) return decision;
+
+    try {
+      const query = extractLastUserText(decision.messages);
+      await probe(`query extracted: ${query ? query.slice(0, 80) : "NULL"}`);
+      if (!query) return decision;
+
+      const result = await recallMemories(cfg, query);
+      await probe(`recall result: ok=${result.ok}, count=${result.count ?? "?"}, block=${(result.block || "").length}chars, error=${result.error || "none"}`);
+      if (!result.ok || !result.block) {
+        ctx.logger?.info(`[mem0-memory] recall skip: ${result.error || "no block"} (query="${query.slice(0, 60)}")`);
+        return decision;
+      }
+
+      ctx.logger?.info(`[mem0-memory] recall ${result.count} memories (${result.block.length} chars)`);
+
+      // 注入：在最后一条 claimed 消息之后插入记忆块。
+      // 必须带消息 id 且 content 用文本块数组 —— DSH 的 user/message 事件校验要求
+      // message.id 为非空字符串、content 为块数组，缺失会把整个 session 持久化日志判为损坏。
+      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" },
+      };
+      const finalMessages = decision.messages.toSpliced(lastClaimedIndex + 1, 0, injected);
+      await probe(`injected! finalMessages=${finalMessages.length}`);
+      return {
+        kind: "enter",
+        messages: finalMessages,
+      };
+    } catch (e) {
+      await probe(`EXCEPTION: ${e.message}`);
+      // 绝不让记忆召回破坏步骤（退化：不注入）
+      ctx.logger?.warn(`[mem0-memory] recall failed: ${e.message}`);
+      return decision;
+    }
+  });
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "dsh-mem0-memory",
+  "version": "0.1.0",
+  "description": "Thin bridge: recall Mem0 memories into DSH agent context via agent/pre-step injection.",
+  "type": "module",
+  "main": "lib/index.js",
+  "bin": {
+    "dsh-mem0-import": "bin/dsh-mem0-import.mjs",
+    "dsh-mem0-search": "bin/dsh-mem0-search.mjs"
+  },
+  "files": [
+    "lib/index.js",
+    "bin/dsh-mem0-import.mjs",
+    "bin/dsh-mem0-search.mjs",
+    "scripts/g1-session-parser.mjs",
+    "scripts/mem0-server.py",
+    "scripts/setup.py",
+    "scripts/start-server.bat",
+    "scripts/start-server.sh",
+    "scripts/.env.example",
+    "scripts/excluded-workspaces.json",
+    "cordis.patch.yml",
+    "excluded-workspaces.example.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent-loop": "^0.1.0-rc.6"
+  },
+  "license": "MIT"
+}