@modusensus/dsh-mneme 0.8.3 → 0.8.5

package/test/helpers/tar-builder.js

@@ -1,80 +1,80 @@
-// test/helpers/tar-builder.js
-// 共享的 tar 造件器：tarball 读取层与取件层的测试都要造归档，放这里免得两份漂移。
-// 只造真东西（POSIX ustar 布局 + 正确的校验和），不引 tar 库 —— 那正是被测代码要回避的依赖。
-
-import { gzipSync } from "node:zlib";
-
-/** 一个 ustar 头块；字段布局照 POSIX，校验和按规范先按空格算再写回。 */
-export function tarHeader({ name = "", prefix = "", size = 0, type = "0" }) {
-  const header = Buffer.alloc(512);
-  header.write(name, 0, 100, "utf8");
-  header.write("0000644\0", 100, 8, "utf8");
-  header.write("0000000\0", 108, 8, "utf8");
-  header.write("0000000\0", 116, 8, "utf8");
-  header.write(`${size.toString(8).padStart(11, "0")}\0`, 124, 12, "utf8");
-  header.write("00000000000\0", 136, 12, "utf8");
-  header.write("        ", 148, 8, "utf8");
-  header.write(type, 156, 1, "utf8");
-  header.write("ustar\0", 257, 6, "utf8");
-  header.write("00", 263, 2, "utf8");
-  header.write(prefix, 345, 155, "utf8");
-  let sum = 0;
-  for (const byte of header) sum += byte;
-  header.write(`${sum.toString(8).padStart(6, "0")}\0 `, 148, 8, "utf8");
-  return header;
-}
-
-/** 普通文件条目（数据按 512 对齐补齐）。 */
-export function tarFile(name, body, { prefix = "" } = {}) {
-  const data = Buffer.from(body, "utf8");
-  const padded = Buffer.alloc(Math.ceil(data.length / 512) * 512);
-  data.copy(padded);
-  return [tarHeader({ name, prefix, size: data.length, type: "0" }), padded];
-}
-
-/** 目录（"5"）/ 符号链接（"2"）等无数据条目。 */
-export function tarMeta(name, type) {
-  return [tarHeader({ name, size: 0, type })];
-}
-
-/** pax 扩展头：载荷是 `长度 path=值\n`。 */
-export function tarPax(path) {
-  const record = Buffer.from(`path=${path}\n`, "utf8");
-  const line = `${record.length + String(record.length).length} path=${path}\n`;
-  return [tarHeader({ name: "PaxHeaders/x", size: Buffer.byteLength(line), type: "x" }), padTo512(Buffer.from(line, "utf8"))];
-}
-
-/** 补齐到 512 的整数倍。 */
-export function padTo512(buffer) {
-  if (buffer.length % 512 === 0) return buffer;
-  const padded = Buffer.alloc(Math.ceil(buffer.length / 512) * 512);
-  buffer.copy(padded);
-  return padded;
-}
-
-/** 两个全零块 = 归档结束。 */
-export const END_BLOCKS = [Buffer.alloc(512), Buffer.alloc(512)];
-
-/**
- * 造一份 .tgz。`entries` 每项：
- *   { path, body }       普通文件（自动加 `package/` 前缀，除非 path 已含它）
- *   { path, type }       目录/符号链接等（type 是 ustar 的 typeflag 字符）
- *   { paxPath }          pax 头，覆盖下一条目的路径
- * @param {Array<object>} entries - 条目。
- * @param {{prefix?: string|null, end?: boolean}} [opts] - 前缀（默认 package/）、是否追加结束块。
- * @returns {Buffer} gzip 后的归档。
- */
-export function makeTgz(entries, { prefix = "package/", end = true } = {}) {
-  const blocks = [];
-  for (const entry of entries) {
-    if (entry.paxPath !== undefined) {
-      blocks.push(...tarPax(prefix === null ? entry.paxPath : `${prefix}${entry.paxPath}`));
-      continue;
-    }
-    const path = prefix === null || entry.path.startsWith(prefix) ? entry.path : `${prefix}${entry.path}`;
-    if (entry.type !== undefined) blocks.push(...tarMeta(path, entry.type));
-    else blocks.push(...tarFile(path, entry.body ?? ""));
-  }
-  if (end) blocks.push(...END_BLOCKS);
-  return gzipSync(Buffer.concat(blocks));
-}
+// test/helpers/tar-builder.js
+// 共享的 tar 造件器：tarball 读取层与取件层的测试都要造归档，放这里免得两份漂移。
+// 只造真东西（POSIX ustar 布局 + 正确的校验和），不引 tar 库 —— 那正是被测代码要回避的依赖。
+
+import { gzipSync } from "node:zlib";
+
+/** 一个 ustar 头块；字段布局照 POSIX，校验和按规范先按空格算再写回。 */
+export function tarHeader({ name = "", prefix = "", size = 0, type = "0" }) {
+  const header = Buffer.alloc(512);
+  header.write(name, 0, 100, "utf8");
+  header.write("0000644\0", 100, 8, "utf8");
+  header.write("0000000\0", 108, 8, "utf8");
+  header.write("0000000\0", 116, 8, "utf8");
+  header.write(`${size.toString(8).padStart(11, "0")}\0`, 124, 12, "utf8");
+  header.write("00000000000\0", 136, 12, "utf8");
+  header.write("        ", 148, 8, "utf8");
+  header.write(type, 156, 1, "utf8");
+  header.write("ustar\0", 257, 6, "utf8");
+  header.write("00", 263, 2, "utf8");
+  header.write(prefix, 345, 155, "utf8");
+  let sum = 0;
+  for (const byte of header) sum += byte;
+  header.write(`${sum.toString(8).padStart(6, "0")}\0 `, 148, 8, "utf8");
+  return header;
+}
+
+/** 普通文件条目（数据按 512 对齐补齐）。 */
+export function tarFile(name, body, { prefix = "" } = {}) {
+  const data = Buffer.from(body, "utf8");
+  const padded = Buffer.alloc(Math.ceil(data.length / 512) * 512);
+  data.copy(padded);
+  return [tarHeader({ name, prefix, size: data.length, type: "0" }), padded];
+}
+
+/** 目录（"5"）/ 符号链接（"2"）等无数据条目。 */
+export function tarMeta(name, type) {
+  return [tarHeader({ name, size: 0, type })];
+}
+
+/** pax 扩展头：载荷是 `长度 path=值\n`。 */
+export function tarPax(path) {
+  const record = Buffer.from(`path=${path}\n`, "utf8");
+  const line = `${record.length + String(record.length).length} path=${path}\n`;
+  return [tarHeader({ name: "PaxHeaders/x", size: Buffer.byteLength(line), type: "x" }), padTo512(Buffer.from(line, "utf8"))];
+}
+
+/** 补齐到 512 的整数倍。 */
+export function padTo512(buffer) {
+  if (buffer.length % 512 === 0) return buffer;
+  const padded = Buffer.alloc(Math.ceil(buffer.length / 512) * 512);
+  buffer.copy(padded);
+  return padded;
+}
+
+/** 两个全零块 = 归档结束。 */
+export const END_BLOCKS = [Buffer.alloc(512), Buffer.alloc(512)];
+
+/**
+ * 造一份 .tgz。`entries` 每项：
+ *   { path, body }       普通文件（自动加 `package/` 前缀，除非 path 已含它）
+ *   { path, type }       目录/符号链接等（type 是 ustar 的 typeflag 字符）
+ *   { paxPath }          pax 头，覆盖下一条目的路径
+ * @param {Array<object>} entries - 条目。
+ * @param {{prefix?: string|null, end?: boolean}} [opts] - 前缀（默认 package/）、是否追加结束块。
+ * @returns {Buffer} gzip 后的归档。
+ */
+export function makeTgz(entries, { prefix = "package/", end = true } = {}) {
+  const blocks = [];
+  for (const entry of entries) {
+    if (entry.paxPath !== undefined) {
+      blocks.push(...tarPax(prefix === null ? entry.paxPath : `${prefix}${entry.paxPath}`));
+      continue;
+    }
+    const path = prefix === null || entry.path.startsWith(prefix) ? entry.path : `${prefix}${entry.path}`;
+    if (entry.type !== undefined) blocks.push(...tarMeta(path, entry.type));
+    else blocks.push(...tarFile(path, entry.body ?? ""));
+  }
+  if (end) blocks.push(...END_BLOCKS);
+  return gzipSync(Buffer.concat(blocks));
+}

package/test/hot-memory.test.js

@@ -1,145 +1,145 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createHotMemory, estimateTokens } from "../src/hot-memory.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createVectorIndex } from "../src/vector-index.js";
-
-// --- hot memory buffer ---
-
-test("hot memory keeps the latest rounds within maxRounds", () => {
-  const hot = createHotMemory({ maxRounds: 2, maxTokens: 10000 });
-  hot.add({ query: "第一轮", response: "答一" });
-  hot.add({ query: "第二轮", response: "答二" });
-  hot.add({ query: "第三轮", response: "答三" });
-  assert.equal(hot.rounds().length, 2);
-  assert.ok(hot.getContext().includes("第三轮"));
-  assert.ok(!hot.getContext().includes("第一轮"));
-});
-
-test("hot memory enforces the token budget", () => {
-  const hot = createHotMemory({ maxRounds: 10, maxTokens: 30 });
-  hot.add({ query: "很长的第一轮问题".repeat(10), response: "很长的回答".repeat(10) });
-  hot.add({ query: "第二轮", response: "答二" });
-  // The first round alone blows the budget; the newest round survives and
-  // the buffer never empties completely.
-  const rounds = hot.rounds();
-  assert.ok(rounds.length >= 1);
-  assert.equal(rounds[rounds.length - 1].query, "第二轮");
-});
-
-test("hot memory getContext uses the Q/A round format", () => {
-  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
-  hot.add({ query: "Q1", response: "A1" });
-  hot.add({ query: "Q2", response: "A2" });
-  assert.equal(hot.getContext(), "Q: Q1\nA: A1\n\nQ: Q2\nA: A2");
-});
-
-test("hot memory ignores empty rounds and clears", () => {
-  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
-  hot.add({ query: "", response: "x" });
-  hot.add(null);
-  assert.equal(hot.rounds().length, 0);
-  hot.add({ query: "q" });
-  hot.clear();
-  assert.equal(hot.getContext(), "");
-});
-
-test("estimateTokens counts CJK heavier than ASCII", () => {
-  assert.ok(estimateTokens("中文内容") > estimateTokens("abcd"));
-});
-
-// --- service-level: BM25 fusion + semantic dedup + selective injection ---
-
-function toyVec(text) {
-  const v = new Array(64).fill(0);
-  for (const t of String(text).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean)) {
-    let h = 0;
-    for (const ch of t) h = (h * 31 + ch.codePointAt(0)) >>> 0;
-    v[h % 64] += 1;
-  }
-  const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1;
-  return v.map((x) => x / norm);
-}
-
-function setup(overrides = {}) {
-  const store = createStore(":memory:");
-  const config = {
-    entitySearchEnabled: false,
-    bm25SearchEnabled: true,
-    adaptiveThresholdEnabled: false,
-    searchSemanticDedup: true,
-    selectiveInjectEnabled: true,
-    ...overrides
-  };
-  const service = createService({ store, mirror: null, config, logger: null });
-  service.setVectorIndex(createVectorIndex({ store, logger: null }));
-  service.setEmbedder({ embedSingle: async (t) => toyVec(t) });
-  return { store, service };
-}
-
-test("searchMemories fuses BM25: scattered-term queries recall both rows", async () => {
-  const { store, service } = setup();
-  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
-  const b = store.save({ type: "decision", title: "语言迁移", content: "编译模块迁移到 Rust", importance: 3 });
-  store.save({ type: "project", title: "无关", content: "夜间 ETL 脚本", importance: 3 });
-
-  // "rust 异步" is not a substring of either row — LIKE misses both; BM25
-  // must surface both rows in the merged result.
-  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
-  const ids = results.map((r) => r.id);
-  assert.ok(ids.includes(a.id), "async row must be recalled via BM25");
-  assert.ok(ids.includes(b.id), "rust row must be recalled via BM25");
-  assert.equal(results.find((r) => r.id === a.id)?.source, "bm25");
-});
-
-test("bm25SearchEnabled=false restores the two-path behavior", async () => {
-  const { store, service } = setup({ bm25SearchEnabled: false });
-  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
-  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
-  assert.ok(!results.some((r) => r.id === a.id), "no BM25 → scattered-term miss is back");
-});
-
-test("search-time semantic dedup drops near-identical embeddings", async () => {
-  const { store, service } = setup();
-  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
-  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
-  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
-  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
-
-  // auto (not keyword): keyword mode is the documented text-only path and is
-  // exempt from dedup by design; auto exercises the dedup the way production
-  // searches run.
-  const results = await service.searchMemories("深色主题", { mode: "auto", topK: 5 });
-  const ids = results.map((r) => r.id);
-  assert.ok(ids.includes(a.id) !== ids.includes(b.id), "one of the near-duplicate pair is dropped");
-});
-
-test("searchSemanticDedup=false keeps duplicate embeddings", async () => {
-  const { store, service } = setup({ searchSemanticDedup: false });
-  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
-  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
-  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
-  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
-  const results = await service.searchMemories("深色主题", { mode: "keyword", topK: 5 });
-  assert.equal(results.length, 2);
-});
-
-test("selective injection re-orders candidates by query similarity", () => {
-  const { store, service } = setup();
-  const thesis = store.save({ type: "project", title: "湿地论文", content: "毕业论文研究城市湿地公园", importance: 5 });
-  const plugin = store.save({ type: "project", title: "插件项目", content: "dsh-mneme 记忆插件开发", importance: 5 });
-  store.setEmbedding(thesis.id, toyVec("毕业论文研究城市湿地公园"));
-  store.setEmbedding(plugin.id, toyVec("dsh-mneme 记忆插件开发"));
-
-  // Rule-based order would put both at equal importance; the query vector is
-  // about the thesis, so topic ranking must put the thesis memory first.
-  const picked = service.injectCandidates({
-    query: "论文写作",
-    queryVector: toyVec("毕业论文研究城市湿地公园"),
-    maxItems: 2,
-    threshold: 3
-  });
-  assert.equal(picked[0].id, thesis.id);
-  assert.ok(picked.some((m) => m.id === plugin.id));
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createHotMemory, estimateTokens } from "../src/hot-memory.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// --- hot memory buffer ---
+
+test("hot memory keeps the latest rounds within maxRounds", () => {
+  const hot = createHotMemory({ maxRounds: 2, maxTokens: 10000 });
+  hot.add({ query: "第一轮", response: "答一" });
+  hot.add({ query: "第二轮", response: "答二" });
+  hot.add({ query: "第三轮", response: "答三" });
+  assert.equal(hot.rounds().length, 2);
+  assert.ok(hot.getContext().includes("第三轮"));
+  assert.ok(!hot.getContext().includes("第一轮"));
+});
+
+test("hot memory enforces the token budget", () => {
+  const hot = createHotMemory({ maxRounds: 10, maxTokens: 30 });
+  hot.add({ query: "很长的第一轮问题".repeat(10), response: "很长的回答".repeat(10) });
+  hot.add({ query: "第二轮", response: "答二" });
+  // The first round alone blows the budget; the newest round survives and
+  // the buffer never empties completely.
+  const rounds = hot.rounds();
+  assert.ok(rounds.length >= 1);
+  assert.equal(rounds[rounds.length - 1].query, "第二轮");
+});
+
+test("hot memory getContext uses the Q/A round format", () => {
+  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
+  hot.add({ query: "Q1", response: "A1" });
+  hot.add({ query: "Q2", response: "A2" });
+  assert.equal(hot.getContext(), "Q: Q1\nA: A1\n\nQ: Q2\nA: A2");
+});
+
+test("hot memory ignores empty rounds and clears", () => {
+  const hot = createHotMemory({ maxRounds: 5, maxTokens: 10000 });
+  hot.add({ query: "", response: "x" });
+  hot.add(null);
+  assert.equal(hot.rounds().length, 0);
+  hot.add({ query: "q" });
+  hot.clear();
+  assert.equal(hot.getContext(), "");
+});
+
+test("estimateTokens counts CJK heavier than ASCII", () => {
+  assert.ok(estimateTokens("中文内容") > estimateTokens("abcd"));
+});
+
+// --- service-level: BM25 fusion + semantic dedup + selective injection ---
+
+function toyVec(text) {
+  const v = new Array(64).fill(0);
+  for (const t of String(text).toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean)) {
+    let h = 0;
+    for (const ch of t) h = (h * 31 + ch.codePointAt(0)) >>> 0;
+    v[h % 64] += 1;
+  }
+  const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1;
+  return v.map((x) => x / norm);
+}
+
+function setup(overrides = {}) {
+  const store = createStore(":memory:");
+  const config = {
+    entitySearchEnabled: false,
+    bm25SearchEnabled: true,
+    adaptiveThresholdEnabled: false,
+    searchSemanticDedup: true,
+    selectiveInjectEnabled: true,
+    ...overrides
+  };
+  const service = createService({ store, mirror: null, config, logger: null });
+  service.setVectorIndex(createVectorIndex({ store, logger: null }));
+  service.setEmbedder({ embedSingle: async (t) => toyVec(t) });
+  return { store, service };
+}
+
+test("searchMemories fuses BM25: scattered-term queries recall both rows", async () => {
+  const { store, service } = setup();
+  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
+  const b = store.save({ type: "decision", title: "语言迁移", content: "编译模块迁移到 Rust", importance: 3 });
+  store.save({ type: "project", title: "无关", content: "夜间 ETL 脚本", importance: 3 });
+
+  // "rust 异步" is not a substring of either row — LIKE misses both; BM25
+  // must surface both rows in the merged result.
+  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
+  const ids = results.map((r) => r.id);
+  assert.ok(ids.includes(a.id), "async row must be recalled via BM25");
+  assert.ok(ids.includes(b.id), "rust row must be recalled via BM25");
+  assert.equal(results.find((r) => r.id === a.id)?.source, "bm25");
+});
+
+test("bm25SearchEnabled=false restores the two-path behavior", async () => {
+  const { store, service } = setup({ bm25SearchEnabled: false });
+  const a = store.save({ type: "project", title: "异步并发模式", content: "async runtime 选用 tokio", importance: 3 });
+  const results = await service.searchMemories("rust 异步", { mode: "auto", topK: 5 });
+  assert.ok(!results.some((r) => r.id === a.id), "no BM25 → scattered-term miss is back");
+});
+
+test("search-time semantic dedup drops near-identical embeddings", async () => {
+  const { store, service } = setup();
+  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
+  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
+  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
+  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
+
+  // auto (not keyword): keyword mode is the documented text-only path and is
+  // exempt from dedup by design; auto exercises the dedup the way production
+  // searches run.
+  const results = await service.searchMemories("深色主题", { mode: "auto", topK: 5 });
+  const ids = results.map((r) => r.id);
+  assert.ok(ids.includes(a.id) !== ids.includes(b.id), "one of the near-duplicate pair is dropped");
+});
+
+test("searchSemanticDedup=false keeps duplicate embeddings", async () => {
+  const { store, service } = setup({ searchSemanticDedup: false });
+  const a = store.save({ type: "project", title: "偏好 A", content: "用户喜欢深色主题编辑器", importance: 3 });
+  const b = store.save({ type: "project", title: "偏好 A 备份", content: "用户喜欢深色主题编辑器（备份）", importance: 3 });
+  store.setEmbedding(a.id, toyVec("用户喜欢深色主题编辑器"));
+  store.setEmbedding(b.id, toyVec("用户喜欢深色主题编辑器"));
+  const results = await service.searchMemories("深色主题", { mode: "keyword", topK: 5 });
+  assert.equal(results.length, 2);
+});
+
+test("selective injection re-orders candidates by query similarity", () => {
+  const { store, service } = setup();
+  const thesis = store.save({ type: "project", title: "湿地论文", content: "毕业论文研究城市湿地公园", importance: 5 });
+  const plugin = store.save({ type: "project", title: "插件项目", content: "dsh-mneme 记忆插件开发", importance: 5 });
+  store.setEmbedding(thesis.id, toyVec("毕业论文研究城市湿地公园"));
+  store.setEmbedding(plugin.id, toyVec("dsh-mneme 记忆插件开发"));
+
+  // Rule-based order would put both at equal importance; the query vector is
+  // about the thesis, so topic ranking must put the thesis memory first.
+  const picked = service.injectCandidates({
+    query: "论文写作",
+    queryVector: toyVec("毕业论文研究城市湿地公园"),
+    maxItems: 2,
+    threshold: 3
+  });
+  assert.equal(picked[0].id, thesis.id);
+  assert.ok(picked.some((m) => m.id === plugin.id));
+});

package/test/inject-content-cap.test.js

@@ -0,0 +1,91 @@
+// Issue #164① 注入截断修复测试。
+// 覆盖：截断带尾部提示（上限/原长/memory_get id 指引，不再静默）/ 短正文无
+// 提示 / 上限可配（injectContentMaxChars）/ 块预算随上限放大（调大上限不被
+// 1500 旧闸卡死）/ _full_content 压缩注入路径不加提示 / 默认 300 与既有行为
+// 对齐（ellipsis 仍在、全文不整段进入）。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const ctx = {
+    systemPrompt: {
+      context(def) {
+        contexts.push(def);
+        return () => {};
+      }
+    }
+  };
+  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
+  const injector = createInjector(ctx, service, settings, config);
+  return { store, service, contexts, injector };
+}
+
+test("truncated entry carries a non-silent tail hint with limit/length/memory_get", () => {
+  const { contexts, service } = setup();
+  const long = "超长正文内容。".repeat(200); // ~1400 chars
+  const mem = service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 }).memory;
+  const text = contexts[0].text({});
+  assert.ok(text.includes("…"), "ellipsis present");
+  assert.ok(text.includes(`memory_get "${mem.id}"`), "hint carries memory_get id");
+  assert.ok(text.includes("上限 300"), "hint carries the limit");
+  assert.ok(text.includes(`原 ${long.length} 字符`), "hint carries original length");
+});
+
+test("short content gets no hint", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "短记忆", content: "中文交流", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(!text.includes("已截断"), "no truncation hint on short content");
+});
+
+test("injectContentMaxChars raises the cap and the hint reports the new limit", () => {
+  const { contexts, service } = setup({ injectContentMaxChars: 800 });
+  const long = "字".repeat(1000);
+  service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("字".repeat(800)), "content injected up to the new cap");
+  assert.ok(!text.includes("字".repeat(801)), "content beyond the new cap is cut");
+  assert.ok(text.includes("上限 800"), "hint reports the configured limit");
+});
+
+test("block budget scales with the cap (raised cap is not defeated by the 1500 gate)", () => {
+  const { contexts, service } = setup({ injectContentMaxChars: 1000, maxInjectedItems: 2 });
+  const body = "块".repeat(900);
+  service.saveWithDedupe({ type: "preference", title: "甲", content: body, importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "乙", content: body, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("甲"), "first entry full");
+  assert.ok(text.includes("块".repeat(900)), "first entry body not collapsed by stale block gate");
+  assert.ok(text.includes("乙"), "second entry still rendered");
+});
+
+test("_full_content (sleep-compressed) path obeys the cap and says so (#266 评审)", () => {
+  const { store, contexts, service } = setup();
+  const mem = service.saveWithDedupe({ type: "preference", title: "压缩记忆", content: "占位", importance: 5 }).memory;
+  // 模拟 sleep 降级：content=压缩摘要（400 字符 > 默认 300 上限），原文入库 _full_content
+  const summary = "压缩摘要。".repeat(80);
+  store.db.prepare("UPDATE memories SET content=?, _full_content=? WHERE id=?")
+    .run(summary, "原始长文".repeat(100), mem.id);
+  const text = contexts[0].text({});
+  // 「降级过」不等于「天然够短」：原先这条早返回的唯一效果就是绕过上限，现在统一截断。
+  assert.ok(!text.includes(summary), "oversized summary is not injected whole");
+  assert.ok(text.includes("压缩摘要。".repeat(60)), "the part inside the cap is still there (300 chars)");
+  assert.ok(text.includes("已截断"), "the cut is reported, never silent");
+});
+
+test("default cap stays 300 (ellipsis regression of Bug6)", () => {
+  const { contexts, service } = setup();
+  const long = "x".repeat(2000);
+  service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("x".repeat(300)));
+  assert.ok(!text.includes("x".repeat(301)));
+});