@modusensus/dsh-mneme 0.8.15 → 0.9.0

package/test/llm-audit.test.js

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
 import { DatabaseSync } from "node:sqlite";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Context } from "@deepseek-ai/cordis";
@@ -468,6 +468,67 @@ test("GET /api/dsh-mneme/semantic/llm-audit/stats aggregates by source and statu
   store.close();
 });
 
+// by_operation / by_day 是面板「token 去向」环形图与 7 天柱状的数据源。
+// 锁三件事：① 环形图直接按返回顺序画段，所以 by_operation 必须按
+// total_tokens 降序、by_day 必须按 day 升序（前端不再排）；② 每行带完整的
+// in/out/total 拆分（by_source 只有 total，画不出输入/输出对照）；
+// ③ write_admission 只计量不调 LLM，token 恒 0 是设计——它必须作为一行
+// 出现且为 0，防的是将来有人把 0 行过滤掉或当成异常补齐。
+test("GET /api/dsh-mneme/semantic/llm-audit/stats breaks spend down by operation and by day", async () => {
+  const { store, service, routes } = apiSetup();
+  const day1 = new Date(Date.now() - 2 * 86400000).toISOString();
+  const day2 = new Date(Date.now() - 1 * 86400000).toISOString();
+  service.saveLlmAudit({
+    timestamp: day1,
+    trigger_source: "autoDream", operation_type: "dream_consolidate",
+    model_id: "m", input_tokens: 100, output_tokens: 40, status: "success"
+  });
+  service.saveLlmAudit({
+    timestamp: day1,
+    trigger_source: "writeAdmission", operation_type: "write_admission",
+    model_id: "m", input_tokens: 0, output_tokens: 0, status: "success"
+  });
+  service.saveLlmAudit({
+    timestamp: day2,
+    trigger_source: "autoDream", operation_type: "dream_consolidate",
+    model_id: "m", input_tokens: 10, output_tokens: 5, status: "success"
+  });
+  service.saveLlmAudit({
+    timestamp: day2,
+    trigger_source: "autoSummarize", operation_type: "summarize_compress",
+    model_id: "m", input_tokens: 30, output_tokens: 10, status: "success"
+  });
+  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);
+
+  // by_operation：total_tokens 降序，含 in/out/total 拆分
+  assert.deepEqual(
+    stats.by_operation.map((o) => o.operation),
+    ["dream_consolidate", "summarize_compress", "write_admission"]
+  );
+  const consolidate = stats.by_operation[0];
+  assert.equal(consolidate.c, 2);
+  assert.equal(consolidate.input_tokens, 110);
+  assert.equal(consolidate.output_tokens, 45);
+  assert.equal(consolidate.total_tokens, 155);
+  const admission = stats.by_operation.find((o) => o.operation === "write_admission");
+  assert.equal(admission.c, 1);
+  assert.equal(admission.total_tokens, 0);
+
+  // by_day：date(timestamp)（UTC）分组，day 升序
+  const d1 = day1.slice(0, 10);
+  const d2 = day2.slice(0, 10);
+  assert.deepEqual(stats.by_day.map((d) => d.day), [d1, d2]);
+  assert.equal(stats.by_day[0].c, 2);
+  assert.equal(stats.by_day[0].total_tokens, 140);
+  assert.equal(stats.by_day[1].c, 2);
+  assert.equal(stats.by_day[1].total_tokens, 55);
+  store.close();
+});
+
 // ------------------------------------------- entity extraction (issue #250)
 // 实体抽取是「每次写入记忆都会跑」的后台 LLM 链路，但 createEntityStreamAdapter
 // 只拿到 llm 句柄、没有 service，所以从来没有写审计的能力——面板因此回答不了
@@ -561,6 +622,97 @@ test("entity extraction writes no audit row when llmAudit.enabled === false", as
   store.close();
 });
 
+// #405：实体抽取的审计行此前把失败原因压成一句常量、related_memory_ids 恒空，于是
+// 429 / 配额 / 鉴权 / 超时在库里长得一模一样（主库 735 条 entity_extract error 行全
+// 是「llm stream aborted or errored」），也查不出是哪条记忆没抽到实体。四条锁：原因
+// 落进 error_message（复用 dream 的 describeStreamFailure，全仓归一只此一份）、无
+// 细节时退回旧字面量、归属 id 传得进来且不凭空造、抛错路径同样带归属。
+test("#405: entity extraction audit records the stream failure cause, not a constant", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield {
+          type: "finish",
+          reason: { kind: "error", failure: { code: "rate_limited", message: "429 Too Many Requests", status: 429 } }
+        };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    { memoryId: "mem-1" }
+  );
+  assert.equal(text, undefined, "a failed stream yields no text");
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.status, "error");
+  assert.equal(row.error_message, "rate_limited: 429 Too Many Requests",
+    "code + message from chunk.reason.failure survive into the audit row");
+  assert.notEqual(row.error_message, "llm stream aborted or errored",
+    "the constant that made every provider failure look identical is gone");
+  assert.deepEqual(row.related_memory_ids, ["mem-1"],
+    "the row is attributable to the memory that was being extracted");
+  store.close();
+});
+
+test("#405: entity extraction audit keeps the legacy wording when the failure has no detail", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        // 老形态：只有 kind，既没有 failure 也没有 message（dsh-llm 早期版本、或
+        // 替身）。这时退回旧字面量——把 error_message 写成空串在库里比一句常量更
+        // 难查，那等于用另一种方式把原因丢掉。
+        yield { type: "finish", reason: { kind: "aborted" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  await streamEntityText([{ role: "user", content: [{ type: "text", text: "记忆内容" }] }], {});
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.error_message, "llm stream aborted or errored");
+  assert.deepEqual(row.related_memory_ids, [], "no memoryId → still empty, never fabricated");
+  store.close();
+});
+
+test("#405: entity extraction audit attributes a thrown stream error to the memory too", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        throw new Error("socket hang up");
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  await streamEntityText([{ role: "user", content: [{ type: "text", text: "记忆内容" }] }], { memoryId: "mem-9" });
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.status, "error");
+  assert.equal(row.error_message, "socket hang up");
+  assert.deepEqual(row.related_memory_ids, ["mem-9"], "the throw path attributes too");
+  store.close();
+});
+
+test("#405: the failure-cause formatter stays a single implementation", async () => {
+  const indexSrc = readFileSync(new URL("../src/index.js", import.meta.url), "utf8");
+  const dreamSrc = readFileSync(new URL("../src/dream.js", import.meta.url), "utf8");
+  assert.match(indexSrc, /describeStreamFailure/, "index.js reuses dream.js's formatter");
+  // 有人在这里就地重写 code/message 拼接，就又多出一份口径——#411 的教训是「复制
+  // 粘贴漂移不是设计，是漂移」。锁死两端：归一逻辑只许在 dream.js 里存在一次。
+  assert.equal(indexSrc.match(/failure\.code/g), null, "index.js must not re-format the failure code itself");
+  assert.equal(dreamSrc.match(/function describeStreamFailure\(/g).length, 1, "exactly one definition");
+});
+
 // 启动期保留清理（Bug8）必须与写入侧读**同一份**配置。面板把 llmAudit.enabled 写进
 // kv、经 nestedFlags 合进 cfg，bundle 里可能是关的：清理若读 rawCfg，就会出现「面板
 // 说开 → 各写入点照写，raw 说关 → 不清理」这种无保留期的增长（写入准入 #254 也是读
@@ -596,3 +748,40 @@ test("boot retention purge reads the assembled config, not rawCfg", async () =>
   after.close();
   assert.equal(left, 0, "面板开着的审计必须按 cfg 清理，否则审计行只增不减");
 });
+
+// #399 的启动期裁剪同理：留存开关与保留期都要取装配后的 cfg。这里额外锁一条
+// 「默认关就不动手」——留存是 opt-in，默认关时一张空表不该被每次启动扫一遍。
+test("boot purge trims expired distill records only when retention is on (issue #399)", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-distill-retention-"));
+  const dbPath = join(dir, "memory.db");
+
+  const seed = createStore(dbPath);
+  createSettings(seed.db).setFeatureFlags({ "distillRecords.enabled": true, "distillRecords.retentionDays": 1 });
+  seed.saveDistillRecords([
+    {
+      sessionId: "s-boot",
+      seq: 1,
+      role: "user",
+      text: "过期原文",
+      windowId: "s-boot:1",
+      distilledAt: new Date(Date.now() - 2 * 86400000).toISOString()
+    }
+  ]);
+  assert.equal(seed.db.prepare("SELECT count(*) AS c FROM distill_records").get().c, 1, "先放一行过期原文");
+  seed.close();
+
+  const ctx = new Context();
+  ctx.provide("tools", { register() { return () => {}; } });
+  ctx.provide("commands", { register() { return () => {}; } });
+  ctx.provide("systemPrompt", { context() { return () => {}; } });
+  ctx.provide("agentDefaultModel", { currentSelection() { return { provider: "mock", model: "mock" }; } });
+  ctx.provide("llm", { async *stream() { yield { type: "finish", reason: { kind: "stop" } }; } });
+  ctx.provide("webServer", { register() { return () => {}; } });
+  // bundle 说关、面板说开（保留期 1 天，那行已过期 2 天）：只有读装配后的 cfg 才会清掉
+  await ctx.plugin(mneme, { memoryDir: dir, distillRecords: { enabled: false, retentionDays: 1 } });
+
+  const after = new DatabaseSync(dbPath);
+  const left = after.prepare("SELECT count(*) AS c FROM distill_records").get().c;
+  after.close();
+  assert.equal(left, 0, "面板开着的留存必须按 cfg 裁剪，否则原文只增不减");
+});

package/test/maintenance.test.js

@@ -102,8 +102,8 @@ test("dry-run：报出将清理的行数与列文本大小，一个字节都不
 
     assert.equal(report.dryRun, true);
     assert.equal(report.olderThanDays, 7, "默认保留窗口 7 天");
-    assert.deepEqual(report.planned, { dream_run_inputs: 1, archived_embeddings: 1 });
-    assert.deepEqual(report.cleared, { dream_run_inputs: 0, archived_embeddings: 0 });
+    assert.deepEqual(report.planned, { dream_run_inputs: 1, archived_embeddings: 1, distill_records: 0 });
+    assert.deepEqual(report.cleared, { dream_run_inputs: 0, archived_embeddings: 0, distill_records: 0 });
     assert.ok(report.column_bytes.dream_run_inputs > 600, "列文本大小要给真实数字（它是上界）");
     assert.equal(typeof report.size.before_bytes, "number");
     assert.equal(report.vacuum.ran, false);
@@ -116,6 +116,41 @@ test("dry-run：报出将清理的行数与列文本大小，一个字节都不
   }
 });
 
+test("dry-run 与执行：蒸馏原文进报告，裁剪只删原文、溯源链接留住（#399）", () => {
+  const { store, close } = fileStore();
+  try {
+    seed(store);
+    const old = new Date(NOW - 30 * DAY).toISOString();
+    const fresh = new Date(NOW - 1 * DAY).toISOString();
+    store.saveDistillRecords([
+      { sessionId: "s-old", seq: 1, role: "user", text: "z".repeat(600), windowId: "s-old:1", distilledAt: old },
+      { sessionId: "s-fresh", seq: 1, role: "user", text: "新窗口的原文", windowId: "s-fresh:1", distilledAt: fresh }
+    ]);
+    const memoryId = store.all()[0].id;
+    store.saveMemoryProvenance({ memoryId, sessionId: "s-old", seqStart: 1, seqEnd: 1, createdAt: old });
+
+    // dry-run：第三项要报出真实行数与列文本大小（上界），且一个字节都不改
+    const dry = maintenanceFor(store).reclaim({ dryRun: true });
+    assert.equal(dry.planned.distill_records, 1, "只有窗口外那行算数");
+    assert.ok(dry.column_bytes.distill_records >= 600, "蒸馏原文的列文本大小要给真实数字");
+    assert.equal(store.db.prepare("SELECT count(*) AS c FROM distill_records").get().c, 2, "dry-run 不删原文");
+
+    const applied = maintenanceFor(store).reclaim({ dryRun: false });
+    assert.equal(applied.cleared.distill_records, 1);
+    const rows = store.db.prepare("SELECT session_id FROM distill_records").all();
+    assert.deepEqual(rows.map((r) => r.session_id), ["s-fresh"], "窗口内原文留住");
+    // 裁剪只删原文：链接与记忆都留着，面板/CLI 显示「来源已过期」而不是查无此记忆。
+    assert.equal(
+      store.db.prepare("SELECT count(*) AS c FROM memory_provenance").get().c,
+      1,
+      "溯源链接刻意保留，指向已空区间"
+    );
+    assert.equal(rawMemoryCount(store), 2, "裁剪原文不删记忆");
+  } finally {
+    close();
+  }
+});
+
 test("执行：只清窗口外的输入快照，run 的骨架与决策原文留住", () => {
   const { store, close } = fileStore();
   try {
@@ -191,6 +226,8 @@ test("VACUUM 失败不回吞：清理照做、报告与回执都带上失败原
         clearDreamRunInputs: (b) => store.clearDreamRunInputs(b),
         archivedEmbeddingStats: () => store.archivedEmbeddingStats(),
         clearArchivedEmbeddings: () => store.clearArchivedEmbeddings(),
+        distillRecordStats: (b) => store.distillRecordStats(b),
+        clearDistillRecords: (b) => store.clearDistillRecords(b),
         storageStats: () => store.storageStats(),
         saveLlmAudit: (e) => store.saveLlmAudit(e),
         vacuum: () => { throw new Error("SQLITE_BUSY: database is locked"); }
@@ -389,3 +426,76 @@ test("CLI：--vacuum 单独用会被拒（dry-run 没有可回收的页），也
   assert.equal(result.status, 1);
   assert.match(result.stderr, /--vacuum 需要配 --apply/);
 });
+
+test("HTTP 面（数据面）：窗口上界与确认门里的抛错都跟面板侧同口径（#411）", async () => {
+  // 这张脸曾是面板路由的整段复制，于是 #410 修好面板侧之后它停在旧形态：#508 没有
+  // 上界（1e20 打进来 → maintenance 算日期抛 RangeError → 一个字节都不回），#523 的
+  // confirm-required 报告也没兜错。现在两处口径都来自 src/reclaim-http.js，这条锁从
+  // **数据面自己的端口**打真 HTTP，证明它真的走的是同一份。
+  const { store, close } = fileStore();
+  const maintenance = maintenanceFor(store);
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const api = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: 0, maintenance });
+  await api.ready;
+  const url = `http://127.0.0.1:${api.port}/maintenance/reclaim`;
+  const post = (body) =>
+    fetch(url, {
+      method: "POST",
+      headers: { authorization: `Bearer ${api.token}`, "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  // 第二个实例：不传 maintenance（「没接线」的那一档）。在 try 之外建、在 finally 里
+  // 关——它要是漏关，node --test 会挂着一个开着的 server 句柄永不退出（变异检验里
+  // 一旦断言先炸就正好踩这条）。
+  const unplugged = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: 0 });
+  await unplugged.ready;
+  try {
+    const { archived } = seed(store);
+
+    // 顺序也是契约：端点整个没接线时，报「窗口不合法」是误导——调用方会去改窗口，
+    // 改完照样 503。所以 503 必须赢过字段校验（面板侧同一条，见 api-routes-gaps.test.js）。
+    const unpluggedRes = await fetch(`http://127.0.0.1:${unplugged.port}/maintenance/reclaim`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${unplugged.token}`, "content-type": "application/json" },
+      body: JSON.stringify({ olderThanDays: 1e20 })
+    });
+    assert.equal(unpluggedRes.status, 503, "没接线要赢过字段校验");
+    assert.equal((await unpluggedRes.json()).error, "maintenance-unavailable");
+
+    // 量级超界：旧形态下这一发既不改数据、也不回任何字节。
+    for (const huge of [3651, 1e20]) {
+      const out = await post({ dryRun: false, olderThanDays: huge });
+      assert.equal(out.status, 400, `olderThanDays=${huge} 必须被拒，而不是把连接挂住`);
+      assert.equal((await out.json()).error, "invalid-older-than-days");
+    }
+    const atLimit = await post({ olderThanDays: 3650 });
+    assert.equal(atLimit.status, 200, "上界本身合法");
+    assert.equal((await atLimit.json()).olderThanDays, 3650);
+    assert.ok(rawVec(store, archived.id), "被拒的那几发一个字节都不能改");
+
+    // 确认门的报告要描述「将要执行的那个动作」，且窗口是调用方问的那个。
+    const refused = await post({ dryRun: false, olderThanDays: 30, vacuum: true });
+    assert.equal(refused.status, 400);
+    const refusedBody = await refused.json();
+    assert.equal(refusedBody.error, "confirm-required");
+    assert.equal(refusedBody.report.olderThanDays, 30, "报告必须说的是被问的那个窗口");
+    assert.equal(refusedBody.report.vacuum.requested, true, "报告必须描述将要执行的那个动作（含 vacuum）");
+    assert.ok(rawVec(store, archived.id), "缺 confirm 时一个字节都不改");
+
+    const applied = await post({ dryRun: false, confirm: true, vacuum: true });
+    assert.equal(applied.status, 200);
+    const appliedBody = await applied.json();
+    assert.equal(appliedBody.olderThanDays, 7, "不传窗口就是默认 7 天");
+    assert.equal(appliedBody.cleared.dream_run_inputs, 1);
+    assert.equal(appliedBody.vacuum.requested, true, "勾了 VACUUM 就必须真带上");
+    assert.equal(appliedBody.vacuum.ran, true);
+    assert.equal(rawVec(store, archived.id), null);
+  } finally {
+    unplugged.server.closeIdleConnections?.();
+    unplugged.server.close();
+    api.server.closeIdleConnections?.();
+    api.server.close();
+    close();
+  }
+});

package/test/mint-source.test.js

@@ -0,0 +1,202 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { applyDecisions, validateDecisions } from "../src/dream/decisions.js";
+import { runSleep } from "../src/dream/sleep.js";
+import { createDreamScheduler } from "../src/dream.js";
+
+// 机器 mint 的记忆必须带真 source。
+//
+// 背景（现场实测，2026-10-14）：pattern 表的 144 行 source 全是 "manual"，
+// 而按 dream_runs 的 patterns.applied 逐轮求和恰好也是 144——它们全是 sleep 的
+// phasePatterns mint 的，那个 "manual" 只是 saveWithDedupe 没拿到 source 时的
+// 兜底值。于是「这类条目从哪来」在数据面上不可读，靠它做的判断（service.js 里
+// 那条「pattern 只由手工写入」）也就跟着错了。
+//
+// 这组用例锁两件事：① 三条 mint 管道各自声明自己的来源；② 来源只能由调用方给，
+// 模型写在决策对象上的 source 一律不算数——validateDecisions 不剥离未知字段，
+// 若 applyCreate 信了 d.source，模型就能给自己的输出盖「人写的」戳。
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+function mint(service, extra = {}) {
+  return service
+    .saveWithDedupe({ type: "project", title: `铺垫${Math.random()}`, content: "给扫描窗垫一条普通记忆", importance: 3 })
+    .memory;
+}
+
+// ---------------------------------------------------------------- applyDecisions
+
+test("mint source: applyDecisions stamps the caller's mintSource on create", () => {
+  const { store, service } = setup();
+  const { applied } = applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "从重复里抽出来的规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "sleep" }
+  );
+  assert.equal(applied, 1);
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "sleep", "minted row carries the pipeline provenance");
+  store.close();
+});
+
+test("mint source: dream pipeline stamps 'dream'", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream" }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "dream");
+  store.close();
+});
+
+// 对抗条：来源取自调用方，不取自决策对象。模型自报的 source 必须被忽略——
+// 否则「机器写的不冒充人写的」这条防线就形同虚设。
+test("mint source: a source on the decision object is ignored, pipeline wins", () => {
+  const { store, service } = setup();
+  const decisions = [
+    { action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3, source: "manual" }
+  ];
+  // 先证明威胁真实存在：这类决策能整个通过校验走到 applyCreate（校验不剥离未知
+  // 字段）。若哪天真加了剥离，这条会红——那时下面的对抗断言也就不再承重了。
+  const { ok } = validateDecisions(decisions, new Map(), { maxCreatePerRun: 3 });
+  assert.equal(ok, true, "a create carrying its own source still validates — that is the threat");
+
+  applyDecisions(decisions, service, null, null, { mintSource: "sleep" });
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "sleep", "the model-authored source must not win");
+  store.close();
+});
+
+// 反向：模型自报 source 而没有管道来源时，也不许它自己说了算——回落到兜底，
+// 而不是让模型指哪打哪。
+test("mint source: without a pipeline source the model-authored one still does not win", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3, source: "human" }],
+    service
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "manual", "falls back to the existing default, not the model's claim");
+  store.close();
+});
+
+// 不传 mintSource 时行为与改前逐字一致（不放大行为面）。
+test("mint source: absent mintSource keeps the previous fallback", () => {
+  const { store, service } = setup();
+  applyDecisions([{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }], service);
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "manual");
+  store.close();
+});
+
+// 空白串按「没给」处理，不能写出 source="" 这种假装有来源的空值。
+test("mint source: blank mintSource is treated as absent", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "   " }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "manual");
+  store.close();
+});
+
+// ------------------------------------------------------------------ end to end
+
+// sleep 的 pattern 相位（唯一的真实 mint 路径）端到端：断言落库行的 source。
+// 不能靠等下一次做梦验收（要调度 + LLM 路由），所以在这里驱动相位。
+function sleepCtx(decisionsJson) {
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        yield { type: "text-delta", index: 0, text: userText.startsWith("id=") ? decisionsJson : "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+test("mint source: sleep pattern phase mints with source=sleep", async () => {
+  const { store, service } = setup();
+  mint(service);
+  mint(service);
+  const ctx = sleepCtx(
+    JSON.stringify([{ action: "create", type: "pattern", title: "真模式", content: "从 a 和 b 提取", importance: 3 }])
+  );
+  const config = {
+    sleepModeEnabled: true,
+    sleepPatternMinMemories: 10,
+    sleepMaxPatternPerRun: 3
+  };
+  const result = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(result.phases.patterns.status, "ok", "pattern phase minted");
+
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern minted");
+  assert.equal(row.source, "sleep", "the sleep phase declares its own provenance");
+  store.close();
+});
+
+test("mint source: dream main chain mints with source=dream", async () => {
+  const { store, service } = setup();
+  const seed = service.saveWithDedupe({ type: "project", title: "旧条目", content: "第一段内容", importance: 3 }).memory;
+  let call = 0;
+  const ctx = {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        call++;
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        const text = call === 1
+          ? JSON.stringify([
+            { action: "keep", ids: [seed.id] },
+            { action: "create", type: "pattern", title: "主链路模式", content: "巩固时发现的规律", importance: 3 }
+          ])
+          : "记忆库总览摘要文本";
+        void userText;
+        yield { type: "text-delta", text };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "mock", dreamModel: "mock-model" });
+  assert.equal(result.ok, true);
+
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "the create decision minted a row");
+  assert.equal(row.source, "dream");
+  store.close();
+});
+
+// 验收口径本身：全表分组统计随之可读——同一次运行 mint 的条目能按来源数出来。
+test("mint source: rows are countable by source after minting", () => {
+  const { store, service } = setup();
+  applyDecisions([{ action: "create", type: "pattern", title: "甲", content: "规律甲", importance: 3 }], service, null, null, { mintSource: "sleep" });
+  applyDecisions([{ action: "create", type: "pattern", title: "乙", content: "规律乙", importance: 3 }], service, null, null, { mintSource: "dream" });
+  const bySource = new Map();
+  for (const m of service.all()) bySource.set(m.source, (bySource.get(m.source) ?? 0) + 1);
+  assert.equal(bySource.get("sleep"), 1);
+  assert.equal(bySource.get("dream"), 1);
+  assert.equal(bySource.get("manual"), undefined, "nothing minted here fell back to the default");
+  store.close();
+});