@modusensus/dsh-mneme 0.4.5 → 0.4.6

package/src/summarize.js

@@ -98,6 +98,12 @@ export function createSummarizer(ctx, service, config) {
     if (disposed || inFlight.has(session.id)) return;
     const controller = new AbortController();
     inFlight.set(session.id, controller);
+    // Bug8: audit state for the compression call. null = no audit for this run
+    // (disabled, or no LLM call was actually made). The audit row is written in
+    // the finally below — once, regardless of which exit path the call took —
+    // so a failed/aborted stream still leaves a status='error' trail without
+    // ever blocking the summarization itself.
+    let audit = null;
     try {
       const header = session.requestHeader?.()?.config;
       // Config override takes priority, then session header, then nothing.
@@ -110,6 +116,18 @@ export function createSummarizer(ctx, service, config) {
       const messages = collectMessages(session);
       if (!messages.length) return;
 
+      if (config?.llmAudit?.enabled !== false && typeof service.saveLlmAudit === "function") {
+        audit = {
+          route,
+          timestamp: new Date().toISOString(),
+          startedAt: Date.now(),
+          inputTokens: 0,
+          outputTokens: 0,
+          status: "success",
+          errorMessage: null
+        };
+      }
+
       const assembler = new BlockAssembler();
       let text = "";
       const options = {
@@ -122,15 +140,35 @@ export function createSummarizer(ctx, service, config) {
         ],
         signal: controller.signal
       };
-      for await (const chunk of ctx.llm.stream(options)) {
-        if (STREAM_CHUNK_TYPES.has(chunk.type)) assembler.push(toProtocolChunk(chunk));
-        if (chunk.type === "text-delta") {
-          text += chunk.text ?? chunk.delta ?? "";
+      try {
+        for await (const chunk of ctx.llm.stream(options)) {
+          if (STREAM_CHUNK_TYPES.has(chunk.type)) assembler.push(toProtocolChunk(chunk));
+          if (chunk.type === "text-delta") {
+            text += chunk.text ?? chunk.delta ?? "";
+          }
+          if (chunk.type === "usage" && audit) {
+            const i = chunk.input_tokens ?? chunk.inputTokens ?? chunk.prompt_tokens ?? chunk.promptTokens;
+            const o = chunk.output_tokens ?? chunk.outputTokens ?? chunk.completion_tokens ?? chunk.completionTokens;
+            if (Number.isFinite(i)) audit.inputTokens = i;
+            if (Number.isFinite(o)) audit.outputTokens = o;
+          }
+          if (chunk.type === "finish") {
+            const reasonKind = chunk.reason?.kind ?? chunk.kind;
+            if (reasonKind === "error" || reasonKind === "aborted") {
+              if (audit) {
+                audit.status = "error";
+                audit.errorMessage = `llm stream ${reasonKind}`;
+              }
+              return;
+            }
+          }
         }
-        if (chunk.type === "finish") {
-          const reasonKind = chunk.reason?.kind ?? chunk.kind;
-          if (reasonKind === "error" || reasonKind === "aborted") return;
+      } catch (error) {
+        if (audit) {
+          audit.status = "error";
+          audit.errorMessage = String(error?.message ?? error);
         }
+        throw error; // caller's catch handles the failure; audit already staged
       }
       // Direct delta accumulation is the primary extraction path (it works
       // for real protocol chunks {index,text} and looser {delta} shapes
@@ -147,6 +185,26 @@ export function createSummarizer(ctx, service, config) {
         service.saveWithDedupe({ ...entry, source: `session:${session.id}` });
       }
     } finally {
+      if (audit) {
+        try {
+          service.saveLlmAudit({
+            timestamp: audit.timestamp,
+            trigger_source: "autoSummarize",
+            operation_type: "summarize_compress",
+            model_id: `${audit.route.provider}:${audit.route.model}`,
+            input_tokens: audit.inputTokens,
+            output_tokens: audit.outputTokens,
+            total_tokens: audit.inputTokens + audit.outputTokens,
+            cost_usd: 0,
+            duration_ms: Date.now() - audit.startedAt,
+            status: audit.status,
+            error_message: audit.errorMessage,
+            related_memory_ids: []
+          });
+        } catch (auditError) {
+          ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
+        }
+      }
       inFlight.delete(session.id);
     }
   }

package/src/vector-index.js

@@ -73,13 +73,23 @@ export function createVectorIndex({ store, logger }) {
 
     /** Re-embed every row missing an embedding. Returns indexed count. */
     async rebuildIndex(embedder, { limit = 1000 } = {}) {
-      if (!embedder || typeof embedder.embedSingle !== "function") return { indexed: 0, skipped: 0 };
+      // The loop needs a single-text embedder. Native embedSingle is preferred;
+      // embed-only OpenAI-compatible clients (issue #10) are accepted too via
+      // their `embed` single-text interface, so /vector-reindex no longer
+      // silently returns 0 for them. An embedder exposing neither is ignored.
+      let embedOne = null;
+      if (embedder && typeof embedder.embedSingle === "function") {
+        embedOne = (text) => embedder.embedSingle(text);
+      } else if (embedder && typeof embedder.embed === "function") {
+        embedOne = (text) => Promise.resolve(embedder.embed(text));
+      }
+      if (!embedOne) return { indexed: 0, skipped: 0 };
       const rows = store.needsEmbedding(limit);
       let indexed = 0;
       for (const row of rows) {
         try {
           const text = [row.title, row.content].filter(Boolean).join("\n");
-          const vector = await embedder.embedSingle(text);
+          const vector = await embedOne(text);
           if (vector && vector.length) {
             store.setEmbedding(row.id, vector);
             indexed++;

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/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`);
+});

package/test/llm-audit.test.js

@@ -0,0 +1,279 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+import { createSummarizer } from "../src/summarize.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+import { mockCtx } from "./helpers/dream-mock.js";
+
+// Bug8: LLM audit trail. Every background LLM call (autoDream consolidation +
+// summary, autoSummarize compression) records tokens/time/status into
+// llm_audit_logs. Failures are captured as status='error' and never block the
+// calling feature. Read back through the API (/llm-audit + /llm-audit/stats).
+// Gating: runDream treats llmAudit.enabled === false as off; summarize treats
+// llmAudit.enabled !== false as on.
+
+function dreamSetup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return {
+    store,
+    service,
+    config: { dreamProvider: "deepseek", dreamModel: "deepseek-chat", llmAudit: { enabled: true }, ...over }
+  };
+}
+
+test("autoDream writes llm_audit_logs rows for consolidation and summary", async () => {
+  const { store, service, config } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  service.saveWithDedupe({ type: "project", title: "旧2", content: "第二段内容" });
+  const ctx = mockCtx({
+    onConsolidation: (listText) => {
+      const ids = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=\w+\s*\|\s*importance=\d+/g)].map((m) => m[1]);
+      return JSON.stringify(ids.map((id) => ({ action: "keep", ids: [id] })));
+    }
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, config);
+  assert.equal(result.ok, true);
+
+  const rows = service.listLlmAudits();
+  assert.equal(rows.length, 2, "one consolidation + one summary audit row");
+  const consolidate = rows.find((r) => r.operation_type === "dream_consolidate");
+  const summarize = rows.find((r) => r.operation_type === "dream_summarize");
+  assert.ok(consolidate, "dream_consolidate row present");
+  assert.ok(summarize, "dream_summarize row present");
+  assert.equal(consolidate.trigger_source, "autoDream");
+  assert.equal(summarize.trigger_source, "autoDream");
+  assert.equal(consolidate.status, "success");
+  assert.equal(summarize.status, "success");
+  // mockCtx resolves the route from agentDefaultModel (mock:stress-model), not
+  // the config fallback — assert the actually-used route.
+  assert.equal(consolidate.model_id, "mock:stress-model");
+  assert.equal(summarize.model_id, "mock:stress-model");
+  assert.ok(Array.isArray(consolidate.related_memory_ids) && consolidate.related_memory_ids.length === 2,
+    "consolidation audit records the snapshot ids");
+  assert.ok(consolidate.total_tokens >= 0 && summarize.total_tokens >= 0);
+  assert.ok(typeof consolidate.duration_ms === "number" && consolidate.duration_ms >= 0);
+  store.close();
+});
+
+test("autoDream LLM failure is audited as status=error and never blocks the run", async () => {
+  const { store, service, config } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "主题", content: "内容" });
+  // Consolidation stream finishes with kind "error" → streamText returns
+  // undefined → the run fails safe; runAuditedLlm must still leave an
+  // error audit row before the failure propagates.
+  const ctx = {
+    logger: { warn: () => {} },
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: "" };
+        yield { type: "finish", reason: { kind: "error" } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, config);
+  assert.equal(result.ok, false, "aborted/errored stream fails the run");
+  const rows = service.listLlmAudits();
+  assert.equal(rows.length, 1, "failed consolidation still audited");
+  assert.equal(rows[0].operation_type, "dream_consolidate");
+  assert.equal(rows[0].status, "error");
+  assert.ok(rows[0].error_message, "error message recorded");
+  // the audit write did not block the failure path
+  assert.equal(result.error, "llm failed");
+  store.close();
+});
+
+test("autoDream throwing LLM is audited as status=error", async () => {
+  const { store, service, config } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "主题", content: "内容" });
+  const ctx = {
+    logger: { warn: () => {} },
+    llm: {
+      async *stream() {
+        throw new Error("network down");
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, config);
+  assert.equal(result.ok, false);
+  const rows = service.listLlmAudits();
+  assert.equal(rows.length, 1, "throwing call still audited");
+  assert.equal(rows[0].status, "error");
+  assert.match(rows[0].error_message, /network down/);
+  store.close();
+});
+
+test("autoDream audit is skipped when llmAudit.enabled === false", async () => {
+  const { store, service, config } = dreamSetup({ llmAudit: { enabled: false } });
+  service.saveWithDedupe({ type: "project", title: "主题", content: "内容" });
+  const ctx = mockCtx();
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  await dream.runDream(ctx, service, config);
+  assert.equal(service.listLlmAudits().length, 0, "no audit rows when disabled");
+  store.close();
+});
+
+test("autoSummarize writes an llm_audit_logs row (trigger_source autoSummarize)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const events = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {};
+    },
+    logger: { warn: () => {} },
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: JSON.stringify([
+          { type: "decision", title: "选型", content: "确定用 node:sqlite", importance: 4 }
+        ]) };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const config = {
+    autoSummarize: true,
+    summarizeProvider: "deepseek",
+    summarizeModel: "deepseek-chat",
+    llmAudit: { enabled: true }
+  };
+  createSummarizer(ctx, service, config);
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s1",
+    requestHeader: () => ({ config: {} }),
+    events: [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "帮我选型" }] } },
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  const rows = service.listLlmAudits();
+  assert.equal(rows.length, 1, "one autoSummarize audit row");
+  assert.equal(rows[0].trigger_source, "autoSummarize");
+  assert.equal(rows[0].operation_type, "summarize_compress");
+  assert.equal(rows[0].model_id, "deepseek:deepseek-chat");
+  assert.equal(rows[0].status, "success");
+  store.close();
+});
+
+// --- API surface ------------------------------------------------------------
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = "GET";
+  r.headers = {};
+  return r;
+}
+
+function apiSetup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const routes = [];
+  const ctx = {
+    webServer: {
+      register(route) {
+        routes.push(route);
+        return () => {};
+      }
+    }
+  };
+  createApi(ctx, service, settings, { add: () => {}, remove: () => false, list: () => [] });
+  return { store, service, routes };
+}
+
+test("GET /api/dsh-mneme/semantic/llm-audit paginates and filters by source", async () => {
+  const { store, service, routes } = apiSetup();
+  for (let i = 0; i < 3; i++) {
+    service.saveLlmAudit({
+      trigger_source: "autoDream",
+      operation_type: "dream_consolidate",
+      model_id: "deepseek:deepseek-chat",
+      input_tokens: 10, output_tokens: 5, status: "success"
+    });
+  }
+  service.saveLlmAudit({
+    trigger_source: "autoSummarize",
+    operation_type: "summarize_compress",
+    model_id: "deepseek:deepseek-chat",
+    input_tokens: 3, output_tokens: 1, status: "success"
+  });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/llm-audit");
+
+  // full page
+  let res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/llm-audit?page=1&pageSize=2"), res);
+  let data = JSON.parse(res.body);
+  assert.equal(res.statusCode, 200);
+  assert.equal(data.total, 4);
+  assert.equal(data.page, 1);
+  assert.equal(data.pageSize, 2);
+  assert.equal(data.items.length, 2);
+
+  // second page
+  res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/llm-audit?page=2&pageSize=2"), res);
+  data = JSON.parse(res.body);
+  assert.equal(data.items.length, 2, "page 2 has the remaining rows");
+  assert.equal(data.total, 4);
+
+  // source filter
+  res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/llm-audit?source=autoSummarize"), res);
+  data = JSON.parse(res.body);
+  assert.equal(data.total, 1);
+  assert.equal(data.items[0].trigger_source, "autoSummarize");
+  store.close();
+});
+
+test("GET /api/dsh-mneme/semantic/llm-audit/stats aggregates by source and status", async () => {
+  const { store, service, routes } = apiSetup();
+  service.saveLlmAudit({
+    timestamp: new Date().toISOString(),
+    trigger_source: "autoDream", operation_type: "dream_consolidate",
+    model_id: "m", input_tokens: 100, output_tokens: 40, duration_ms: 25, status: "success"
+  });
+  service.saveLlmAudit({
+    timestamp: new Date().toISOString(),
+    trigger_source: "autoDream", operation_type: "dream_summarize",
+    model_id: "m", input_tokens: 30, output_tokens: 10, duration_ms: 8, status: "success"
+  });
+  service.saveLlmAudit({
+    timestamp: new Date().toISOString(),
+    trigger_source: "autoSummarize", operation_type: "summarize_compress",
+    model_id: "m", input_tokens: 5, output_tokens: 2, duration_ms: 4, status: "error"
+  });
+  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);
+  const stats = JSON.parse(res.body);
+  assert.equal(res.statusCode, 200);
+  assert.equal(stats.days, 7);
+  assert.equal(stats.total_calls, 3);
+  assert.equal(stats.input_tokens, 135);
+  assert.equal(stats.output_tokens, 52);
+  assert.equal(stats.total_tokens, 187);
+  assert.equal(stats.total_duration_ms, 37);
+  const bySource = stats.by_source.find((s) => s.source === "autoDream");
+  assert.equal(bySource.c, 2);
+  assert.equal(bySource.total_tokens, 180);
+  const errStatus = stats.by_status.find((s) => s.status === "error");
+  assert.equal(errStatus.c, 1);
+  store.close();
+});

package/test/mirror-edit-digest.test.js

@@ -75,7 +75,9 @@ test("digest 匹配：saveWithDedupe 同标题 merge 后新值落地、无伪冲
     assert.equal(result.action, "merged");
     assert.equal(store.count(), 1, "同标题合并不新增条目");
     const m = service.getById(result.memory.id);
-    assert.equal(m.content, "新内容", "合并后新值必须落地");
+    // Bug5: 同标题合并不是覆盖，而是追加（旧内容 + --- 分隔 + 新内容）
+    assert.ok(m.content.includes("旧内容"), "合并后旧内容保留在追加正文");
+    assert.ok(m.content.includes("新内容"), "合并后新值必须落地");
     assert.ok(!m.content.includes(CONFLICT_MARKER), "不得出现伪冲突 marker");
     const file = readFileSync(mirrorFile(dir, "preference"), "utf8");
     assert.match(file, /新内容/, "镜像已重渲染为新值");