dsh-memory-core 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0
+
+- 首版：按 preset 隔离的记忆包（与 dsh-memory-shield 配套）。
+- 五轨记忆（memory / user / project / key / daily），lite 三轨 + full 五轨。
+- `memory_core` 工具：add / list / replace / remove / archive。
+- `memory-core:snapshot` 注入段（常驻记忆 + 引导 + 写看门狗提醒）。
+- `/api/memory-core` 路由：status / entries / entry / manage。
+- `manage.html` 管理页：浏览、编辑、删除、归档、待确认队列。
+- 写看门狗：连续 N 个空回合提醒写记忆，写入后清零。

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sacredbluedragon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,104 @@
-# Temporary Holding Version
+# dsh-memory-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+遮蔽会话的 companion 记忆包。与 [dsh-memory-shield (shield)](../dsh-memory-shield/) 配对使用：
+
+- **shield 包**：挡住其他记忆插件（dsh-memory-evolve 等）的注入和工具，让指定 preset 的会话拥有干净的上下文。
+- **companion 包**：给被遮蔽的会话加一套隔离的记忆存储——独立数据目录、独立工具、独立面板，与普通会话的 dsh-memory-evolve 完全隔离。
+
+## 安装
+
+```bash
+dsh plugin --profile web add dsh-memory-core
+```
+
+装完还要**手动启用一次**：包默认是关闭的（`cordis.patch.yml` 里 `disabled: true`），不启用的话重启后没有工具、没有记忆注入、面板也是空的，而且不报错。
+
+1. 打开 `%USERPROFILE%\.dsh\profiles\web\cordis.patch.yml`（macOS/Linux 下是 `~/.dsh/profiles/web/cordis.patch.yml`）。
+2. 找到 `id: memory-core` 那一段，把 `disabled: true` 改成 `disabled: false`，或直接删掉这一行。
+3. 完全退出并重启 DSH，再新建会话。
+
+前提：已安装 `dsh-memory-shield`（shield 包）。两包配对时建议只把 companion 挂进需要独立记忆的那个 preset，不要放进全局 `dsh.profile.bundles`。
+
+## 配置
+
+| 配置项 | 默认值 | 说明 |
+|---|---|---|
+| `memoryTracks` | `"lite"` | 记忆轨模式：`lite` = 三轨 memory/user/key；`full` = 五轨 memory/user/project/key/daily |
+| `presetName` | `"default"` | preset 名称（影响数据目录落点） |
+| `memoryDir` | `""` | 记忆数据目录（留空自动解析到 `~/.dsh-plugin-data/<presetName>/memory/`） |
+| `writeGuard` | `true` | key 轨写入走待确认队列（防误写） |
+| `writeGuardThreshold` | `2` | 连续 N 轮没写记忆就提醒 |
+| `snapshotOrder` | `500` | memory-core:snapshot 注入顺序 |
+
+## 记忆轨
+
+### lite 模式（默认，三轨）
+
+| 轨 | 文件 | 用途 |
+|---|---|---|
+| `memory` | `memory.md` | 长期记忆（跨会话复用） |
+| `user` | `user.md` | 用户偏好与画像 |
+| `key` | `key.md` | 关键事实（走待确认队列） |
+
+### full 模式（五轨）
+
+在 lite 三轨基础上加：
+
+| 轨 | 文件 | 用途 |
+|---|---|---|
+| `project` | `projects/<hash>/memory.md` | 项目记忆（按 cwd 隔离） |
+| `daily` | `daily/<date>.md` | 每日日志（编年史） |
+
+切 full 模式：把配置里 `memoryTracks` 改成 `"full"`，重启会话即可。
+
+## 工具
+
+注册了一个 `memory_core` 工具，agent 可在遮蔽会话里调用：
+
+```
+memory_core action=add target=memory content="用户喜欢用中文回复"
+memory_core action=list target=user
+memory_core action=replace target=key match="旧内容" content="新内容"
+memory_core action=remove target=memory match="要删的子串"
+memory_core action=archive target=user match="要归档的子串"
+```
+
+## 面板
+
+插件详情页里有一个小面板：
+
+- 显示当前模式（lite/full）
+- 各轨记忆条数
+- 待确认队列条数
+- 「打开记忆管理面板」按钮——在独立窗口打开 `manage.html`，可查看/修改/归档各轨记忆
+
+## 与 dsh-memory-evolve 的关系
+
+- 本包的存储层（`lib/store.js`）**参考并借鉴了 [dsh-memory-evolve](https://github.com/csyangwen/dsh-memory-evolve)**（作者 csyangwen）的实现，做了隔离适配：数据目录独立、工具名独立、注入 section 同名（`memory-core:snapshot`）但内容是自己的。
+- 普通会话的 dsh-memory-evolve 面板看不到遮蔽会话的记忆，反之亦然。
+- 如果用户想要完整的五轨记忆 + 待确认审查 + 合并梳理，可以在普通会话里装 dsh-memory-evolve，本包只负责给遮蔽会话提供最小可用的记忆能力。
+
+## 目录结构
+
+```
+packages/dsh-memory-core/
+├── index.js          # 插件入口（memory_core 工具 + snapshot 注入 + webServer API）
+├── client.js         # 插件详情页小面板
+├── manage.html       # 独立窗口记忆管理页
+├── package.json
+├── README.md
+└── lib/
+    ├── constants.js  # PLUGIN_NAME
+    ├── defaults.js   # DEFAULTS + resolveMemoryDir
+    ├── schema.js     # schemastery config schema
+    ├── tracks.js     # 轨道定义（lite/full）
+    ├── store.js      # MemoryStore + SuggestionQueue + ArchiveStore（抄自 evolve）
+    ├── render.js     # 注入渲染（预算分配 + 看门狗提醒）
+    ├── watchdog.js   # 写入看门狗（连续 N 轮没写就提醒）
+    ├── budgets.js    # 注入预算与检索参数
+    └── entryid.js    # 条目身份证
+```
+
+## License
+
+MIT

package/client.js

@@ -0,0 +1,117 @@
+/**
+ * dsh-memory-core —— 浏览器半端：插件详情页的状态面板。
+ *
+ * 显示当前模式、各轨记忆条数、待确认队列，以及打开独立管理页 manage.html 的按钮。
+ * 挂载点：plugins.bundle.config（key = 包名）。
+ */
+window.__ModuleLoader__.load({
+  id: "dsh-memory-core",
+  factory: (require) => {
+    const React = require("react");
+    const h = React.createElement;
+
+    const PKG = "dsh-memory-core";
+    const API = "/api/memory-core";
+    const jget = async (p) => (await fetch(API + p, { credentials: "same-origin" })).json();
+
+    const CSS = `
+[data-pmc-page]{display:flex;flex-direction:column;gap:10px;padding:4px 2px 10px;max-width:640px;font-size:13px;}
+[data-pmc-head]{display:flex;align-items:baseline;gap:8px;flex-wrap:wrap;}
+[data-pmc-title]{font-size:14px;font-weight:600;}
+[data-pmc-sub]{font-size:12px;color:var(--dsw-alias-label-tertiary,#8a9099);}
+[data-pmc-sec]{display:flex;flex-direction:column;gap:6px;border-top:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.18));padding-top:10px;}
+[data-pmc-row]{display:flex;align-items:center;gap:10px;flex-wrap:wrap;min-height:26px;}
+[data-pmc-name]{min-width:100px;flex:none;}
+[data-pmc-val]{flex:1;color:var(--dsw-alias-label-secondary,#6b7280);}
+[data-pmc-btn]{font-size:12px;min-height:26px;padding:2px 10px;border-radius:6px;cursor:pointer;border:1px solid var(--dsw-alias-border-l2,rgba(255,255,255,.16));background:transparent;color:inherit;flex:none;}
+[data-pmc-note]{font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary,#8a9099);}
+[data-pmc-chip]{display:inline-block;padding:1px 8px;border-radius:999px;font-size:11px;background:var(--dsw-alias-bg-weak,rgba(128,128,128,.1));}
+[data-pmc-chip="ok"]{background:#e6f5ec;color:#1a7f4b;}
+[data-pmc-chip="warn"]{background:#fdf3e3;color:#b26a00;}
+`;
+
+    const TRACKS_LITE = ["memory", "user", "key"];
+    const TRACKS_FULL = ["memory", "user", "project", "key", "daily"];
+    const TRACK_LABELS = { memory: "长期记忆", user: "用户档案", project: "项目记忆", key: "关键事实", daily: "每日日志" };
+
+    function Panel() {
+      const [st, setSt] = React.useState(null);
+      const [err, setErr] = React.useState("");
+
+      const load = React.useCallback(async () => {
+        try {
+          // 拉各轨条数 + 待确认（后端没有 /pending，pending 挂在 /entries 的返回里）
+          const tracks = TRACKS_LITE; // 默认 lite，full 模式需要切配置
+          const counts = {};
+          let pendingCount = 0;
+          for (const t of tracks) {
+            try {
+              const j = await jget(`/entries?track=${t}`);
+              counts[t] = j.ok ? j.data.count : 0;
+              if (j.ok && Array.isArray(j.data.pending)) pendingCount += j.data.pending.length;
+            } catch { counts[t] = 0; }
+          }
+          setSt({ counts, pendingCount, tracks });
+          setErr("");
+        } catch (e) {
+          setErr(String(e?.message || e));
+        }
+      }, []);
+
+      React.useEffect(() => {
+        load();
+        const t = setInterval(load, 10000);
+        return () => clearInterval(t);
+      }, [load]);
+
+      if (err) return h("div", { "data-pmc-page": "" }, h("div", { "data-pmc-note": "" }, "状态读取失败：" + err));
+      if (!st) return h("div", { "data-pmc-page": "" }, h("div", { "data-pmc-note": "" }, "读取中…"));
+
+      return h("div", { "data-pmc-page": "" },
+        h("div", { "data-pmc-head": "" },
+          h("span", { "data-pmc-title": "" }, "遮蔽会话记忆"),
+          h("span", { "data-pmc-sub": "" }, "companion 模式 · 数据与普通会话完全隔离")),
+        h("div", { "data-pmc-sec": "" },
+          h("div", { "data-pmc-row": "" },
+            h("span", { "data-pmc-name": "" }, "当前模式"),
+            h("span", { "data-pmc-val": "" }, "lite（三轨 memory/user/key）"),
+            h("span", { "data-pmc-chip": "ok" }, "默认")),
+          h("div", { "data-pmc-row": "" },
+            h("span", { "data-pmc-name": "" }, "待确认记忆"),
+            h("span", { "data-pmc-val": "" }, st.pendingCount > 0 ? `${st.pendingCount} 条待确认` : "无"),
+            st.pendingCount > 0 ? h("span", { "data-pmc-chip": "warn" }, "需处理") : null)),
+        h("div", { "data-pmc-sec": "" },
+          ...st.tracks.map((t) =>
+            h("div", { "data-pmc-row": "", key: t },
+              h("span", { "data-pmc-name": "" }, TRACK_LABELS[t] || t),
+              h("span", { "data-pmc-val": "" }, `${st.counts[t] || 0} 条`),
+            ),
+          )),
+        h("div", { "data-pmc-sec": "" },
+          h("div", { "data-pmc-row": "" },
+            h("a", { href: "/api/memory-core/manage", target: "_blank", rel: "noopener", "data-pmc-btn": "" }, "打开记忆管理面板"),
+          ),
+          h("div", { "data-pmc-note": "" },
+            "管理面板在独立窗口打开，可查看/修改/归档各轨记忆。升级到 full 模式（五轨）需在配置里改 memoryTracks=full。")),
+      );
+    }
+
+    return {
+      inject: ["slots"],
+      apply(ctx) {
+        const style = document.createElement("style");
+        style.setAttribute("data-plugin-css", PKG);
+        style.textContent = CSS;
+        document.head.appendChild(style);
+        if (typeof ctx.effect === "function") ctx.effect(() => () => style.remove(), `${PKG}: 面板样式`);
+
+        const slots = (typeof ctx.get === "function" ? ctx.get("slots") : undefined) || ctx.slots;
+        if (!slots) return;
+        slots.inject("plugins.bundle.config", () => slots.register(
+          { name: "plugins.bundle.config", key: PKG },
+          Panel,
+        ));
+      },
+    };
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,8 @@
+# dsh bundle patch: 插入本插件，但默认关闭。
+# 本包一旦装进 profile 就会被所有会话加载（注册 memory_core 工具 + memory-core:snapshot 注入），
+# 因此默认 disabled: true，只在目标 preset 里显式启用。
+# 要用于某个 preset：在该 preset 的 plugins 里显式挂载本包，并去掉 disabled（或写 disabled: false）。
+- insert:
+    - id: memory-core
+      name: 'dsh-memory-core'
+      disabled: true

package/index.js

@@ -0,0 +1,291 @@
+/**
+ * dsh-memory-core —— 遮蔽会话的 companion 记忆包。
+ *
+ * 与 shield 包配对使用：shield 挡住其他记忆插件的注入，本包给遮蔽会话加一套
+ * 隔离的记忆存储（独立数据目录，与普通会话的 dsh-memory-evolve 完全隔离）。
+ *
+ * 默认 lite 模式（三轨 memory/user/key）；切 full 模式（五轨）由用户在设置里改。
+ */
+import { PLUGIN_NAME } from "./lib/constants.js";
+import { DEFAULTS, resolveMemoryDir } from "./lib/defaults.js";
+import { MemoryStore, SuggestionQueue, ArchiveStore } from "./lib/store.js";
+import { renderSnapshot } from "./lib/render.js";
+import { writeGapCounter } from "./lib/watchdog.js";
+import { tracksOf, TRACK_FILES, PENDING_FILE } from "./lib/tracks.js";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const name = PLUGIN_NAME;
+const inject = ["systemPrompt", "tools", "webServer"];
+
+const LOOPBACK = new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
+
+/** 同源守卫：挡 DNS 重绑定与跨站请求；返回空串表示放行 */
+function sameOriginBlocked(req) {
+	const host = String(req.headers?.host ?? "").split(":")[0];
+	const origin = req.headers?.origin;
+	if (origin) {
+		let oh = "";
+		try {
+			oh = new URL(origin).hostname;
+		} catch {
+			return "非法 Origin 头";
+		}
+		if (oh !== host && !(LOOPBACK.has(host) && LOOPBACK.has(oh))) return "跨源访问被拒绝";
+	}
+	const site = req.headers?.["sec-fetch-site"];
+	if (!origin && site && site !== "same-origin" && site !== "none") return "跨站请求被拒绝";
+	return "";
+}
+
+function apply(ctx, config) {
+	const s = { ...DEFAULTS, ...(config ?? {}) };
+	const memoryDir = resolveMemoryDir(s);
+	if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true });
+
+	const store = new MemoryStore(memoryDir, { injectionScan: true, memoryTracks: s.memoryTracks });
+	const pending = new SuggestionQueue(join(memoryDir, PENDING_FILE));
+	const archive = new ArchiveStore(memoryDir);
+
+	// ── memory_core 工具 ────────────────────────────────────────
+	const writeGap = writeGapCounter(ctx, () => s.writeGuard === true);
+	/** 写入成功后清 gap，否则看门狗每轮都会提醒「没写记忆」 */
+	const markWrote = (agent) => {
+		try {
+			writeGap?.noteWrite?.(agent);
+		} catch {}
+	};
+
+	const memoryTool = {
+		name: "memory_core",
+		description:
+			"读写遮蔽会话的隔离记忆（与全局 memory 工具互不影响）。target 可选：memory（长期记忆）、user（用户偏好）、key（关键事实，需确认）、project（项目记忆，需 full 模式）、daily（每日日志，需 full 模式）。",
+		parameters: {
+			type: "object",
+			properties: {
+				action: { type: "string", enum: ["add", "list", "replace", "remove", "archive"], description: "操作" },
+				target: { type: "string", enum: ["memory", "user", "key", "project", "daily"], description: "记忆轨" },
+				content: { type: "string", description: "新内容（add/replace 时必填）" },
+				match: { type: "string", description: "匹配子串（replace/remove/archive 时必填）" },
+			},
+			required: ["action", "target"],
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					ok: { type: "boolean" },
+					message: { type: "string" },
+					target: { type: "string" },
+					entries: { type: "array", items: { type: "string" } },
+					count: { type: "integer" },
+					queued: { type: "boolean" },
+				},
+				required: ["ok", "message"],
+			},
+			render: (_args, value) => [{ type: "text", text: value.message || (value.ok ? "ok" : "failed") }],
+		},
+		async execute({ action, target, content, match }, exec) {
+			try {
+				if (action === "list") {
+					const entries = store.entriesOf(target, exec?.agent);
+					return { ok: true, message: `${target} 轨 ${entries.length} 条`, target, entries, count: entries.length };
+				}
+				if (action === "add") {
+					if (!content) return { ok: false, message: "add 需要 content", target };
+					// key 轨走待确认队列
+					if (target === "key" && s.writeGuard) {
+						pending.append({ target, content, at: new Date().toISOString() });
+						return { ok: true, message: "已加入待确认队列，用户确认后生效。", target, queued: true };
+					}
+					const r = store.add(target, content, exec?.agent);
+					if (r?.ok !== false) markWrote(exec?.agent);
+					return { ok: r?.ok !== false, message: r?.message || `已写入 ${target}`, target };
+				}
+				if (action === "replace") {
+					if (!match || !content) return { ok: false, message: "replace 需要 match 和 content", target };
+					const r = store.replace(target, match, content, exec?.agent);
+					if (r?.ok !== false) markWrote(exec?.agent);
+					return { ok: r?.ok !== false, message: r?.message || `已替换 ${target}`, target };
+				}
+				if (action === "remove") {
+					if (!match) return { ok: false, message: "remove 需要 match", target };
+					const r = store.remove(target, match, exec?.agent);
+					return { ok: r?.ok !== false, message: r?.message || `已删除 ${target}`, target };
+				}
+				if (action === "archive") {
+					if (!match) return { ok: false, message: "archive 需要 match", target };
+					// 先写归档、再删主轨：两步之间断掉也不会丢内容
+					const peek = store.peek(target, match, exec?.agent);
+					if (peek?.ok === false) return { ok: false, message: peek.message || "找不到要归档的条目", target };
+					archive.append(target, peek.entry, exec?.agent?.session?.header?.cwd);
+					const r = store.remove(target, match, exec?.agent);
+					return { ok: r?.ok !== false, message: r?.message || `已归档 ${target}`, target };
+				}
+				return { ok: false, message: `未知 action: ${action}`, target };
+			} catch (e) {
+				return { ok: false, message: e?.message ?? String(e), target };
+			}
+		},
+	};
+	ctx.effect(() => ctx.tools.register(memoryTool), `${name}: memory tool`);
+
+	// ── memory-core:snapshot 注入 ──────────────────────────────
+	ctx.effect(
+		() =>
+			ctx.systemPrompt.context({
+				name: "memory-core:snapshot",
+				order: s.snapshotOrder,
+				text: () => renderSnapshot(store, s, writeGap, { agent: ctx.agent }),
+			}),
+		`${name}: memory-core:snapshot inject`,
+	);
+
+	// ── webServer API ───────────────────────────────────────────
+	ctx.effect(
+		() =>
+			ctx.webServer.register({
+				kind: "prefix",
+				path: "/api/memory-core",
+				handler: async (req, res) => {
+					const url = new URL(req.url, "http://127.0.0.1");
+					const json = (code, data) => {
+						res.writeHead(code, { "content-type": "application/json" });
+						res.end(JSON.stringify(data));
+					};
+					const denied = sameOriginBlocked(req);
+					if (denied) {
+						json(403, { ok: false, why: denied });
+						return;
+					}
+					const cwd = ctx.agent?.session?.header?.cwd;
+
+					// GET /manage —— 返回 manage.html 页面
+					if (req.method === "GET" && url.pathname === "/api/memory-core/manage") {
+						try {
+							const htmlPath = join(dirname(fileURLToPath(import.meta.url)), "manage.html");
+							const html = readFileSync(htmlPath, "utf8");
+							res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+							res.end(html);
+						} catch (e) {
+							json(500, { ok: false, why: e?.message ?? String(e) });
+						}
+						return;
+					}
+
+					// GET /status —— 面板状态
+					if (req.method === "GET" && url.pathname === "/api/memory-core/status") {
+						json(200, {
+							ok: true,
+							data: {
+								memoryEnabled: true,
+								memoryTracks: s.memoryTracks,
+								presetName: s.presetName,
+								memoryDir,
+								tracks: tracksOf(s.memoryTracks),
+							},
+						});
+						return;
+					}
+
+					// GET /entries?track=memory —— 列出某轨正式条目 + 待确认 + 归档
+					if (req.method === "GET" && url.pathname === "/api/memory-core/entries") {
+						const track = url.searchParams.get("track") || "memory";
+						try {
+							const entries = store.entriesOf(track, ctx.agent);
+							const pendingItems = pending.read().filter((p) => p.target === track);
+							const archived = archive.entriesOf(track, cwd);
+							json(200, { ok: true, data: { track, entries, pending: pendingItems, archived, count: entries.length } });
+						} catch (e) {
+							json(500, { ok: false, why: e?.message ?? String(e) });
+						}
+						return;
+					}
+
+					// POST /entry —— 所有写操作
+					if (req.method === "POST" && url.pathname === "/api/memory-core/entry") {
+						try {
+							const body = await new Promise((resolve) => {
+								let raw = "";
+								req.on("data", (c) => (raw += c));
+								req.on("end", () => {
+									try { resolve(JSON.parse(raw || "{}")); } catch { resolve({}); }
+								});
+							});
+							const { action, track, target, content, entry, match, index } = body;
+							const t = track || target || "memory";
+
+							if (action === "add") {
+								if (t === "key" && s.writeGuard) {
+									pending.append({ target: t, content, at: new Date().toISOString() });
+								} else {
+									const r = store.add(t, content, ctx.agent);
+									if (r?.ok !== false) markWrote(ctx.agent);
+								}
+							} else if (action === "replace" || action === "edit" || action === "saveEdit") {
+								const r = store.replace(t, match || entry, content, ctx.agent);
+								if (r?.ok !== false) markWrote(ctx.agent);
+							} else if (action === "delete" || action === "remove") {
+								store.remove(t, match || entry, ctx.agent);
+							} else if (action === "archive") {
+								// 先写归档、再删主轨（两步之间断掉也不丢内容）
+								archive.append(t, entry || match, cwd);
+								store.remove(t, match || entry, ctx.agent);
+							} else if (action === "confirm") {
+								// 待确认 → 正式写入；按内容匹配，不用前端索引（前端列表是过滤后的）
+								const items = pending.read();
+								const want = String(entry ?? "").trim();
+								const idx = items.findIndex((p) => String(p.content ?? "").trim() === want);
+								if (idx >= 0) {
+									const r = store.add(items[idx].target, items[idx].content, ctx.agent);
+									if (r?.ok !== false) {
+										items.splice(idx, 1);
+										pending.write(items);
+										markWrote(ctx.agent);
+									}
+								}
+							} else if (action === "reject") {
+								// 待确认 → 删除；同样按内容匹配
+								const items = pending.read();
+								const want = String(entry ?? "").trim();
+								const idx = items.findIndex(
+									(p) => p.target === t && String(p.content ?? "").trim() === want,
+								);
+								if (idx >= 0) {
+									items.splice(idx, 1);
+									pending.write(items);
+								}
+							} else if (action === "promote") {
+								// 归档 → 移回主轨：先写主轨，写成功才删归档
+								const r = store.add(t, entry, ctx.agent);
+								if (r?.ok !== false) {
+									archive.removeExact(t, entry, cwd);
+									markWrote(ctx.agent);
+								}
+							} else if (action === "removeArchive") {
+								archive.removeExact(t, entry, cwd);
+							} else {
+								return json(400, { ok: false, why: "unknown action: " + action });
+							}
+							json(200, { ok: true, data: { action, target: t } });
+						} catch (e) {
+							json(500, { ok: false, why: e?.message ?? String(e) });
+						}
+						return;
+					}
+
+					json(404, { ok: false, why: "not found" });
+				},
+			}),
+		`${name}: webServer API`,
+	);
+
+	ctx.logger.info(
+		`${name}: companion active — mode=${s.memoryTracks}, dir=${memoryDir}, tracks=${tracksOf(s.memoryTracks).join("/")}`,
+	);
+}
+
+export { apply, inject, name };
+export { Config } from "./lib/schema.js";

package/lib/budgets.js

@@ -0,0 +1,11 @@
+/**
+ * 注入预算与检索参数。
+ */
+export const BUDGETS = { memory: 1000, user: 600, key: 400 };
+export const TOTAL_BUDGET = 2000;
+export const KEY_TOP_N = 5;
+export const SEARCH_TOP_N = 5;
+export const KEY_SCAN_N = 8;
+export const KEY_EXTRA_CAP = 600;
+// key 轨加权挑条目时用的「重要词」：命中越多排越前；留空数组 = 不加权（原样按最近排序）
+export const KEY_HOT_WORDS = ['不要', '必须', '注意', '重要', '偏好', '禁止', '始终', '永远'];

package/lib/constants.js

@@ -0,0 +1,4 @@
+/**
+ * 不变的常量。
+ */
+export const PLUGIN_NAME = "dsh-memory-core";

package/lib/defaults.js

@@ -0,0 +1,23 @@
+/**
+ * 默认配置（companion 版）。
+ */
+import path from "node:path";
+import os from "node:os";
+
+export const DEFAULTS = {
+	memoryTracks: "lite", // "lite" = 三轨 memory/user/key；"full" = 五轨 memory/user/project/key/daily
+	presetName: "default",
+	memoryDir: "",
+	writeGuard: true,
+	writeGuardThreshold: 2,
+	snapshotOrder: 500,
+};
+
+/** 解析 memoryDir 落点。 */
+export function resolveMemoryDir(s) {
+	if (s.memoryDir) return s.memoryDir;
+	return process.env.DSH_MEMORY_CORE_DIR || path.join(
+		process.env.DSH_HOME || path.join(os.homedir(), ".dsh"),
+		"..", ".dsh-plugin-data", s.presetName, "memory",
+	);
+}