@modusensus/dsh-mneme 0.8.15 → 0.9.0

package/test/summarize.test.js

@@ -3,6 +3,9 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { DatabaseSync } from "node:sqlite";
+import { Context } from "@deepseek-ai/cordis";
+import * as mneme from "../src/index.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createSummarizer, parseSummaryJson, parsePeakSpec, isInPeakWindow, nextOffPeakAt } from "../src/summarize.js";
@@ -274,6 +277,43 @@ test("#239 窗口过短：零 LLM 预判拦下调用，留 skip 审计并消费
   assert.equal(service.listLlmAudits().length, 1, "游标已消费：同一窗口不重复评估、不重复审计");
 });
 
+// #239 定标埋点：窗口字符数必须落进审计，否则下一级预判规则的阈值无从选起。
+// 第二条才是本改动的目的——预判开关关着（默认档位）时行为逐字节不变，但从这一刻
+// 起成功行开始留数，验收 4「默认配置下调用量可量化下降」才有账可对。
+test("#239 计量：window-too-small 的 skip 行带 distillChars 与阈值", async () => {
+  const { events, service } = setup({ summarizeMinWindowChars: 1000 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-metric-skip",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("好", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  const row = service.listLlmAudits()[0];
+  assert.equal(row.error_message, "window-too-small");
+  // 计的是**真正发给模型的转录文本**长度（含角色前缀：一条 1 字的「好」实测记 4），
+  // 与闸门比较的口径同一个数，定标才对得上。这里不锁字面量，锁语义：短于阈值才该 skip。
+  assert.ok(Number.isInteger(row.metadata?.distillChars) && row.metadata.distillChars > 0,
+    "skip 行必须带窗口字符数");
+  assert.equal(row.metadata.minWindowChars, 1000, "阈值随行落档，事后能复核是哪条闸门拦的");
+  assert.ok(row.metadata.distillChars < row.metadata.minWindowChars, "skip 的前提：窗口短于阈值");
+});
+
+test("#239 计量：预判开关关闭时成功行仍记录 distillChars", async () => {
+  const { events, service } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-metric-success",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("今天决定把窗口字符数记进审计", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  const row = service.listLlmAudits()[0];
+  assert.equal(row.status, "success");
+  assert.ok(Number.isInteger(row.metadata?.distillChars) && row.metadata.distillChars > 0,
+    "默认档位下也要留数，否则验收 4 无从对账");
+});
+
 test("#239 窗口达到阈值时预判放行（不误杀）", async () => {
   const { events, calls } = setup({ summarizeMinWindowChars: 5 });
   const handler = events.find((e) => e.name === "session/event").fn;
@@ -1463,3 +1503,313 @@ test("parseSummaryJson salvage does not turn string-embedded objects into memori
   assert.equal(parsed[0].title, "good");
   assert.match(parsed[0].content, /fake/);
 });
+
+// ── Issue #399：蒸馏窗口原始记录 + 记忆级溯源 ─────────────────────────────
+//
+// 这五条锁的是「把蒸馏从替换降级为叠加索引」的四个承重点：重跑幂等、隐私谓词
+// 在落盘路径同样成立、留存不受喂给模型的裁剪约束、裁剪不毁资产、默认关零写入。
+// 锁形状而非锁实现：断言直接查表，不去读 summarize.js 的中间变量。
+
+/** Issue #399 的开启档 + 关掉真实节流（否则同会话第二轮会被间隔门挡下）。 */
+const RECORDS_ON = { distillRecords: { enabled: true }, distillRateLimitIntervalMs: 0 };
+
+function countRows(store, sql) {
+  return store.db.prepare(sql).get().c;
+}
+
+function recordsSession(id, events) {
+  return {
+    id,
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events
+  };
+}
+
+function eventHandler(events) {
+  return events.find((e) => e.name === "session/event").fn;
+}
+
+test("issue#399: re-distilling the same window never duplicates records", async () => {
+  const first = setup(RECORDS_ON);
+  const session = recordsSession("s399-idem", [userMessage("同一窗口的提问", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(first.events)(session, { seq: 2, type: "turn/end" });
+  assert.equal(countRows(first.store, "SELECT count(*) AS c FROM distill_records"), 1);
+
+  // 模拟宿主重启后重跑同一 seq 段（代码注释里点名的路径：max-runs 耗尽额度、游标
+  // 写入随事务回滚后丢失）：删掉持久化游标 + 换一个全新的 summarizer 实例，于是
+  // lastDistilledSeq 这份内存游标也一并归零，同一窗口会被完整重蒸一遍。
+  first.store.db.prepare("DELETE FROM distill_cursors").run();
+  const second = setup(RECORDS_ON, { store: first.store });
+  await eventHandler(second.events)(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(
+    countRows(first.store, "SELECT count(*) AS c FROM distill_records"),
+    1,
+    "同一 (session_id, seq) 只留一行：重跑必须幂等，保留首次落盘时间才诚实"
+  );
+  assert.equal(
+    countRows(
+      first.store,
+      `SELECT count(*) AS c FROM (
+         SELECT memory_id, session_id, seq_start, seq_end FROM memory_provenance
+         GROUP BY memory_id, session_id, seq_start, seq_end HAVING count(*) > 1)`
+    ),
+    0,
+    "同一窗口重跑不重复挂链接（唯一索引 + ON CONFLICT DO NOTHING）"
+  );
+});
+
+test("issue#399: records keep only public transcript; reasoning and machine-injected content never land on disk", async () => {
+  const { events, store, calls } = setup(RECORDS_ON);
+  const session = recordsSession("s399-priv", [
+    userMessage("真实提问：这个报错怎么修", 1),
+    // 机器注入的三类：AGENTS.md / skill 正文 / 文件变更通知。source.kind 不是
+    // user / agent-message / subagent-settled，必须整个事件被挡在门外。
+    { seq: 2, type: "user/message", data: { source: { kind: "plugin" }, content: [{ type: "text", text: "AGENTS.md 注入正文不该落盘" }] } },
+    { seq: 3, type: "user/message", data: { source: { kind: "skill" }, content: [{ type: "text", text: "SKILL_BODY 不该落盘" }] } },
+    { seq: 4, type: "user/message", data: { source: { kind: "file-change" }, content: [{ type: "text", text: "FILE_CHANGE 通知不该落盘" }] } },
+    {
+      seq: 5,
+      type: "assistant/message",
+      data: { message: { content: [
+        { type: "reasoning", text: "PRIVATE_REASONING 不该落盘" },
+        { type: "text", text: "公开回答：检查第 3 行。" }
+      ] } }
+    },
+    toolResultEvent("TOOL_OUTPUT 只进渲染不落盘", false, 6),
+    { seq: 7, type: "turn/end" }
+  ]);
+  await eventHandler(events)(session, { seq: 7, type: "turn/end" });
+
+  const texts = store.db.prepare("SELECT text FROM distill_records ORDER BY seq").all().map((r) => r.text).join("\n");
+  assert.ok(texts.includes("真实提问"), "用户提示落盘");
+  assert.ok(texts.includes("公开回答"), "助手公开正文落盘");
+  assert.ok(!texts.includes("AGENTS.md"), "插件注入的 AGENTS.md 绝不落盘");
+  assert.ok(!texts.includes("SKILL_BODY"), "skill 正文绝不落盘");
+  assert.ok(!texts.includes("FILE_CHANGE"), "文件变更通知绝不落盘");
+  assert.ok(!texts.includes("PRIVATE_REASONING"), "私有推理链绝不落盘");
+  assert.ok(!texts.includes("TOOL_OUTPUT"), "工具结果不落盘（#399 已知边界 3）");
+  // 渲染路径照旧带工具输出（codingRetrospect 靠它沉淀踩坑根因）——两条路径在
+  // 「工具输出」上的差异是设计的一部分，不是漂移：漂移的方向必须是「落盘的更少」。
+  assert.ok(JSON.stringify(calls[0].messages).includes("TOOL_OUTPUT"), "工具输出仍进 LLM 转录");
+});
+
+test("issue#399: records keep the untruncated prompt while the LLM transcript stays capped", async () => {
+  // 头部标记 + 超长正文：trimTranscript 保尾部，所以「渲染里找不到头部标记」正是
+  // 被 distillMaxChars 截断的证据；记录里必须连头部标记都在。
+  const long = `HEAD_MARKER ${"x".repeat(1200)} TAIL_MARKER`;
+  const { events, store, calls } = setup({ ...RECORDS_ON, distillMaxChars: 200 });
+  const session = recordsSession("s399-long", [userMessage(long, 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  const rows = store.db.prepare("SELECT text FROM distill_records ORDER BY seq").all();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].text, long, "留存的是整段原文，不截断、不加省略号");
+  assert.ok(!JSON.stringify(calls[0].messages).includes("HEAD_MARKER"), "喂 LLM 的转录仍受 distillMaxChars 约束");
+});
+
+test("issue#399: expiring records keeps the memories and leaves provenance dangling-but-present", async () => {
+  const { events, store } = setup(RECORDS_ON);
+  const session = recordsSession("s399-expire", [userMessage("会被裁剪的原文", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+  assert.equal(store.count(), 2);
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM memory_provenance"), 2);
+
+  // 到期裁剪：把 cutoff 推到未来，等价于「这条记录已经过期」。
+  assert.equal(store.clearDistillRecords(new Date(Date.now() + 86400000).toISOString()), 1);
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM distill_records"), 0);
+  assert.equal(store.count(), 2, "裁剪原文绝不级联删记忆");
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM memory_provenance"), 2, "链接保留，从此指向空区间");
+  const memoryId = store.all()[0].id;
+  assert.ok(store.provenanceFor(memoryId).length >= 1, "面板/CLI 仍能回答「这条记忆出自哪个窗口」，只是来源已过期");
+});
+
+test("issue#399: enabled=false (the default) writes nothing at all", async () => {
+  const { events, store, service } = setup({ distillRateLimitIntervalMs: 0 });
+  let saverCalls = 0;
+  const original = service.saveDistillRecords;
+  service.saveDistillRecords = (...args) => {
+    saverCalls++;
+    return original(...args);
+  };
+  const session = recordsSession("s399-off", [userMessage("默认关不该留原文", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(saverCalls, 0, "默认关：连收集都不做，一次写入调用都不发");
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM distill_records"), 0);
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM memory_provenance"), 0);
+  assert.equal(store.count(), 2, "记忆写入照旧");
+});
+// ── 蒸馏留存：开关从「设置面」一路走到「盘上有行」 ──────────────────────────────
+//
+// 上面 #399 那五条锁的是 summarize.js 内部的行为，它们把 config 直接递给
+// createSummarizer。真实链路上，config 不来自测试也不来自 bundle：它由 index.js
+// 在**启动时**把 kv（feature_flags，面板 PUT /api/dsh-mneme/features 写的就是它）
+// 合并进 cfg 得到，再交给 createSummarizer。中间两环——设置面写入与启动期
+// 合并——一条测试都没覆盖过，而它们正是「distill_records 行数开始增长」这条
+// 验收判据的唯一通路：开关没写进 kv，或者写进了但装配时没被读出来，盘上就永远
+// 是 0 行，而 summarize.js 内部的五条锁照样全绿。
+//
+// 所以这两条不在 createSummarizer 层造 config，而是起一个最小宿主（真实 cordis
+// Context + 六个服务位），让 ctx.plugin(mneme, …) 走完 index.js 的装配：
+//   ① kv 写开 → 装配 → 派发 turn/end → 原文与溯源链接都落盘；
+//   ② 同一个装配但 kv 一个键都不写（默认态）→ 两表 0 行，记忆写入照旧。
+// 第二条守的是反面：装配默认不许把 opt-in 的开关私自打开。
+
+/** 最小宿主：六个服务位按 webServer-optional.test.js 的形状提供。 */
+function minimalHost() {
+  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: "block-start", block: { type: "text" } };
+      yield {
+        type: "text-delta",
+        delta: JSON.stringify([
+          { type: "decision", title: "选型", content: "确定用 node:sqlite", importance: 4 },
+          { type: "preference", title: "语言", content: "用户喜欢中文交流", importance: 5 }
+        ])
+      };
+      yield { type: "block-end", block: { type: "text" } };
+      yield { type: "finish", kind: "ok" };
+    }
+  });
+  ctx.provide("webServer", { register() { return () => {}; } });
+  return ctx;
+}
+
+/** 盘上的三张表：装配前后各查一次，才知道行是谁写的。 */
+function readTables(dbPath) {
+  const db = new DatabaseSync(dbPath);
+  const count = (table) => db.prepare(`SELECT count(*) AS c FROM ${table}`).get().c;
+  const out = {
+    records: count("distill_records"),
+    provenance: count("memory_provenance"),
+    memories: count("memories")
+  };
+  out.rows = db.prepare("SELECT session_id, seq, role, text FROM distill_records ORDER BY seq").all();
+  db.close();
+  return out;
+}
+
+/** 装配 + 派发 turn/end + 拆掉装配（不给宿主留开着的手柄）。 */
+async function bootAndDistill(config, session) {
+  const ctx = minimalHost();
+  const fiber = ctx.plugin(mneme, config);
+  await fiber;
+  // ctx.parallel 会等所有监听器跑完；summarize.js 的监听器 return 了这次写入的
+  // promise（summarize.js 的 session/event 订阅处明写「Return the summarization
+  // promise so awaiters observe the writes」），所以并行派发完就是写完了。
+  await ctx.parallel("session/event", session, { seq: 2, type: "turn/end" });
+  await fiber.dispose();
+}
+
+test("distill records grow from the settings face all the way to disk", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-distill-on-"));
+  const dbPath = join(dir, "memory.db");
+  try {
+    // 第一环：用产品自己的设置面写 kv，等价于面板 PUT /api/dsh-mneme/features。
+    const seed = createStore(dbPath);
+    const merged = createSettings(seed.db).setFeatureFlags({ "distillRecords.enabled": true });
+    assert.equal(merged["distillRecords.enabled"], true, "开关必须先真的落进 kv");
+    assert.equal(readTables(dbPath).records, 0, "开之前盘上一行都没有");
+    seed.close();
+
+    // 第二环 + 第三环：装配时 bundle 说关、kv 说开，合并取 kv；然后真跑一次蒸馏。
+    await bootAndDistill(
+      { memoryDir: dir, distillRecords: { enabled: false }, distillRateLimitIntervalMs: 0 },
+      recordsSession("s-distill-on", [userMessage("这句话该落进 distill_records", 1), { seq: 2, type: "turn/end" }])
+    );
+
+    const after = readTables(dbPath);
+    assert.equal(after.records, 1, "装配读过 kv 之后，原文必须真的落盘");
+    assert.equal(after.rows[0].session_id, "s-distill-on");
+    assert.equal(after.rows[0].seq, 1);
+    assert.equal(after.rows[0].role, "user");
+    assert.match(after.rows[0].text, /该落进 distill_records/, "落盘的是公开正文原文");
+    assert.equal(after.memories, 2, "记忆照常写入，留存是叠加不是替换");
+    assert.equal(after.provenance, 2, "每条新记忆各落一条回指链接");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("the same assembly writes nothing when the flag was never set", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-distill-off-"));
+  const dbPath = join(dir, "memory.db");
+  try {
+    // 连 createStore 都不预先起：一个全新的库就是「从没碰过设置面」的真实形态。
+    await bootAndDistill(
+      { memoryDir: dir, distillRateLimitIntervalMs: 0 },
+      recordsSession("s-distill-off", [userMessage("默认态：不该有原文落盘", 1), { seq: 2, type: "turn/end" }])
+    );
+
+    const after = readTables(dbPath);
+    assert.equal(after.records, 0, "opt-in 的开关不许被装配私自打开");
+    assert.equal(after.provenance, 0);
+    assert.equal(after.memories, 2, "关的只是留存，蒸馏本身照常");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+
+// v0.9.0（M.O. 项目记忆）：机器提炼是写入量的绝大多数，而它此前一个作用域字段都不带
+// ——全库带 scope 的行不足 3%，且全部来自 memory_save 那条工具路径。这组用例钉住
+// 「蒸馏写入也盖章」这件事：值取 session.header（agentPreset + cwd），闸门与工具路径
+// 同一把（scopeEnabled），来源一律 'auto'（auto 不构成硬墙，只吃软加权，见
+// test/scope-strict.test.js 的 "auto and legacy rows are NOT hard walls" 用例，
+// 2026-10-13 在 :41-54）。
+function scopedSession(id, header) {
+  const session = {
+    id,
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("继续"), { seq: 2, type: "turn/end" }]
+  };
+  if (header !== undefined) session.header = header;
+  return session;
+}
+
+test("v0.9.0: scopeEnabled 开时蒸馏写入盖 auto 章（agent=agentPreset、workspace=header.cwd）", async () => {
+  const { events, store } = setup({ scopeEnabled: true });
+  const session = scopedSession("mo-scope", { agentPreset: "amarre", cwd: "C:\\work\\dsh-mneme" });
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  const rows = store.list({ limit: null });
+  assert.equal(rows.length, 2, "两个条目都落库");
+  for (const row of rows) {
+    assert.equal(row.agent_scope, "amarre", "agent 维取自 session.header.agentPreset");
+    assert.equal(row.agent_scope_source, "auto", "来源必须标 auto：显式声明才会构成硬过滤");
+    assert.equal(row.workspace_scope, "C:\\work\\dsh-mneme", "workspace 维取自 session.header.cwd");
+    assert.equal(row.workspace_scope_source, "auto");
+  }
+});
+
+test("v0.9.0: 解析不出身份时照样标 auto、值落 NULL（与「从未标注」可区分）", async () => {
+  const { events, store } = setup({ scopeEnabled: true });
+  // 无 header、无 workspaceRegistry（mock ctx 只有 on/llm）：正是老会话/测试环境的形状。
+  await eventHandler(events)(scopedSession("mo-scope-anon"), { seq: 2, type: "turn/end" });
+
+  for (const row of store.list({ limit: null })) {
+    assert.equal(row.agent_scope, undefined);
+    assert.equal(row.workspace_scope, undefined);
+    // 关键区别：*_source='auto' 说明「自动标注跑过但没解析出值」，NULL 值才等于全局可见。
+    assert.equal(row.agent_scope_source, "auto");
+    assert.equal(row.workspace_scope_source, "auto");
+  }
+});
+
+test("v0.9.0: scopeEnabled 关时蒸馏写入一个 scope 字段都不加（老行为不变）", async () => {
+  const { events, store } = setup({});
+  await eventHandler(events)(scopedSession("mo-scope-off", { agentPreset: "amarre", cwd: "C:\\work\\dsh-mneme" }), { seq: 2, type: "turn/end" });
+
+  for (const row of store.list({ limit: null })) {
+    assert.equal(row.agent_scope, undefined);
+    assert.equal(row.agent_scope_source, undefined);
+    assert.equal(row.workspace_scope, undefined);
+    assert.equal(row.workspace_scope_source, undefined);
+  }
+});

package/test/supersede-state-tracking.test.js

@@ -337,10 +337,10 @@ test("supersede 后注入语义候选池（向量命中 / 语义缓存）不得
   const { store, service, legacy, current } = await supersededFixture({ embedder: semanticEmbedder() });
   service.setVectorIndex(leakyVectorIndex(store));
 
-  // 先填一次语义缓存：新查询的首帧 render 没有 queryVector（src/inject.js:327
-  // 的预取是异步 .then），只能吃 lastSemanticRecall。真实检索不会吐归档行，
-  // 是上面的假索引在源侧失守。填缓存的这一刻已经是 supersede 之后，所以缓存
-  // 条目里 loser 的 archived 是 true。
+  // 先填一次语义缓存：新查询的首帧 render 没有 queryVector（src/inject.js 的
+  // prefetchQueryVector 预取是异步 .then，2026-10-14 在 :296），只能吃
+  // lastSemanticRecall。真实检索不会吐归档行，是上面的假索引在源侧失守。填缓存
+  // 的这一刻已经是 supersede 之后，所以缓存条目里 loser 的 archived 是 true。
   const cached = await service.searchMemories(QUERY, { mode: "vector", useRerank: false, recordRecall: false });
   const cachedOld = cached.find((r) => r.id === legacy.id);
   // 夹具自检：确认缓存里确实躺着带 archived 标记的旧值，否则 (e) 是空压。

package/test/tools.test.js

@@ -8,6 +8,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createTools } from "../src/tools.js";
 import { TRANSFORMERS_ENTRY, defaultModelCacheDir, payloadDir, payloadId } from "../src/runtime/layout.js";
+import { hostModulesDir } from "../src/runtime/provision.js";
 
 function setup(embedder, config = {}) {
   const store = createStore(":memory:");
@@ -370,7 +371,21 @@ test("memory_runtime：status 只读且带代价说明；两条来源都不可
   const provision = await tool.execute({ action: "provision" });
   assert.deepEqual(validateJsonSchemaValue(tool.output.schema, provision), []);
   assert.equal(provision.status, "failed");
-  assert.match(provision.reason, /收编失败|下载失败/);
+  // #323：车道（junction node_modules）里这条用例报过一次红，红的是下面那句「半份 payload」，
+  // 但变的是**环境**不是产品。所以把这条用例赖以成立的前提显式钉在这里：
+  // hostModulesDir 是 import.meta.url 的 4 级上溯，只有装入布局
+  // （<profile>/node_modules/@modusensus/dsh-mneme/src/tools.js → <profile>/node_modules）
+  // 才指向真的 node_modules；仓库根与车道布局下它落到仓库父目录 / <repo>\.worktrees，
+  // 于是收编在**计划阶段**就因「入口包不存在」零写入地失败——根本没走到物化分支，残留无从产生。
+  // （「物化到一半要清干净」由 runtime-adopt.test.js / runtime-download.test.js 的注入式用例负责，不靠这里。）
+  // 若有人改了目录层级、让源目录变成真的 node_modules，这一条会先红并把推导出的路径打出来，
+  // 而不是让「半份 payload」背一个看不懂的锅。
+  const source = hostModulesDir(new URL("../src/tools.js", import.meta.url).href);
+  assert.match(
+    provision.reason,
+    /收编失败：入口包不存在/,
+    `本用例的前提是「${source} 里没有可收编的 payload」；源目录换了形状，收编就会真的走物化分支（issue #323）`
+  );
   assert.equal(existsSync(runtimeDir) ? readdirSync(runtimeDir).length : 0, 0, "失败后不该留下半份 payload");
 });