@modusensus/dsh-mneme 0.4.4 → 0.4.6

package/test/api.test.js

@@ -5,6 +5,7 @@ import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createApi } from "../src/api.js";
 import { createSettings } from "../src/settings.js";
+import { createVectorIndex } from "../src/vector-index.js";
 
 class FakeRes extends EventEmitter {
   constructor() { super(); this.statusCode = 200; this.body = ""; }
@@ -383,3 +384,86 @@ test("no apiToken configured keeps all endpoints open", async () => {
   await vec.handler(req("/api/dsh-mneme/vector-config"), res);
   assert.equal(res.statusCode, 200, "open when apiToken is unset");
 });
+
+// --- Bug8: llm-audit API (pagination + stats) --------------------------------
+
+test("GET /api/dsh-mneme/semantic/llm-audit returns paginated rows", async () => {
+  const { routes, service } = setup();
+  for (let i = 0; i < 5; i++) {
+    service.saveLlmAudit({ trigger_source: "autoDream", operation_type: "dream_consolidate", model_id: "m1", input_tokens: 10, output_tokens: 5, status: "success", related_memory_ids: [] });
+  }
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/llm-audit");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/llm-audit?page=2&pageSize=2"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.total, 5);
+  assert.equal(data.page, 2);
+  assert.equal(data.pageSize, 2);
+  assert.equal(data.items.length, 2, "second page of 2");
+});
+
+test("GET /api/dsh-mneme/semantic/llm-audit filters by source", async () => {
+  const { routes, service } = setup();
+  service.saveLlmAudit({ trigger_source: "autoDream", operation_type: "dream_consolidate", model_id: "m1", status: "success" });
+  service.saveLlmAudit({ trigger_source: "autoSummarize", operation_type: "summarize_compress", model_id: "m2", status: "success" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/llm-audit");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/llm-audit?source=autoSummarize"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.total, 1);
+  assert.equal(data.items[0].operation_type, "summarize_compress");
+});
+
+test("GET /api/dsh-mneme/semantic/llm-audit/stats aggregates tokens by source and status", async () => {
+  const { routes, service } = setup();
+  service.saveLlmAudit({
+    trigger_source: "autoDream", operation_type: "dream_consolidate", model_id: "m1",
+    input_tokens: 100, output_tokens: 50, total_tokens: 150, duration_ms: 12, status: "success", related_memory_ids: []
+  });
+  service.saveLlmAudit({
+    trigger_source: "autoSummarize", operation_type: "summarize_compress", model_id: "m2",
+    input_tokens: 20, output_tokens: 10, total_tokens: 30, duration_ms: 5, status: "error", error_message: "boom", related_memory_ids: []
+  });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/llm-audit/stats");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/llm-audit/stats?days=7"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.total_calls, 2);
+  assert.equal(data.input_tokens, 120);
+  assert.equal(data.output_tokens, 60);
+  assert.equal(data.total_tokens, 180);
+  assert.equal(data.total_duration_ms, 17);
+  assert.ok(data.by_source.some((s) => s.source === "autoDream" && s.total_tokens === 150), "autoDream aggregate present");
+  assert.ok(data.by_status.some((s) => s.status === "error" && s.c === 1), "error status counted");
+});
+
+// --- issue #10: vector-reindex with an embed-only OpenAI-compatible embedder --
+
+test("Bug10: vector-reindex with an embed-only OpenAI-compatible embedder returns the real count and records the model fingerprint", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const vectorIndex = createVectorIndex({ store });
+  const embedder = {
+    embed: async (text) => [0.1, 0.2, 0.3], // OpenAI-compatible single-text embed
+    modelHash: "text-embedding-3#abc",
+    dimension: 3
+  };
+  // A pre-index row written before the embedder is attached (so it still has no vector).
+  service.saveWithDedupe({ type: "project", title: "待回填", content: "缺少向量的存量记忆" });
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, { add() {}, remove() {}, list() { return []; } }, embedder, { vectorIndex }, "");
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/vector-reindex");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/vector-reindex"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.indexed, 1, "actual indexed count, not 0");
+  assert.equal(data.skipped, 0);
+  assert.equal(vectorIndex.modelHash(), "text-embedding-3#abc", "model_hash written to vector_meta");
+  assert.equal(vectorIndex.dimension(), 3, "dimension written to vector_meta");
+  assert.equal(vectorIndex.getEmbedding(service.all()[0].id).length, 3, "embedding persisted");
+});

package/test/dream.test.js

@@ -847,3 +847,55 @@ test("consolidation prompt pins the decision schema (action field, single-string
   assert.match(systemText, /决策 JSON 示例/, "prompt includes a canonical example block");
   store.close();
 });
+
+// --- Bug8: llm_audit_logs trail ----------------------------------------------
+
+test("Bug8: runDream records llm_audit_logs rows for consolidation and summary", async () => {
+  const { store, service } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  service.saveWithDedupe({ type: "project", title: "旧2", content: "第二段内容" });
+  const ctx = mockCtx({
+    onConsolidation: (listText) => JSON.stringify([{ action: "keep", ids: [listText.match(/id=([^\s|]+)/)[1]] }])
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.equal(result.ok, true, "run succeeds");
+  const rows = store.listLlmAudits();
+  assert.equal(rows.length, 2, "consolidation + summary both audited");
+  assert.deepEqual(rows.map((r) => r.trigger_source), ["autoDream", "autoDream"]);
+  assert.deepEqual(rows.map((r) => r.operation_type).sort(), ["dream_consolidate", "dream_summarize"]);
+  const consolidate = rows.find((r) => r.operation_type === "dream_consolidate");
+  assert.equal(consolidate.related_memory_ids.length, 2, "consolidation audit links the snapshot ids");
+  const summarize = rows.find((r) => r.operation_type === "dream_summarize");
+  assert.deepEqual(summarize.related_memory_ids, [], "summary audit has no related ids");
+  for (const row of rows) {
+    assert.equal(row.status, "success");
+    assert.equal(row.model_id, "mock:stress-model");
+    assert.ok(Number.isInteger(row.duration_ms) && row.duration_ms >= 0, "duration recorded");
+    assert.equal(row.input_tokens, 0);
+    assert.equal(row.output_tokens, 0);
+  }
+  store.close();
+});
+
+test("Bug8: a failed LLM call is recorded with status=error and does not block the run", async () => {
+  const { store, service } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "主题", content: "内容" });
+  const ctx = {
+    logger: { warn: () => {} },
+    llm: {
+      stream: async function* () {
+        yield { type: "finish", reason: { kind: "error" } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.equal(result.ok, false, "failed run reported");
+  const rows = store.listLlmAudits();
+  assert.equal(rows.length, 1, "one audit row for the failed consolidation call");
+  assert.equal(rows[0].operation_type, "dream_consolidate");
+  assert.equal(rows[0].status, "error", "LLM failure status=error");
+  assert.ok(rows[0].error_message, "error message recorded");
+  store.close();
+});

package/test/epistemic.test.js

@@ -0,0 +1,298 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { DatabaseSync } from "node:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+import { applyDecisions } from "../src/dream.js";
+
+// ---------------------------------------------------------------- schema / legacy compat
+
+test("default epistemic_status is subjective (legacy-compatible)", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "preference", title: "语言", content: "用户用中文交流" });
+  assert.equal(saved.epistemic_status, "subjective", "no signal -> default subjective");
+  assert.equal(store.getById(saved.id).epistemic_status, "subjective");
+  store.close();
+});
+
+test("legacy DB without the column is migrated, old rows read back as subjective", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-epistemic-"));
+  const dbPath = join(dir, "memory.db");
+  try {
+    const old = new DatabaseSync(dbPath);
+    old.exec(`
+      CREATE TABLE memories (
+        id TEXT PRIMARY KEY, type TEXT NOT NULL, title TEXT NOT NULL, content TEXT NOT NULL,
+        tags TEXT NOT NULL DEFAULT '[]', importance INTEGER NOT NULL DEFAULT 3, forgotten INTEGER NOT NULL DEFAULT 0,
+        source TEXT, embedding TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+      );
+      INSERT INTO memories (id, type, title, content, tags, importance, forgotten, created_at, updated_at)
+        VALUES ('legacy', 'preference', '旧偏好', '用户以前说过', '[]', 3, 0, 't', 't');
+    `);
+    old.close();
+
+    const store = createStore(dbPath);
+    const cols = store.db.prepare("PRAGMA table_info(memories)").all().map((c) => c.name);
+    assert.ok(cols.includes("epistemic_status"), "column added by migration");
+    const legacy = store.getById("legacy");
+    assert.equal(legacy.title, "旧偏好", "legacy row preserved");
+    assert.equal(legacy.epistemic_status, "subjective", "legacy row defaults to subjective");
+    // New writes on the migrated DB still work with the column.
+    const saved = store.save({ type: "preference", title: "新", content: "实测结果可用" });
+    assert.equal(saved.epistemic_status, "observation");
+    store.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------- write inference
+
+test("content-based inference: subjective markers -> subjective", () => {
+  const store = createStore(":memory:");
+  const a = store.save({ type: "preference", title: "天气", content: "我推测明天可能会下雨" });
+  const b = store.save({ type: "preference", title: "口味", content: "我觉得用户喜欢甜的" });
+  assert.equal(a.epistemic_status, "subjective");
+  assert.equal(b.epistemic_status, "subjective");
+  store.close();
+});
+
+test("content-based inference: observation markers -> observation", () => {
+  const store = createStore(":memory:");
+  const a = store.save({ type: "project", title: "温度", content: "实测温度为35度，数据显示稳定" });
+  const b = store.save({ type: "project", title: "观察", content: "观察到用户总是先点保存" });
+  assert.equal(a.epistemic_status, "observation");
+  assert.equal(b.epistemic_status, "observation");
+  store.close();
+});
+
+test("content-based inference: inference markers -> inferred", () => {
+  const store = createStore(":memory:");
+  const a = store.save({ type: "decision", title: "喜好", content: "根据历史记录推断他喜欢猫" });
+  const b = store.save({ type: "decision", title: "趋势", content: "综上，结论是可推断的" });
+  assert.equal(a.epistemic_status, "inferred");
+  assert.equal(b.epistemic_status, "inferred");
+  store.close();
+});
+
+test("AI-generated types (summary/pattern) are always inferred", () => {
+  const store = createStore(":memory:");
+  const s = store.save({ type: "summary", title: "总览", content: "实测数据汇总" });
+  const p = store.save({ type: "pattern", title: "模式", content: "用户反复这样操作" });
+  assert.equal(s.epistemic_status, "inferred");
+  assert.equal(p.epistemic_status, "inferred");
+  store.close();
+});
+
+test("explicit epistemic_status wins over content inference", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "preference", title: "x", content: "我觉得可能", epistemic_status: "observation" });
+  assert.equal(saved.epistemic_status, "observation", "explicit value respected");
+  store.close();
+});
+
+test("update re-infers when content changes, keeps status otherwise", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "preference", title: "x", content: "我觉得可能" });
+  assert.equal(saved.epistemic_status, "subjective");
+  // content unchanged -> status kept
+  const untouched = store.update(saved.id, { title: "y" });
+  assert.equal(untouched.epistemic_status, "subjective");
+  // content changed to observation -> status re-inferred
+  const reInferred = store.update(saved.id, { content: "实测结果显示没问题" });
+  assert.equal(reInferred.epistemic_status, "observation");
+  store.close();
+});
+
+test("update re-infers when TYPE changes to summary/pattern (regression)", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "project", title: "x", content: "我觉得可能" });
+  assert.equal(saved.epistemic_status, "subjective");
+  // type -> summary: summary/pattern are always inferred, so status must flip
+  const asSummary = store.update(saved.id, { type: "summary" });
+  assert.equal(asSummary.epistemic_status, "inferred");
+  store.close();
+});
+
+// ---------------------------------------------------------------- retrieval ranking
+
+const embedder = {
+  embedSingle: async () => [1, 0, 0],
+  embed: async () => [1, 0, 0],
+  schedule: () => {},
+  modelHash: "mock#1",
+  dimension: 3
+};
+
+test("retrieval ranking: switch off leaves scores and order untouched", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const a = service.saveWithDedupe({ type: "preference", title: "猫A", content: "我觉得猫很可爱", importance: 5 });
+  const b = service.saveWithDedupe({ type: "preference", title: "猫B", content: "实测猫很可爱", importance: 3 });
+  assert.equal(a.memory.epistemic_status, "subjective");
+  assert.equal(b.memory.epistemic_status, "observation");
+
+  const rows = await service.searchMemories("猫", { mode: "keyword", topK: 10 });
+  assert.equal(rows[0].id, a.memory.id, "subjective first under default importance order");
+  assert.equal(rows[0].score, 1.0, "subjective keeps its raw score (1.0) when off");
+  assert.equal(rows[1].score, 0.8, "observation keeps its raw score (0.8) when off");
+  store.close();
+});
+
+test("retrieval ranking: switch on re-weights and re-orders mixed recall", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { trustEpistemicWeighting: true } });
+  const vi = createVectorIndex({ store });
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vi);
+  const subj = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "我觉得量子计算很难", importance: 5 });
+  const obs = service.saveWithDedupe({ type: "preference", title: "量子计算实践", content: "实测量子计算简单", importance: 3 });
+  vi.saveEmbedding(subj.memory.id, [1, 0, 0]);
+  vi.saveEmbedding(obs.memory.id, [1, 0, 0]);
+  assert.equal(subj.memory.epistemic_status, "subjective");
+  assert.equal(obs.memory.epistemic_status, "observation");
+
+  // hybrid blend (default 0.6/0.4): subjective 1.0*0.6+1.0*0.4=1.0;
+  // observation 1.0*0.6+0.8*0.4=0.92. After weighting: 1.0*0.7=0.7 vs 0.92*1.0=0.92.
+  const rows = await service.searchMemories("量子计算", { mode: "hybrid", topK: 10 });
+  const byId = new Map(rows.map((r) => [r.id, r]));
+  assert.equal(byId.get(subj.memory.id).score, 0.7, "subjective weighted to 0.7");
+  assert.equal(byId.get(obs.memory.id).score, 0.92, "observation weighted to 0.92");
+  assert.equal(rows[0].id, obs.memory.id, "observation outranks subjective when weighting is on");
+  store.close();
+});
+
+// ---------------------------------------------------------------- injection marking
+
+function setupInjector(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 };
+  createInjector(ctx, service, settings, config);
+  return { store, service, contexts };
+}
+
+test("injection marks observation memories [verified] only when enabled", () => {
+  const { service, contexts } = setupInjector({ trustEpistemicWeighting: true });
+  service.saveWithDedupe({ type: "preference", title: "偏好实测", content: "实测用户喜欢用命令行", importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "偏好推测", content: "我觉得用户可能喜欢GUI", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("[verified] 偏好实测"), "observation memory is flagged");
+  assert.ok(!text.includes("[verified] 偏好推测"), "subjective memory is not flagged");
+});
+
+test("injection never adds [verified] when the switch is off", () => {
+  const { service, contexts } = setupInjector({});
+  service.saveWithDedupe({ type: "preference", title: "偏好实测", content: "实测用户喜欢用命令行", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("偏好实测"), "memory still injected");
+  assert.ok(!text.includes("[verified]"), "no verified marker when off");
+});
+
+// ---------------------------------------------------------------- decision priority
+
+test("merge keepSource prefers observation when enabled", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const config = { trustEpistemicWeighting: true };
+  const a = service.saveWithDedupe({ type: "project", title: "插件甲", content: "我觉得应该用A方案", importance: 3 });
+  const b = service.saveWithDedupe({ type: "project", title: "插件乙", content: "实测结果显示B方案更好", importance: 4 });
+  assert.equal(a.memory.epistemic_status, "subjective");
+  assert.equal(b.memory.epistemic_status, "observation");
+
+  const { committed } = applyDecisions(
+    [{ action: "merge", ids: [a.memory.id, b.memory.id], title: "插件总览", content: "合并", keepSource: a.memory.id }],
+    service, null, null, config
+  );
+  assert.equal(committed[0].keepSource, b.memory.id, "keepSource switched to the observation memory");
+  assert.equal(store.getById(b.memory.id).archived, false, "observation keeper stays live");
+  assert.equal(store.getById(a.memory.id).archived, true, "subjective source archived");
+});
+
+test("merge keepSource keeps the LLM choice when disabled", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const a = service.saveWithDedupe({ type: "project", title: "插件甲", content: "我觉得应该用A方案", importance: 3 });
+  const b = service.saveWithDedupe({ type: "project", title: "插件乙", content: "实测结果显示B方案更好", importance: 4 });
+  const { committed } = applyDecisions(
+    [{ action: "merge", ids: [a.memory.id, b.memory.id], title: "插件总览", content: "合并", keepSource: a.memory.id }],
+    service
+  );
+  assert.equal(committed[0].keepSource, a.memory.id, "LLM keepSource respected when off");
+  assert.equal(store.getById(a.memory.id).archived, false);
+  assert.equal(store.getById(b.memory.id).archived, true);
+});
+
+test("merge never promotes an ARCHIVED observation to keeper when enabled (regression)", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const config = { trustEpistemicWeighting: true };
+  // a = live subjective (LLM's keepSource), b = live observation,
+  // c = ARCHIVED observation. Pre-fix pickBestKeeper would pick c (highest
+  // priority, no archived check) as keeper, hit the archived-keeper guard in
+  // applyMerge and silently drop the merge — the live b never merges.
+  const a = service.saveWithDedupe({ type: "project", title: "甲", content: "我觉得A方案", importance: 3 });
+  const b = service.saveWithDedupe({ type: "project", title: "乙", content: "实测B方案更好", importance: 4 });
+  const c = service.saveWithDedupe({ type: "project", title: "丙", content: "实测C方案最好", importance: 4 });
+  service.setArchived(c.memory.id, true);
+
+  const { committed } = applyDecisions(
+    [{ action: "merge", ids: [a.memory.id, b.memory.id, c.memory.id], title: "合并", content: "合并", keepSource: a.memory.id }],
+    service, null, null, config
+  );
+  // c (archived) must NOT be promoted; the live observation b becomes keeper,
+  // and the merge actually lands.
+  assert.equal(committed.length, 1, "merge actually committed (not silently skipped)");
+  assert.equal(committed[0].keepSource, b.memory.id, "live observation promoted over archived one");
+  assert.equal(store.getById(b.memory.id).archived, false, "observation keeper stays live");
+  assert.equal(store.getById(a.memory.id).archived, true, "subjective source archived");
+  assert.equal(store.getById(c.memory.id).archived, true, "archived c stays archived");
+});
+
+test("conflict resolution prefers the observation side as winner when enabled", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const config = { trustEpistemicWeighting: true };
+  const w = service.saveWithDedupe({ type: "decision", title: "截止1", content: "我觉得截止是8月20日", importance: 4 });
+  const l = service.saveWithDedupe({ type: "decision", title: "截止2", content: "实测截止是8月15日", importance: 4 });
+  assert.equal(w.memory.epistemic_status, "subjective");
+  assert.equal(l.memory.epistemic_status, "observation");
+
+  const { committed } = applyDecisions(
+    [{ action: "conflict", winner: w.memory.id, loser: l.memory.id, reason: "日期更新" }],
+    service, null, null, config
+  );
+  assert.equal(committed[0].winner, l.memory.id, "winner swapped to the observation memory");
+  assert.equal(store.getById(l.memory.id).archived, false, "observation winner stays live");
+  assert.equal(store.getById(w.memory.id).archived, true, "subjective loser archived");
+});
+
+test("conflict resolution keeps the LLM winner when disabled", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const w = service.saveWithDedupe({ type: "decision", title: "截止1", content: "我觉得截止是8月20日", importance: 4 });
+  const l = service.saveWithDedupe({ type: "decision", title: "截止2", content: "实测截止是8月15日", importance: 4 });
+  const { committed } = applyDecisions(
+    [{ action: "conflict", winner: w.memory.id, loser: l.memory.id, reason: "日期更新" }],
+    service
+  );
+  assert.equal(committed[0].winner, w.memory.id, "LLM winner respected when off");
+  assert.equal(store.getById(w.memory.id).archived, false);
+  assert.equal(store.getById(l.memory.id).archived, true);
+});

package/test/inject.test.js

@@ -80,3 +80,24 @@ test("user-settings context precedes memory block (order 85 < 90)", () => {
   const settingsCtx = contexts.find((c) => c.name === "user-settings");
   assert.ok(settingsCtx.order < contexts.find((c) => c.name === "memory").order);
 });
+
+test("Bug6: long content is truncated to ~300 chars with an ellipsis", () => {
+  const { contexts, service } = setup();
+  const longContent = "这是一段非常长的记忆正文".repeat(200); // ~2600 chars
+  service.saveWithDedupe({ type: "preference", title: "长记忆", content: longContent, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("长记忆"), "memory still rendered");
+  assert.ok(text.includes("…"), "ellipsis marks the truncation");
+  assert.ok(!text.includes(longContent.slice(300)), "full body not injected verbatim");
+});
+
+test("Bug6: injected block stays within the ~1500 char budget, later entries collapse", () => {
+  const { contexts, service } = setup({ maxInjectedItems: 8 });
+  for (let i = 0; i < 8; i++) {
+    service.saveWithDedupe({ type: "preference", title: `长标题记忆${i}`, content: "这是一段".repeat(100), importance: 5 });
+  }
+  const text = contexts[0].text({});
+  assert.ok(text.length <= 1600, `memory block bounded near budget, got ${text.length} chars`);
+  // The first entries render full bodies; every entry is present by title.
+  for (let i = 0; i < 8; i++) assert.ok(text.includes(`长标题记忆${i}`), `entry ${i} present`);
+});