@modusensus/dsh-mneme 0.8.4 → 0.8.6

package/test/organize.test.js

@@ -0,0 +1,418 @@
+// #231：agent 主动整理接口——dryRun 比对报告 → agent 判断 → apply；筛除项进归档
+// 不删；调用全程复用 dream_runs 的 receipt 语义（不新建审计面）。维护者口径：
+// 功能本体落在 service 层并带测试，不进工具列表、不加独立 opt-in 开关。
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createOrganizer } from "../src/organize.js";
+import { parseReceipt } from "../src/dream.js";
+
+const preference = (title, content = "内容", extra = {}) =>
+  ({ type: "preference", title, content, importance: 5, ...extra });
+
+/** 单元级 organizer：假 embedQuery 隔离向量档，写路径复用真 service。 */
+function makeOrganizer(embedQuery = async () => null, config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const finalizeCalls = [];
+  const { organize } = createOrganizer({
+    store,
+    embedQuery,
+    saveWithDedupe: service.saveWithDedupe,
+    transaction: service.transaction,
+    finalize: (rows) => finalizeCalls.push(rows)
+  });
+  return { store, service, organize, finalizeCalls };
+}
+
+test("#231: dryRun writes no memory and leaves one organize receipt", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const seeded = service.saveWithDedupe(preference("偏好X", "既有内容")).memory;
+  const report = await organize({
+    mode: "dryRun",
+    candidates: [preference("偏好X", "同一标题的新内容"), { type: "decision", title: "全新决定", content: "库里没有" }]
+  });
+  assert.equal(report.items[0].verdict, "exact");
+  assert.equal(report.items[0].match.id, seeded.id);
+  assert.equal(report.items[1].verdict, "new");
+  assert.equal(report.counts.total, 2);
+  // 比对是报告不是动作：记忆表仍然只有种子那一行。
+  assert.equal(store.list({ limit: null }).length, 1);
+  const run = store.getDreamRun(report.run_id);
+  assert.equal(run.run_type, "organize");
+  assert.equal(run.status, "ok");
+  assert.equal(run.applied, 0);
+  assert.equal(parseReceipt(run.receipt).runId, report.run_id, "receipt 复用 dream 的既有格式");
+});
+
+test("#231: dryRun reports near duplicates with similarity (vector layer)", async () => {
+  const { store, service, organize } = makeOrganizer(async () => [0.99, 0.1, 0]);
+  const seeded = service.saveWithDedupe({ type: "decision", title: "令牌桶限流方案", content: "旧记录" }).memory;
+  store.setEmbedding(seeded.id, [1, 0, 0]);
+  const report = await organize({
+    mode: "dryRun",
+    candidates: [{ type: "decision", title: "限流方案选型", content: "内容相近但换了标题" }]
+  });
+  assert.equal(report.items[0].verdict, "near");
+  assert.equal(report.items[0].match.id, seeded.id);
+  assert.ok(report.items[0].match.sim > 0.9, "相似度带回报告，供 agent 判断");
+  assert.equal(report.counts.near, 1);
+});
+
+test("#231: apply refuses to write without a real dryRun report", async () => {
+  const { store, service, organize } = makeOrganizer();
+  // 先 seed 一行再断言「零写入」：空库 + decisions: [] 本来也不会写，那样的断言恒真、
+  // 抓不住守卫的回归（静态审查指出）。
+  const seeded = service.saveWithDedupe(preference("既有偏好", "原内容")).memory;
+  await assert.rejects(() => organize({ mode: "apply", decisions: [] }), /run_id is required/);
+  await assert.rejects(
+    () => organize({ mode: "apply", run_id: "nope", decisions: [{ action: "save", index: 0 }] }),
+    /unknown organize run/
+  );
+  const rows = store.list({ limit: null });
+  assert.equal(rows.length, 1, "拒绝路径零写入");
+  assert.equal(rows[0].id, seeded.id);
+  assert.equal(rows[0].content, "原内容", "既有行未被改动");
+});
+
+test("#231: write-path control flags never reach the write path through the snapshot (#267 静态审查)", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const victim = service.saveWithDedupe(preference("受害者行", "原内容")).memory;
+  // 原始候选里塞写入端控制旗标：normalizeCandidate 只保留白名单字段，审计存的是它，
+  // apply 重放快照 → 旗标够不到 saveWithDedupe 的 _mergeInto/_overwrite 分支，
+  // 不能借整理接口改写既有行。这是「报告无法被用来越权写入」的钉子。
+  const report = await organize({
+    mode: "dryRun",
+    candidates: [{ ...preference("另一条偏好", "新内容"), _mergeInto: victim.id, _overwrite: true }]
+  });
+  const outcome = await organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] });
+  assert.equal(outcome.saved, 1, "正常写成新行");
+  assert.equal(store.getById(victim.id).content, "原内容", "既有行未被覆写");
+  assert.equal(store.getById(victim.id).title, "受害者行");
+});
+
+test("#231: apply saves kept candidates, records discards, archives instead of deleting", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const stale = service.saveWithDedupe({ type: "project", title: "被取代的状态", content: "过时" }).memory;
+  const report = await organize({
+    mode: "dryRun",
+    candidates: [
+      preference("新偏好"),
+      { type: "decision", title: "被丢掉的决定", content: "不落库" },
+      // 归档要有依据：只有报告命中过的行才有资格被归档，所以这条必须进 dryRun。
+      { type: "project", title: "被取代的状态", content: "新的状态描述" }
+    ]
+  });
+  assert.equal(report.items[2].match.id, stale.id, "第二条项目候选命中的就是待归档那行");
+  const outcome = await organize({
+    mode: "apply",
+    run_id: report.run_id,
+    decisions: [
+      { action: "save", index: 0 },
+      { action: "discard", index: 1 },
+      { action: "archive", id: stale.id }
+    ]
+  });
+  assert.equal(outcome.saved, 1);
+  assert.equal(outcome.discarded, 1);
+  assert.equal(outcome.archived, 1);
+  assert.equal(outcome.status, "ok");
+  // 筛除 = 归档（可恢复），不是删除。
+  assert.equal(store.getById(stale.id).archived, true, "archived row still exists");
+  const titles = store.list({ limit: null }).map((m) => m.title);
+  assert.ok(titles.includes("新偏好"), "kept candidate landed");
+  assert.ok(!titles.includes("被丢掉的决定"), "discarded candidate was not written");
+  // 审计链：apply 回执指向它依据的那份报告。
+  const applyRun = store.getDreamRun(outcome.run_id);
+  assert.equal(applyRun.outcome.dry_run_id, report.run_id);
+  assert.equal(applyRun.applied, 2);
+  assert.equal(parseReceipt(applyRun.receipt).status, "ok");
+});
+
+test("#231: the source columns do not split the match key (#267 评审第二轮)", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const seeded = service.saveWithDedupe({
+    ...preference("同标题的约束"),
+    agent_scope: "agent-b",
+    agent_scope_source: "auto"
+  }).memory;
+  // 只差 agent_scope_source（auto vs explicit）：saveWithDedupe 的去重键不含来源两列，
+  // 所以这必须判成「命中既有行」。比对键里多带来源就会报 new，而 apply 却合并——错位。
+  const report = await organize({
+    mode: "dryRun",
+    candidates: [{ ...preference("同标题的约束"), agent_scope: "agent-b", agent_scope_source: "explicit" }]
+  });
+  assert.equal(report.items[0].verdict, "exact");
+  assert.equal(report.items[0].match.id, seeded.id);
+  const outcome = await organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] });
+  assert.equal(outcome.merged, 1, "报告与写入同口径：命中既有行");
+  assert.equal(outcome.saved, 0);
+  assert.equal(store.list({ limit: null }).length, 1);
+});
+
+test("#231: dryRun compares in the candidate's own scope, not the payload's (#267 评审 1)", async () => {
+  const { service, organize } = makeOrganizer();
+  const seeded = service.saveWithDedupe({ ...preference("同标题的约束"), agent_scope: "agent-b" }).memory;
+  // 载荷级不给 scope，只在候选上给：报告必须按候选自己的 scope 看库，否则同一个
+  // scope 里明明已有同标题行也会报 "new"——报告 scope 与写入 scope 就此错位。
+  const report = await organize({
+    mode: "dryRun",
+    candidates: [{ ...preference("同标题的约束"), agent_scope: "agent-b" }]
+  });
+  assert.equal(report.items[0].verdict, "exact");
+  assert.equal(report.items[0].match.id, seeded.id);
+  // 反向：默认 scope 的候选看不到 agent-b 的行（跨 scope 永不互判，防泄漏）。
+  const other = await organize({ mode: "dryRun", candidates: [preference("同标题的约束")] });
+  assert.equal(other.items[0].verdict, "new");
+});
+
+test("#231: the same report cannot be applied twice (#267 评审 2)", async () => {
+  const { store, organize } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [preference("只应落一次")] });
+  await organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] });
+  await assert.rejects(
+    () => organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }),
+    /already applied/
+  );
+  assert.equal(store.list({ limit: null }).filter((m) => m.title === "只应落一次").length, 1);
+  const receipts = store.listDreamRuns({}).filter((r) => r.outcome?.dry_run_id === report.run_id);
+  assert.equal(receipts.length, 1, "同一份报告只留一份落地回执");
+  assert.ok(store.getDreamRun(report.run_id).outcome.applied_at, "报告行上留了已落地凭证");
+});
+
+test("#231: archive only accepts ids the report flagged as matches (#267 评审 3)", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const bystander = service.saveWithDedupe({ type: "project", title: "报告没提过的项目行", content: "无关" }).memory;
+  const report = await organize({ mode: "dryRun", candidates: [preference("只有偏好类")] });
+  const outcome = await organize({
+    mode: "apply",
+    run_id: report.run_id,
+    decisions: [{ action: "archive", id: bystander.id }]
+  });
+  assert.equal(outcome.archived, 0);
+  assert.match(outcome.skipped[0].error, /not flagged as a match/);
+  assert.equal(store.getById(bystander.id).archived, false, "报告没提过的行不许被动");
+  assert.equal(outcome.status, "degraded");
+});
+
+test("#231: merged candidates count as merged, not as new saves (#267 评审 2)", async () => {
+  const { store, service, organize } = makeOrganizer();
+  service.saveWithDedupe(preference("已被记下的偏好", "旧内容"));
+  const report = await organize({ mode: "dryRun", candidates: [preference("已被记下的偏好", "新内容")] });
+  assert.equal(report.items[0].verdict, "exact");
+  const outcome = await organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] });
+  assert.equal(outcome.saved, 0, "同键命中走合并，不是新建");
+  assert.equal(outcome.merged, 1);
+  assert.equal(outcome.status, "ok", "合并也是落地生效，不能记成 noop");
+  assert.equal(store.list({ limit: null }).length, 1);
+  assert.equal(store.getDreamRun(outcome.run_id).applied, 1);
+});
+
+test("#231: a failing audit write does not replace the original error (#267 评审 4)", async () => {
+  const { store, organize } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [preference("会失败的落地")] });
+  // 审计整体不可用：事务内的「已落地」标记先抛 → 回滚 → 失败回执也写不进去。
+  store.saveDreamRun = () => {
+    throw new Error("audit unavailable");
+  };
+  await assert.rejects(
+    () => organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }),
+    (err) => {
+      assert.match(err.message, /audit unavailable/, "原始错误原样抛出");
+      assert.match(err.audit_error, /audit unavailable/, "审计的失败挂上去，不被静默吞掉");
+      return true;
+    }
+  );
+});
+
+test("#231: apply tolerates bad decisions — legal subset lands, run is degraded", async () => {
+  const { store, organize } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [preference("能落的")] });
+  const outcome = await organize({
+    mode: "apply",
+    run_id: report.run_id,
+    decisions: [
+      { action: "save", index: 0 },
+      { action: "save", index: 9 },           // 越界
+      { action: "archive", id: "m_missing" }, // 未知 id
+      { action: "explode", index: 0 }         // 未知动作
+    ]
+  });
+  assert.equal(outcome.saved, 1, "legal subset applied");
+  assert.equal(outcome.skipped.length, 3);
+  assert.equal(outcome.status, "degraded");
+  assert.equal(outcome.degraded, true);
+  assert.equal(store.getDreamRun(outcome.run_id).skipped.length, 3, "逐条跳过明细进审计");
+});
+
+test("#231: dryRun refuses document candidates (registerDocument is the only mint)", async () => {
+  const { organize } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [{ type: "document", title: "长文", content: "摘要" }] });
+  assert.equal(report.counts.total, 0);
+  assert.equal(report.status, "degraded");
+  assert.match(report.skipped[0].error, /registerDocument/);
+});
+
+test("#231: dryRun bounds the batch and reports the truncation", async () => {
+  const { organize } = makeOrganizer();
+  const report = await organize({
+    mode: "dryRun",
+    candidates: Array.from({ length: 55 }, (_, i) => preference(`偏好${i}`))
+  });
+  assert.equal(report.counts.total, 50);
+  assert.equal(report.counts.truncated, 5);
+});
+
+test("#231: single entry point with a mode parameter, exported through the service barrel", async () => {
+  const { service, organize } = makeOrganizer();
+  await assert.rejects(() => organize({ mode: "wat" }), /unknown mode/);
+  assert.equal(typeof service.organize, "function", "service 层 barrel 出口（调用方零改动）");
+  const report = await service.organize({ mode: "dryRun", candidates: [preference("走 service 的")] });
+  assert.equal(report.counts.total, 1);
+});
+
+// --- 以下为 CodeRabbit #267 复核后补的边界：报告的索引/scope 必须与落库严格一致 ---
+
+test("#231: payload-level scope travels with the snapshot into the write", async () => {
+  const { store, organize } = makeOrganizer();
+  const report = await organize({
+    mode: "dryRun",
+    agent_scope: "agent-a",
+    candidates: [preference("带 scope 的偏好")]
+  });
+  const run = store.getDreamRun(report.run_id);
+  assert.equal(run.input[0].agent_scope, "agent-a", "审计存的是带 scope 的规范化快照");
+  assert.equal(run.input[0].index, 0, "快照保留原始索引，apply 才能按索引重放");
+  assert.equal(run.input[0].type, "preference");
+  await organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] });
+  assert.equal(store.list({ limit: null })[0].agent_scope, "agent-a", "比对用的 scope 就是落地用的 scope");
+});
+
+test("#231: apply cannot land an index the dryRun never accepted", async () => {
+  const { store, organize } = makeOrganizer();
+  const report = await organize({
+    mode: "dryRun",
+    candidates: [preference("合法的"), { type: "document", title: "长文", content: "摘要" }]
+  });
+  assert.equal(report.counts.skipped, 1);
+  const outcome = await organize({
+    mode: "apply",
+    run_id: report.run_id,
+    decisions: [{ action: "save", index: 1 }] // dryRun 当时就拒了这一条
+  });
+  assert.equal(outcome.saved, 0);
+  assert.equal(outcome.status, "degraded");
+  assert.match(outcome.skipped[0].error, /not accepted by this dryRun/);
+  assert.equal(store.list({ limit: null }).length, 0, "被跳过的候选没有资格落库");
+});
+
+test("#231: apply refuses an apply receipt as its dryRun reference", async () => {
+  const { organize } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [preference("第一条")] });
+  const first = await organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] });
+  // 两者共用 run_type='organize'，只有 outcome.dry_run_id 能把回执与报告分开。
+  await assert.rejects(
+    () => organize({ mode: "apply", run_id: first.run_id, decisions: [{ action: "save", index: 0 }] }),
+    /apply receipt/
+  );
+});
+
+test("#231: a throwing embedder fails the dryRun, audits it and rethrows", async () => {
+  const { store, service } = makeOrganizer(async () => {
+    throw new Error("embedder offline");
+  });
+  const seeded = service.saveWithDedupe({ type: "preference", title: "已有向量", content: "内容" }).memory;
+  store.setEmbedding(seeded.id, [1, 0, 0]);
+  const seen = [];
+  const observed = createOrganizer({
+    store: { ...store, saveDreamRun: (row) => { seen.push(row); return store.saveDreamRun(row); } },
+    embedQuery: async () => {
+      throw new Error("embedder offline");
+    },
+    saveWithDedupe: service.saveWithDedupe,
+    transaction: service.transaction
+  });
+  await assert.rejects(() => observed.organize({ mode: "dryRun", candidates: [preference("新的一条")] }), /embedder offline/);
+  assert.equal(seen.at(-1).status, "failed", "基础设施错误留 failed 回执，不降级成「全是新条目」");
+  assert.match(seen.at(-1).error, /embedder offline/);
+  assert.equal(store.list({ limit: null }).length, 1, "失败路径零写入");
+});
+
+test("#231: an infrastructure write error rolls back and reports applied 0", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [preference("会写失败的")] });
+  const seen = [];
+  const failing = createOrganizer({
+    store: { ...store, saveDreamRun: (row) => { seen.push(row); return store.saveDreamRun(row); } },
+    embedQuery: async () => null,
+    saveWithDedupe: () => {
+      throw new Error("database is locked");
+    },
+    transaction: service.transaction
+  });
+  await assert.rejects(
+    () => failing.organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }),
+    /database is locked/
+  );
+  assert.equal(store.list({ limit: null }).length, 0, "整批回滚，零写入");
+  const failed = seen.at(-1);
+  assert.equal(failed.status, "failed");
+  assert.equal(failed.applied, 0, "回滚后不得虚报 applied");
+  assert.deepEqual(failed.outcome.byId, {});
+});
+
+test("#231: a failing success audit rolls the writes back with it", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [preference("回执写不进去")] });
+  let auditFailures = 0;
+  const audited = {
+    ...store,
+    saveDreamRun: (row) => {
+      if (row.run_type === "organize" && row.status === "ok" && row.id !== report.run_id) {
+        auditFailures++;
+        throw new Error("audit table is full");
+      }
+      return store.saveDreamRun(row);
+    }
+  };
+  const { organize: proxied } = createOrganizer({
+    store: audited,
+    embedQuery: async () => null,
+    saveWithDedupe: service.saveWithDedupe,
+    transaction: service.transaction
+  });
+  await assert.rejects(
+    () => proxied({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }),
+    /audit table is full/
+  );
+  assert.equal(auditFailures, 1);
+  assert.equal(store.list({ limit: null }).length, 0, "成功回执与数据同事务：回执写不进去 → 数据也回滚");
+});
+
+test("#231: finalize runs after commit with the saved rows, and not for empty batches", async () => {
+  const { store, organize, finalizeCalls } = makeOrganizer();
+  const report = await organize({ mode: "dryRun", candidates: [preference("要重嵌入的")] });
+  await organize({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] });
+  assert.equal(finalizeCalls.length, 1, "提交后补一次重嵌入（transaction 里被 txDepth 挡掉）");
+  assert.equal(finalizeCalls[0][0].id, store.list({ limit: null })[0].id);
+  const discardsOnly = await organize({ mode: "dryRun", candidates: [preference("只丢弃")] });
+  await organize({ mode: "apply", run_id: discardsOnly.run_id, decisions: [{ action: "discard", index: 0 }] });
+  assert.equal(finalizeCalls.length, 1, "noop 批次不触发 finalize");
+});
+
+test("#231: archive honours the hidden-id set from the trusted caller, not the payload", async () => {
+  const { store, service, organize } = makeOrganizer();
+  const outOfScope = service.saveWithDedupe({ type: "project", title: "看不见的项目", content: "内容" }).memory;
+  const report = await organize({ mode: "dryRun", candidates: [preference("占位")] });
+  // opts 是第二参数（document 的 hiddenEvidenceIds 同款契约）：payload 里的同名字段
+  // 一律不认——那是调用方可自选的内容，不是授权。
+  const outcome = await service.organize(
+    { mode: "apply", run_id: report.run_id, decisions: [{ action: "archive", id: outOfScope.id }] },
+    { hiddenIds: [outOfScope.id] }
+  );
+  assert.equal(outcome.archived, 0);
+  assert.match(outcome.skipped[0].error, /out of scope/);
+  assert.equal(store.getById(outOfScope.id).archived, false, "看不见的行按不存在处理，不归档");
+});

package/test/recall-stats.test.js

@@ -71,7 +71,13 @@ test("僵尸率：零曝光活跃计入，归档/遗忘剔除，豁免期单独
   assert.equal(withExempt.zombie.activeCount, 0);
   assert.equal(withExempt.zombie.rate, null);
 
-  // 豁免归零：归档/遗忘剔除，零曝光的 z 计僵尸
+  // 豁免归零：归档/遗忘剔除，零曝光的 z 计僵尸。回拨 created_at 避开
+  // nowIso 同毫秒单调顶推的 1ms 豁免边界——刚写入的记忆可能比 recallStats
+  // 的 Date.now() 晚 1ms，exemptDays:0 时落进豁免桶，断言随调度抖动翻转。
+  const old = new Date(Date.now() - 10 * 86400000).toISOString();
+  for (const m of store.all()) {
+    store.db.prepare("UPDATE memories SET created_at = ? WHERE id = ?").run(old, m.id);
+  }
   const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
   assert.equal(stats.zombie.activeCount, 2, "归档与遗忘不进分母");
   assert.equal(stats.zombie.zombieCount, 1);

package/test/runtime-loader.test.js

@@ -214,6 +214,24 @@ test("describeLocalRuntime：可用时报出 payload 与来源，且不假装验
   assert.match(report.hint, /mneme-runtime\.mjs/);
 });
 
+test("describeLocalRuntime：下载档的完整性结论投影成字符串，不把对象漏进免鉴权端点（issue #268）", () => {
+  const runtimeDir = emptyRuntime();
+  const dir = makePayload(runtimeDir);
+  writeFileSync(
+    join(dir, "mneme-runtime.json"),
+    JSON.stringify({
+      procedure: "downloaded",
+      integrity: { status: "verified", checked: 3, detail: "每个 tarball 的 sha512 与 runtime-manifest.json 一致" }
+    })
+  );
+  const report = describeLocalRuntime({ runtimeDir, platform: "win32", arch: "x64" });
+  assert.equal(report.status, "available");
+  // DTO 声明是 string|null（见 publicRuntimeStatus 的注释），对象溜出去就是形状违约。
+  assert.equal(typeof report.integrity, "string");
+  assert.equal(report.integrity, "verified");
+  assert.equal(publicRuntimeStatus(report).integrity, "verified");
+});
+
 test("describeLocalRuntime：没有 payload 时报 missing，而不是报坏掉", () => {
   const report = describeLocalRuntime({ runtimeDir: emptyRuntime(), platform: "win32", arch: "x64" });
   assert.equal(report.status, "missing");

package/test/runtime-manifest.test.js

@@ -124,9 +124,10 @@ test("build：平台无关，六个常见平台都能过滤出完整的必需包
       assert.ok((pkg.os ?? []).includes(platform), `${platform}-${arch} 混进了 ${pkg.rel}`);
     }
     // payloadId 由「版本 + 平台」算出来（v2 清单里不再存它）。
+    // 版本取自生成器输出本身：本断言锁的是格式，不是某个具体版本号。
     assert.equal(
       payloadId({ version: built.transformersVersion, platform, arch }),
-      `transformers-4.2.0-node-${platform}-${arch}`
+      `transformers-${built.transformersVersion}-node-${platform}-${arch}`
     );
   }
 });

package/test/runtime-verify.test.js

@@ -146,6 +146,71 @@ test("三件套：--strict 场景下哈希不匹配即整体不通过", async ()
   assert.equal(mismatch.functional.ok, true);
 });
 
+test("三件套：清单里记下的来源完整性被认账，不因状态词不同就判失败（issue #268）", async () => {
+  const dir = makePayload();
+  // download.js 在落盘前逐个 tarball 比对过 sha512，把这个结论写进清单的形状与词就是下面这样。
+  writeFileSync(
+    join(dir, "mneme-runtime.json"),
+    JSON.stringify({
+      procedure: "downloaded",
+      version: "4.2.0",
+      integrity: { status: "verified", checked: 3, detail: "每个 tarball 的 sha512 与 runtime-manifest.json 一致" }
+    })
+  );
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8))
+  });
+  assert.equal(result.integrity.status, "verified");
+  assert.equal(result.integrity.ok, true, "下载档记下的 verified 是可用结论，不是失败");
+  assert.match(result.integrity.detail, /每个 tarball/);
+  assert.equal(result.ok, true);
+});
+
+test("三件套：清单里记下的不一致照样判失败（别把「读到一份结论」变成「一律放过」）", async () => {
+  const dir = makePayload();
+  writeFileSync(
+    join(dir, "mneme-runtime.json"),
+    JSON.stringify({ procedure: "downloaded", integrity: { status: "sha512-mismatch", detail: "与钉死的哈希不一致" } })
+  );
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8))
+  });
+  assert.equal(result.integrity.ok, false);
+  assert.equal(result.integrity.status, "sha512-mismatch");
+  assert.equal(result.ok, false);
+});
+
+test("三件套：清单里的 integrity 形状非法时 fail-closed，不读成「没验过」（#269 评审）", async () => {
+  const dir = makePayload();
+  writeFileSync(join(dir, "mneme-runtime.json"), JSON.stringify({ procedure: "downloaded", integrity: false }));
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8))
+  });
+  assert.equal(result.integrity.status, "malformed");
+  assert.equal(result.integrity.ok, false, "形状错误不是「验过了」，也不能当成「没记录」放过");
+  assert.equal(result.ok, false);
+  assert.match(result.integrity.detail, /形状非法/);
+});
+
+test("三件套：显式报 unverified 与「没传」同判，不因为说出口就变失败", async () => {
+  const dir = makePayload();
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8)),
+    integrity: { status: "unverified" }
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.integrity.status, "unverified");
+  assert.match(result.integrity.detail, /没有可比对的原始产物/);
+});
+
 test("假通过防线 ①：行不是数组时返回失败，而不是抛异常", async () => {
   // 契约是「任何失败都返回结果对象，不抛」；非数组行会让 .length/.some 直接抛。
   const dir = makePayload();