@modusensus/dsh-mneme 0.11.0 → 0.13.0

package/test/store.test.js

@@ -108,6 +108,26 @@ test("count excludes forgotten by default, includeForgotten opts in", () => {
   store.close();
 });
 
+test("countByType: same filters, no type clause — the distribution sums to count(undefined) (#597)", () => {
+  const store = openMemory();
+  const a = store.save({ type: "project", title: "t1", content: "c" });
+  store.save({ type: "project", title: "t2", content: "c" });
+  store.save({ type: "preference", title: "p", content: "c", importance: 5 });
+  store.setForget(a.id, true);
+  const counts = store.countByType();
+  assert.equal(counts.project, 1, "forgotten rows excluded (same口径 as count)");
+  assert.equal(counts.preference, 1);
+  assert.equal(
+    Object.keys(counts).reduce((n, k) => n + counts[k], 0),
+    store.count(),
+    "distribution sums to count(undefined)"
+  );
+  // 筛选同口径：带 minImportance 的分布合计 = 带同筛选的 count
+  const filtered = store.countByType({ minImportance: 5 });
+  assert.deepEqual(filtered, { preference: 1 }, "distribution honors the same filters as count");
+  store.close();
+});
+
 test("search matches title, content and tags", () => {
   const store = openMemory();
   store.save({ type: "project", title: "记忆插件", content: "c1", tags: [] });

package/test/summarize.test.js

@@ -386,6 +386,32 @@ test("#239-4 高峰时段解析：合法 / 多段 / 跨零点 / 星期前缀 /
   }
 });
 
+// #424：中文输入法带出来的全角等价符号曾让整串解析成 null——null 的语义是
+// 「未配置 = 不限制」，错峰闸门于是静默失效（用户写的全角逗号把省钱功能整个
+// 关掉，且没有任何提示）。本用例锁两件事：
+//   ① 全角逗号/冒号/数字/波浪号（含 U+301C）与全角星期前缀都归一成半角照常解析，
+//      判定与补跑（isInPeakWindow / nextOffPeakAt）走同一份解析、自动受益；
+//   ② 归一化只做等价映射不救错：值本身越界的写法（24:00）无论半角全角仍然非法，
+//      防的是「归一化顺手放宽了数值边界」这类静默语义漂移。
+test("#424 全角等价符号：归一后照常解析，不改变越界判定", () => {
+  assert.deepEqual(parsePeakSpec("00:00-03:00，04:00-06:00"), {
+    days: null,
+    windows: [{ start: 0, end: 180 }, { start: 240, end: 360 }]
+  }, "全角逗号切段");
+  assert.deepEqual(parsePeakSpec("00：00-03:00").windows, [{ start: 0, end: 180 }], "全角冒号");
+  assert.deepEqual(parsePeakSpec("００:00-03:00").windows, [{ start: 0, end: 180 }], "全角数字");
+  assert.deepEqual(parsePeakSpec("00:00～03:00").windows, [{ start: 0, end: 180 }], "全角波浪号当连接号");
+  assert.deepEqual(parsePeakSpec("00:00〜03:00").windows, [{ start: 0, end: 180 }], "U+301C 波浪号的另一半");
+  assert.deepEqual(parsePeakSpec("ｓａｔ，ｓｕｎ ２３:００-０６:００").days, [6, 7], "整串全角：星期前缀一起归一");
+  // 判定与补跑与解析共用同一入口，全角串在两侧行为一致
+  const at = (h, m) => new Date(2026, 10, 10, h, m, 0);
+  assert.equal(isInPeakWindow(at(1, 0), "００:００～０３:００"), true, "判定侧同一份解析");
+  assert.equal(nextOffPeakAt(at(1, 0), "00:00～03:00").getHours(), 3, "补跑时刻同一份解析");
+  // 归一化不救错：#424 的举例串本身还踩 24:00 越界，跨零点的正写是 04:00-00:00
+  assert.equal(parsePeakSpec("00:00-03:00,04:00-24:00"), null, "24:00 越界不因归一化变合法");
+  assert.equal(parsePeakSpec("２４:００-０６:００"), null, "全角形式不改变越界判定");
+});
+
 test("#239-4 高峰判定与补跑时刻（跨零点、右开区间）", () => {
   const at = (h, m) => new Date(2026, 8, 19, h, m, 30);
   assert.equal(isInPeakWindow(at(10, 0), "09:00-18:00"), true);

package/test/test-count-sync.test.js

@@ -32,8 +32,8 @@ test("双 README 的测试数处处一致（徽章与所有注释同数）", ()
 // 自动发版路径因此反倒成了漂移来源。
 test("applyTestCount 覆盖徽章与全部四种注释形状（真实漂移样本）", () => {
   const drifted = [
-    '<img src="https://img.shields.io/badge/tests-1431%20passed-3E63DD?style=flat-square" alt="tests">',
-    "[![tests](https://img.shields.io/badge/tests-1431%20passed-success)](https://github.com/slow-stack/mneme)",
+    '<img src="https://img.shields.io/badge/tests-1431%20total-3E63DD?style=flat-square" alt="tests">',
+    "[![tests](https://img.shields.io/badge/tests-1431%20total-success)](https://github.com/slow-stack/mneme)",
     "npm test        # 1431 个测试",
     "npm test           # 运行 1431 个测试",
     "test/                 # 1431 个 node:test 测试（审计与三轴线压测不变量）",
@@ -47,7 +47,7 @@ test("applyTestCount 覆盖徽章与全部四种注释形状（真实漂移样
 });
 
 test("applyTestCount 幂等：同一个数重复施加不再产生变化", () => {
-  const once = applyTestCount("tests-9%20passed-3E63DD\n# 9 个测试\n# 9 tests", 12);
+  const once = applyTestCount("tests-9%20total-3E63DD\n# 9 个测试\n# 9 tests", 12);
   assert.equal(applyTestCount(once, 12), once);
 });
 
@@ -58,3 +58,14 @@ test("applyTestCount 不碰历史版本表里的「N 测试全绿」", () => {
   const history = "| **v0.8.0** | 745 测试全绿 |\n| **v0.7.9** | 790 通过 |\n| v0.2.7 | 263 |";
   assert.equal(applyTestCount(history, 1437), history);
 });
+// 徽章报的是套件总数（`ℹ tests N`），不是通过数：本地 Windows 未开开发者模式时有一条
+// 符号链接用例被条件跳过，pass 数会比总数少 1。徽章字面量若退回 `%20passed`，读者会把它
+// 读成「N 个用例都通过了」，而它其实只表示「跑了 N 个套件」——#599 评审指出这一处措辞
+// 与实际口径不符。这条用例锁住那个词，改回 `passed` 立刻转红。
+test("双 README 的徽章字面量报总数（total），不谎称全部通过（passed）", () => {
+  for (const f of READMES) {
+    const text = readFileSync(f, "utf8");
+    assert.ok(/tests-\d+%20total/.test(text), `${f} 徽章必须写 %20total：${text.match(/tests-\d+%20\w+/)}`);
+    assert.ok(!/tests-\d+%20passed/.test(text), `${f} 徽章不得退回 %20passed`);
+  }
+});

package/test/tool-state-ignore.test.js

@@ -0,0 +1,65 @@
+// 锁「本地工具状态目录不得再进库」这条预防层，以及它配套的那条公开记档。
+//
+// 背景：2026-11-05 分支 feat/choro-panel-run-and-vectors 有一次粗粒度 git add 把 .mimosa/
+// （本地扫描钩子的状态目录，22 个文件）吸进了功能提交。文件两个提交后删掉了，但 blob 留在历史里、
+// 仓库是 PUBLIC，其中一条 hook-status 记着一台机器的绝对路径。删文件不是补偿——删只把暴露从
+// 目录树挪进对象存储（详见 SECURITY.md 的 2026-11-05 条目）。所以真正的防线只有两层：
+//
+//   1. 忽略规则（本文件第 1 组用例）——两个 .gitignore 都必须有。仓库里有两个 .mimosa 前缀
+//      （仓库根与 dsh-mneme/），只写一处时另一处照样会被 add 进来；历史重写那次就栽在这里。
+//   2. 忽略规则若被谁「顺手清掉」，本文件必须变红——否则下一次 add -A 又是同一个坑。
+//
+// 第 2 组用例守的是记档本身：SECURITY.md 要中英各一条（两份文档都在同一文件里，缺一边等于
+// 一种语言的读者看不到这件事），且条目里不得出现任何本机绝对路径——一份记录泄露的文档
+// 自己再泄露一次就是二次事故。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const repoRoot = path.dirname(pkgRoot);
+
+// 两个前缀都必须覆盖：历史上漏的就是「只写了 dsh-mneme/.mimosa」。
+const gitignores = [
+  { label: "仓库根 .gitignore", file: path.join(repoRoot, ".gitignore") },
+  { label: "dsh-mneme/.gitignore", file: path.join(pkgRoot, ".gitignore") },
+];
+
+for (const { label, file } of gitignores) {
+  test(`${label} 忽略 .mimosa/（本地工具状态不进库）`, () => {
+    const lines = readFileSync(file, "utf8").split(/\r?\n/).map((l) => l.trim());
+    assert.ok(
+      lines.includes(".mimosa/"),
+      `${label} 缺少 .mimosa/ 忽略规则。少了它，下一次 git add -A 会把钩子状态目录再带进库——` +
+        "2026-11-05 已经发生过一次，且 blob 至今仍可从历史取到。两处都要写：本仓有两个 .mimosa 前缀。"
+    );
+  });
+}
+
+test("SECURITY.md 有这次暴露的中英双份记档，且记档本身不含本机绝对路径", () => {
+  const doc = readFileSync(path.join(repoRoot, "SECURITY.md"), "utf8");
+  const headings = doc.split(/\r?\n/).filter((l) => l.startsWith("### 2026-11-05 — "));
+  assert.equal(
+    headings.length,
+    2,
+    `SECURITY.md 应有中英各一条「### 2026-11-05 — 」记档，实际 ${headings.length} 条。` +
+      "只写一边等于另一种语言的读者看不到这条已知暴露。"
+  );
+
+  // 记档里点名的是「本机目录结构」这件事本身，不能反过来把路径抄进去：
+  // 一条记录泄露的条目自己再泄露一次，就是把事故重演一遍。
+  // 只扫记档那两段（每条从标题到下一个 `### `），别拿整篇文档去撞历史遗留的行。
+  const lines = doc.split(/\r?\n/);
+  const section = [];
+  let inside = false;
+  for (const l of lines) {
+    if (l.startsWith("### ")) inside = l.startsWith("### 2026-11-05 — ");
+    if (inside) section.push(l);
+  }
+  const leaked = section.filter((l) =>
+    /[A-Za-z]:\\Users\\/.test(l) || l.includes("/Users/") || l.includes("AppData")
+  );
+  assert.deepEqual(leaked, [], `记档不得出现本机绝对路径，实际命中：${leaked.join(" | ")}`);
+});

package/test/tools-dto-schema-matrix.test.js

@@ -37,6 +37,7 @@ const TOOL_NAMES = [
   "memory_delete",
   "memory_forget",
   "memory_archive",
+  "memory_pin",
   "memory_register_document",
   "memory_runtime",
   "memory_organize",
@@ -126,7 +127,7 @@ test("工具矩阵与 TOOL_NAMES 清单一致（新增工具必须补进矩阵
   assert.deepEqual(Object.keys(byName).sort(), [...TOOL_NAMES].sort());
 });
 
-test("A 实跑：12 个工具每个可安全触达的分支，真实返回 ⊆ 声明的 output schema", async () => {
+test("A 实跑：13 个工具每个可安全触达的分支，真实返回 ⊆ 声明的 output schema", async () => {
   const { store, service, byName } = setup({ documentMemoryEnabled: true, organizeEnabled: true });
   const shapes = seedShapes(store);
   const annotated = shapes[shapes.length - 1];
@@ -202,6 +203,26 @@ test("A 实跑：12 个工具每个可安全触达的分支，真实返回 ⊆
   assert.equal((await drive(byName, "memory_archive", { id: archiveTarget.id, archived: false })).memory.archived, false);
   note("memory_archive");
 
+  // --- memory_pin（#249 第二批）：钉上 / 松开 / 幂等三条分支。
+  // 幂等单独驱动是因为回执要报 pinned:false 而不是报错，这条分支最容易在
+  // 「本来没钉也算成功」的语义上写错。
+  const pinTarget = store.save({ type: "constraint", title: "pin-me", content: "每轮都要在。", source: "test" });
+  const pinned = await drive(byName, "memory_pin", { id: pinTarget.id, note: "matrix" });
+  assert.equal(pinned.pinned, true);
+  assert.equal(pinned.memory_id, pinTarget.id);
+  assert.equal(pinned.note, "matrix");
+  // #593：pin 池由 pinnedInjectBudget 开关，本矩阵用的默认配置里它是 0（关闭），
+  // 所以钉上了也不会注入 —— 回执必须如实报 false。这里断 false 而不是 true，
+  // 锁的正是「返回成功不等于生效」那条口径。
+  assert.equal(pinned.injectable, false);
+  const unpinned = await drive(byName, "memory_pin", { id: pinTarget.id, unpin: true });
+  assert.equal(unpinned.pinned, false);
+  assert.equal(store.countPinned(), 0);
+  // 本来没钉时再松一次：返回 pinned:false，不抛错（幂等）。
+  assert.equal((await drive(byName, "memory_pin", { id: pinTarget.id, unpin: true })).pinned, false);
+  note("memory_pin");
+
+
   // --- set_scope_state（#471）：两个方向的分支——按下与松开各驱动一次 ---
   const pressed = await drive(byName, "set_scope_state", { dimension: "workspace", scope_value: "proj-alpha", state: "paused" });
   assert.equal(pressed.scope.state, "paused");
@@ -337,7 +358,7 @@ test("B' search / list / get 三个消费方共用同一份 item schema（#184
 
 // 同清单比对那条：opt-in 工具在默认配置下不在注册表里，C 层按 TOOL_NAMES 取
 // byName[name]，所以必须用暴露闸全开的配置，否则新工具的 schema 结构从未被检查。
-test("C 结构：全部 12 个工具的 output schema 闭合、required ⊆ properties、每项带 type", () => {
+test("C 结构：全部 13 个工具的 output schema 闭合、required ⊆ properties、每项带 type", () => {
   const { byName } = setup({ organizeEnabled: true });
   for (const name of TOOL_NAMES) {
     const schema = byName[name].output.schema;

package/test/tools.test.js

@@ -49,11 +49,148 @@ function walkSchema(node, path, problems) {
   }
 }
 
-test("registers eleven tools with correct names", () => {
+// memory_pin 的 injectable 回执必须跟注入侧同一个出口判定（#249 第二批）。
+//
+// 这条单独立在 tools 侧而不是注入侧：注入侧早已锁了「暂停作用域的行不进块」，
+// 但回执那句话是另一段代码，它可以照样撒谎——描述文案与 README 都写着
+// 「遗忘 / 归档 / 暂停作用域都优先于 pin」，而 execute 里只算了 forgotten/archived
+// 两个标志位，暂停作用域被漏掉。于是同一条行在「真会注入」与「被作用域挡住」
+// 两种完全相反的处境下都报 injectable: true，正是「返回成功不等于生效」那一类。
+//
+// 三档一起锁，是因为 filterPaused 的出口语义是分档的（见 src/scope-state.js:215）：
+//   enforce 开 → 真正剔掉，回执必须 false；
+//   只开 enabled（观察档）→ 不拦任何东西，回执必须 true（此时报 false 才是假警报）；
+//   两个都关 → 同样不拦，回执 true。
+function setupPinReceipt(config) {
+  // pin 预算从 config 读（src/service.js:1885），不是 injectCandidates 的入参——
+  // 传进调用参数会被静默忽略，那样这几条测试就测不到 pin 池。
+  const cfg = { pinnedInjectBudget: 5, ...config };
+  const store = createStore(":memory:");
+  // 注意 config 必须同时喂 service 与 tools：作用域闸在 service 侧构造，
+  // 而 memory_pin 的 execute 走的是 service 暴露的那个出口。
+  const service = createService({ store, mirror: null, config: cfg });
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  createTools(ctx, service, cfg, undefined);
+  return { store, service, byName: Object.fromEntries(registered.map((d) => [d.name, d])) };
+}
+
+test("memory_pin 的 injectable 如实报告暂停作用域（而不是只算遗忘与归档）", async () => {
+  const config = { scopeState: { enabled: true, enforce: true } };
+  const { store, service, byName } = setupPinReceipt(config);
+  const target = store.save({
+    type: "preference",
+    title: "暂停域里的偏好",
+    content: "这一路现在被按下了。",
+    workspace_scope: "proj-a",
+    importance: 5
+  });
+  await service.setScopeState({ dimension: "workspace", scope_value: "proj-a", state: "paused" });
+
+  const receipt = await byName.memory_pin.execute({ id: target.id }, undefined);
+  // 钉是钉上了（存储确实写了），但它在当前状态下不会被注入——两件事分开报。
+  assert.equal(receipt.pinned, true);
+  assert.equal(receipt.injectable, false, "暂停作用域里的行必须报 injectable: false");
+
+  // 回执与行为必须同向：真的注入一次，这条不许出现。
+  const pinnedStats = {};
+  const injected = service.injectCandidates({
+    query: "随便问个问题",
+    maxItems: 5,
+    pinnedStats
+  });
+  assert.equal(pinnedStats.source, "explicit", "这一条本身钉住了，口径应留在 explicit");
+  assert.ok(
+    !injected.some((m) => m.id === target.id),
+    "被暂停作用域挡住的行不该出现在注入块里（回执说 false，行为也必须一致）"
+  );
+});
+
+test("暂停作用域只开观察档（enforce 关）时，injectable 仍报 true", async () => {
+  // 观察档的语义是「记录本应被拦下多少，但一条都不拦」。此时那条行确实会进上下文，
+  // 所以回执必须报 true；报 false 会让用户以为它被挡了，比漏掉暂停作用域更难查。
+  const config = { scopeState: { enabled: true, enforce: false } };
+  const { store, service, byName } = setupPinReceipt(config);
+  const target = store.save({
+    type: "preference",
+    title: "观察档下的偏好",
+    content: "按下但未生效。",
+    workspace_scope: "proj-a",
+    importance: 5
+  });
+  await service.setScopeState({ dimension: "workspace", scope_value: "proj-a", state: "paused" });
+
+  const receipt = await byName.memory_pin.execute({ id: target.id }, undefined);
+  assert.equal(receipt.injectable, true, "观察档不拦任何东西，回执必须报 true");
+
+  const pinnedStats = {};
+  const injected = service.injectCandidates({
+    query: "随便问个问题",
+    maxItems: 5,
+    pinnedStats
+  });
+  assert.ok(
+    injected.some((m) => m.id === target.id),
+    "观察档下这条应当照常注入，回执与行为必须同向"
+  );
+});
+
+test("pinnedInjectBudget=0（默认，pin 池整体关闭）时 injectable 必须报 false", async () => {
+  // #593 遗留缺口：pin 池由 pinnedInjectBudget 开关（src/service.js:1885 的
+  // pinnedBudget > 0 才读表选路），默认 0。上一版只看遗忘/归档/暂停作用域，
+  // 预算为 0 的一条照样报 true——钉住成功但一条都不会被注入，正是「返回成功
+  // 不等于生效」。这里把默认档（不传任何 config）与显式 0 两档一起锁。
+  const { store, service, byName } = setupPinReceipt({ pinnedInjectBudget: 0 });
+  const target = store.save({ type: "preference", title: "预算关着", content: "x", importance: 5 });
+  const receipt = await byName.memory_pin.execute({ id: target.id }, undefined);
+  assert.equal(receipt.pinned, true, "钉的动作确实成功了，两件事分开报");
+  assert.equal(receipt.injectable, false, "预算 0 = pin 池关闭，此刻不会经 pin 通道注入，回执必须报 false");
+
+  // 这里不断言「注入序列里一定没有它」：预算 0 关掉的是 **pin 通道**，不是这条记忆
+  // 本身——它仍可能靠自己的重要性走常规候选路进块（既有用例
+  // inject-pin-explicit.test.js:176 锁的是「注入序列与改前逐字节一致」，不是「不出现」）。
+});
+
+test("autoInject=false（注入器未注册）时 injectable 必须报 false", async () => {
+  // #596 评审指出的第二处：autoInject 是 pin 通道的总闸，关着时 src/index.js:617
+  // 根本不注册注入器——pin 段一行都跑不到，回执照样报 true 就是同一个「返回成功
+  // 不等于生效」。判据按「只有显式 false 才算关」写，故这里显式传 false。
+  const { store, byName } = setupPinReceipt({ autoInject: false });
+  const target = store.save({ type: "preference", title: "注入器没挂", content: "x", importance: 5 });
+  const receipt = await byName.memory_pin.execute({ id: target.id }, undefined);
+  assert.equal(receipt.pinned, true, "钉的动作照样成功，两件事分开报");
+  assert.equal(receipt.injectable, false, "autoInject 关 = 注入器不存在，此刻不可能经 pin 通道注入");
+
+  // 反例：不显式传 autoInject 时不能因为 config 里没这个键就误报 false
+  // （createTools 的测试直连场景拿不到已填 defaults 的 config）。
+  const on = setupPinReceipt({});
+  const t2 = on.store.save({ type: "preference", title: "默认开", content: "y", importance: 5 });
+  assert.equal(
+    (await on.byName.memory_pin.execute({ id: t2.id }, undefined)).injectable,
+    true,
+    "未显式关 autoInject 时必须报 true（预算 5 已满足）"
+  );
+});
+
+test("遗忘或归档的 pin：injectable 报 false（原有两项不能被这次改动弄丢）", async () => {
+  const { store, byName } = setupPinReceipt({});
+  const target = store.save({ type: "preference", title: "会被归档", content: "x", importance: 5 });
+  assert.equal((await byName.memory_pin.execute({ id: target.id }, undefined)).injectable, true);
+  store.setArchived(target.id, true);
+  const archived = await byName.memory_pin.execute({ id: target.id }, undefined);
+  assert.equal(archived.pinned, true);
+  assert.equal(archived.injectable, false);
+  store.setArchived(target.id, false);
+  store.setForget(target.id, true);
+  const forgotten = await byName.memory_pin.execute({ id: target.id }, undefined);
+  assert.equal(forgotten.injectable, false);
+});
+
+test("registers twelve tools with correct names", () => {
   const { registered } = setup();
   const names = registered.map((t) => t.name).sort();
   // #230 新增 memory_register_document（agent 产长文档的指针行铸造口）。
-  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_get", "memory_list", "memory_register_document", "memory_runtime", "memory_save", "memory_search", "memory_update", "set_scope_state"]);
+  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_get", "memory_list", "memory_pin", "memory_register_document", "memory_runtime", "memory_save", "memory_search", "memory_update", "set_scope_state"]);
 });
 
 // v0.8.5 tool-exposure gate: disabling a tool hides it from the model entirely
@@ -62,19 +199,19 @@ test("registers eleven tools with correct names", () => {
 test("disableMemorySearch hides only memory_search", () => {
   const { registered } = setup({}, { disableMemorySearch: true });
   const names = registered.map((t) => t.name).sort();
-  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_get", "memory_list", "memory_register_document", "memory_runtime", "memory_save", "memory_update", "set_scope_state"]);
+  assert.deepEqual(names, ["memory_archive", "memory_delete", "memory_forget", "memory_get", "memory_list", "memory_pin", "memory_register_document", "memory_runtime", "memory_save", "memory_update", "set_scope_state"]);
 });
 
 test("disableMemoryArchive hides only memory_archive", () => {
   const { registered } = setup({}, { disableMemoryArchive: true });
   const names = registered.map((t) => t.name).sort();
-  assert.deepEqual(names, ["memory_delete", "memory_forget", "memory_get", "memory_list", "memory_register_document", "memory_runtime", "memory_save", "memory_search", "memory_update", "set_scope_state"]);
+  assert.deepEqual(names, ["memory_delete", "memory_forget", "memory_get", "memory_list", "memory_pin", "memory_register_document", "memory_runtime", "memory_save", "memory_search", "memory_update", "set_scope_state"]);
 });
 
 test("both disable flags hide both tools", () => {
   const { registered } = setup({}, { disableMemorySearch: true, disableMemoryArchive: true });
   const names = registered.map((t) => t.name).sort();
-  assert.deepEqual(names, ["memory_delete", "memory_forget", "memory_get", "memory_list", "memory_register_document", "memory_runtime", "memory_save", "memory_update", "set_scope_state"]);
+  assert.deepEqual(names, ["memory_delete", "memory_forget", "memory_get", "memory_list", "memory_pin", "memory_register_document", "memory_runtime", "memory_save", "memory_update", "set_scope_state"]);
 });
 
 // Description discipline: with all tools exposed, the descriptions must steer a
@@ -90,12 +227,12 @@ test("memory_search/archive descriptions carry tool-use discipline", () => {
 
 test("compiled schemas pass the enforced DSH subset (defineTool projection)", () => {
   const { registered } = setup();
-  assert.equal(registered.length, 11);
+  assert.equal(registered.length, 12);
   // opt-in 暴露的工具在默认配置下不注册（#231 的 memory_organize），所以本用例还得
   // 把暴露闸打开再走一遍——否则新工具的编译 schema 从来没被这条护栏看过，
   // 「子集不支持的写法」要到运行时才炸。
   const { registered: exposed } = setup(undefined, { organizeEnabled: true });
-  assert.equal(exposed.length, 12, "organizeEnabled 只多带一个工具，不许顺手改在场的别的东西");
+  assert.equal(exposed.length, 13, "organizeEnabled 只多带一个工具，不许顺手改在场的别的东西");
   for (const tool of [...registered, ...exposed]) {
     assertSupportedJsonSchema(tool.parameters);
     assertSupportedJsonSchema(tool.output.schema);