@modusensus/dsh-mneme 0.12.0 → 0.13.0

package/test/reindex-scheduler.test.js

@@ -0,0 +1,369 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { scheduleBootBackfill } from "../src/semantic.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// #604：boot 回填的续排此前完全没有用例覆盖 —— createSemantic 只被 index.js /
+// serve.js 引用，闭包里的调度逻辑既测不到也看不见，于是「一次启动只跑一轮、撞
+// cap 就停」活了很久：日志里写着 capped，没有任何出口能说明「它不会再自己跑」。
+// 这里直接驱动调度器，用压缩后的等待时间，断言排了几轮、为什么停。
+
+function setup({ count = 6, batchSize = 2, maxPerBoot = 2 } = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  for (let i = 0; i < count; i++) {
+    service.saveWithDedupe({ type: "preference", title: `记忆${i}`, content: `内容${i}` });
+  }
+  const vectorIndex = createVectorIndex({ store });
+  const cfg = {
+    autoReindexOnBoot: true,
+    reindexMaxPerBoot: maxPerBoot,
+    reindexBatchSize: batchSize,
+    reindexRateLimitMs: 0
+  };
+  return { store, vectorIndex, cfg };
+}
+
+// 调度器用 setTimeout 串联，delay 压到 0 之后仍然要等事件循环转几圈。
+// 轮询到状态稳定（连续两次读到同一个终态）或超时为止。
+async function settle(statusOf, { timeoutMs = 3000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  let stable = 0;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 10));
+    const now = JSON.stringify(statusOf() ?? null);
+    if (now === last) {
+      stable++;
+      if (stable >= 3) return JSON.parse(now);
+    } else {
+      stable = 0;
+      last = now;
+    }
+  }
+  throw new Error(`scheduler did not settle within ${timeoutMs}ms (last=${last})`);
+}
+
+// settle() 只要求「连续三次读到同一个状态」，对几百行的长跑会提前返回 running。
+// 需要终态的场景用这个：等到 state 变成 finished / error 再返回。
+async function waitForFinished(statusOf, { timeoutMs = 10000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const now = statusOf();
+    if (now && (now.state === "finished" || now.state === "error")) return now;
+    await new Promise((r) => setTimeout(r, 10));
+  }
+  throw new Error(`scheduler never reached a terminal state within ${timeoutMs}ms`);
+}
+
+// 续排场景下「第一个终态」不是答案：第一轮 errored 之后还会再排一轮。
+// 需要等到某个具体的 finishReason 出现才算数。
+async function waitForReason(statusOf, reason, { timeoutMs = 10000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  while (Date.now() < deadline) {
+    const now = statusOf();
+    if (now) last = now;
+    if (now && now.state === "finished" && now.finishReason === reason) return now;
+    await new Promise((r) => setTimeout(r, 10));
+  }
+  throw new Error(
+    `scheduler never reported "${reason}" within ${timeoutMs}ms (last=${JSON.stringify(last)})`
+  );
+}
+
+test("#604: a capped run continues inside the same boot until the backlog drains", async () => {
+  // 6 行、每轮最多 2 行 → 需要 3 轮。旧实现只跑第一轮就永久停手。
+  const { store, vectorIndex, cfg } = setup({ count: 6, batchSize: 2, maxPerBoot: 2 });
+  const embedder = { embedSingle: async () => [1, 0, 0], modelHash: "m#1", dimension: 3 };
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, logger: { info() {}, warn() {} }, cfg,
+    getEmbedder: () => embedder,
+    timing: { initialDelayMs: 0, continueDelayMs: 0 }
+  });
+
+  const status = await settle(() => scheduler.status());
+  scheduler.dispose();
+
+  assert.equal(store.needsEmbeddingFor("m#1").length, 0, "the whole backlog is cleared in one boot");
+  assert.equal(status.state, "finished");
+  assert.equal(status.finishReason, "drained", "the last run reports why it stopped");
+  assert.equal(status.continuation, 2, "two continuations after the first run (3 runs total)");
+  store.close();
+});
+
+test("#604: continuations stop at the cap instead of looping forever", async () => {
+  // 12 行、每轮 2 行、上限 2 次续排 → 只跑 3 轮（6 行），剩下的留到下次启动。
+  const { store, vectorIndex, cfg } = setup({ count: 12, batchSize: 2, maxPerBoot: 2 });
+  const embedder = { embedSingle: async () => [1, 0, 0], modelHash: "m#1", dimension: 3 };
+  const warnings = [];
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn: (m) => warnings.push(m) },
+    getEmbedder: () => embedder,
+    timing: { initialDelayMs: 0, continueDelayMs: 0, maxContinuations: 2 }
+  });
+
+  const status = await settle(() => scheduler.status());
+  scheduler.dispose();
+
+  assert.equal(status.finishReason, "capped");
+  assert.equal(status.continuation, 2, "the cap counts continuations, not runs");
+  assert.equal(store.needsEmbeddingFor("m#1").length, 6, "exactly the remainder is left queued");
+  assert.ok(
+    warnings.some((m) => m.includes("continuation limit")),
+    "hitting the cap is logged, not silent"
+  );
+  store.close();
+});
+
+test("#604: a stalled run does not reschedule — the next boot is the retry point", async () => {
+  // 全行永久失败 → finishReason stalled。立刻再排只会把同几行再烧一遍，
+  // 所以正确行为是停手，把重试留给下一次启动（与 #128 的契约一致）。
+  // 用 null 向量（empty-vector，对该行是永久性）而不是抛错：抛错属于
+  // `error:` 桶，是瞬时故障，走 errored 那条更短的续排路径，见下面两个用例。
+  const { store, vectorIndex, cfg } = setup({ count: 4, batchSize: 10, maxPerBoot: 100 });
+  let calls = 0;
+  const embedder = {
+    embedSingle: async () => { calls++; return null; },
+    modelHash: "m#1",
+    dimension: 3
+  };
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => embedder,
+    timing: { initialDelayMs: 0, continueDelayMs: 0 }
+  });
+
+  const status = await settle(() => scheduler.status());
+  scheduler.dispose();
+
+  assert.equal(status.finishReason, "stalled");
+  assert.equal(status.continuation, 0, "no continuation was scheduled");
+  assert.equal(calls, 4, "each row was attempted once, total");
+  assert.equal(store.needsEmbeddingFor("m#1").length, 4, "rows stay queued for the next boot");
+  store.close();
+});
+
+test("#604: dispose cancels a pending continuation (no query against a closed store)", async () => {
+  // 这是 #365 CodeRabbit 记过的同一类事故：计时器没入册，卸载后还在跑。
+  // 断言方式是关库之后不再有任何新调用 —— 若续排漏出去，会在这里炸。
+  const { store, vectorIndex, cfg } = setup({ count: 8, batchSize: 2, maxPerBoot: 2 });
+  let calls = 0;
+  const embedder = {
+    embedSingle: async () => { calls++; return [1, 0, 0]; },
+    modelHash: "m#1",
+    dimension: 3
+  };
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => embedder,
+    timing: { initialDelayMs: 0, continueDelayMs: 60 }
+  });
+
+  // 等第一轮跑完（status 有值），此时续排已经排上但还没触发。
+  const deadline = Date.now() + 2000;
+  while (scheduler.status() === null && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 5));
+  }
+  const callsAtDispose = calls;
+  scheduler.dispose();
+  store.close();
+
+  await new Promise((r) => setTimeout(r, 200));
+  assert.equal(calls, callsAtDispose, "no embed attempt happened after dispose");
+});
+
+test("#604: autoReindexOnBoot: false schedules nothing at all", async () => {
+  const { store, vectorIndex, cfg } = setup();
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg: { ...cfg, autoReindexOnBoot: false },
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => ({ embedSingle: async () => [1, 0, 0], modelHash: "m#1", dimension: 3 }),
+    timing: { initialDelayMs: 0, continueDelayMs: 0 }
+  });
+
+  await new Promise((r) => setTimeout(r, 60));
+  assert.equal(scheduler.status(), null, "the switch is respected");
+  assert.equal(store.needsEmbeddingFor("m#1").length, 6, "nothing was embedded");
+  scheduler.dispose();
+  store.close();
+});
+
+test("#604: an embedder that is not ready yet is retried before the run", async () => {
+  const { store, vectorIndex, cfg } = setup({ count: 2, batchSize: 2, maxPerBoot: 10 });
+  let readyChecks = 0;
+  const embedder = {
+    get ready() { readyChecks++; return readyChecks > 2; },
+    embedSingle: async () => [1, 0, 0],
+    modelHash: "m#1",
+    dimension: 3
+  };
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => embedder,
+    timing: { initialDelayMs: 0, continueDelayMs: 0, readyRetryDelayMs: 0 }
+  });
+
+  const status = await settle(() => scheduler.status());
+  scheduler.dispose();
+
+  assert.ok(readyChecks >= 3, "waited for ready instead of giving up on the first check");
+  assert.equal(status.finishReason, "drained");
+  assert.equal(store.needsEmbeddingFor("m#1").length, 0);
+  store.close();
+});
+
+test("#604: a dead prefix deeper than the pick window stops the scheduler instead of spinning", async () => {
+  // 回归 Ephor 实测的那条悬崖：死前缀 >= maxWindow(500) 时，每轮窗口都被死行
+  // 占满、被 attempted 截断，rows 永远非空、indexed 恒 0，于是 finishReason 落到
+  // capped、调度器继续续排。默认配置连跑 21 轮：每轮 indexed=0 / failed=500，
+  // 累计 provider 调用 10500 次，好行 0/10 嵌入。
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  for (let i = 0; i < 10; i++) {
+    service.saveWithDedupe({ type: "preference", title: `好行${i}`, content: `good-${i}` });
+  }
+  for (let i = 0; i < 500; i++) {
+    service.saveWithDedupe({ type: "preference", title: `坏行${i}`, content: `bad-${i}` });
+  }
+  const vectorIndex = createVectorIndex({ store });
+  const cfg = {
+    autoReindexOnBoot: true,
+    reindexMaxPerBoot: 500,
+    reindexBatchSize: 10,
+    reindexRateLimitMs: 0
+  };
+  let calls = 0;
+  const embedder = {
+    embedSingle: async (text) => {
+      calls++;
+      return String(text).includes("bad-") ? null : [1, 0, 0];
+    },
+    modelHash: "m#1",
+    dimension: 3
+  };
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => embedder,
+    timing: { initialDelayMs: 0, continueDelayMs: 0 }
+  });
+
+  const status = await waitForFinished(() => scheduler.status());
+  scheduler.dispose();
+  assert.equal(status.finishReason, "stalled", "no progress is reported honestly");
+  assert.equal(status.continuation, 0, "no continuation: the next boot is the retry point");
+  assert.equal(calls, 500, "one run, one attempt per row — not 21 rounds of the same 500");
+  assert.equal(store.needsEmbeddingFor("m#1", 5000).length, 510, "everything stays queued");
+  store.close();
+});
+
+test("#604: a synchronous throw before the promise still publishes an error status", async () => {
+  // 旧实现的同步 catch 只写了日志、没写 lastBackfill，于是面板读到 null，
+  // 显示的是「从来没跑过」而不是「跑了但失败」—— 两种状态的含义完全不同。
+  const { store, vectorIndex, cfg } = setup({ count: 2 });
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => { throw new Error("embedder blew up"); },
+    timing: { initialDelayMs: 0, continueDelayMs: 0, maxContinuations: 0 }
+  });
+
+  const status = await settle(() => scheduler.status());
+  scheduler.dispose();
+
+  assert.equal(status.state, "error", "the failure is visible instead of reading as never-ran");
+  assert.match(status.error, /embedder blew up/);
+  store.close();
+});
+
+test("#604: a transient provider outage retries inside the boot instead of waiting for the next start", async () => {
+  // 一轮 batch 10 刚好全撞上 503：indexed === 0，但这是运气不好，不是死行。
+  // 判成 stalled 会把重试推到下次启动（可能几小时后），而 provider 一秒后就好了。
+  // 判据在 failureReasons 里：抛错落在 `error:` 桶（瞬时），null 向量落在
+  // `empty-vector`（对该行是永久性）。
+  const { store, vectorIndex, cfg } = setup({ count: 10, batchSize: 10, maxPerBoot: 500 });
+  let calls = 0;
+  const embedder = {
+    embedSingle: async () => {
+      calls++;
+      // 第一轮的 10 次全挂，之后恢复。
+      if (calls <= 10) throw new Error("503 Service Unavailable");
+      return [1, 0, 0];
+    },
+    modelHash: "m#1",
+    dimension: 3
+  };
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => embedder,
+    timing: { initialDelayMs: 0, continueDelayMs: 0 }
+  });
+
+  const status = await waitForReason(() => scheduler.status(), "drained");
+  scheduler.dispose();
+
+  assert.equal(status.finishReason, "drained", "the retry rode out the outage and finished");
+  assert.ok(status.continuation >= 1, "a retry actually happened inside this boot");
+  assert.equal(store.needsEmbeddingFor("m#1", 100).length, 0, "every row ended up embedded");
+  store.close();
+});
+
+test("#604: a provider that stays down stops after the small error budget", async () => {
+  // 反面：provider 一直挂。errored 值得重试，但不能用 capped 的 20 轮预算陪跑，
+  // 否则「瞬时」这个借口就变成了另一个活锁。
+  // 断言必须看「排了几轮」，不能只看「调用次数有没有超」——后者在调用一多就
+  // dispose，分辨不出 4 轮和 20 轮（变异自证时确实漏过这条）。
+  const { store, vectorIndex, cfg } = setup({ count: 10, batchSize: 10, maxPerBoot: 500 });
+  let calls = 0;
+  let runs = 0;
+  const embedder = {
+    embedSingle: async () => {
+      calls++;
+      throw new Error("503 Service Unavailable");
+    },
+    modelHash: "m#1",
+    dimension: 3
+  };
+
+  const scheduler = scheduleBootBackfill({
+    store, vectorIndex, cfg,
+    logger: { info() {}, warn() {} },
+    getEmbedder: () => embedder,
+    onStatus: (s) => { if (s.state === "running") runs++; },
+    timing: { initialDelayMs: 0, continueDelayMs: 0, maxErrorContinuations: 3 }
+  });
+
+  // 等到调用数不再增长（调度器真的停手），而不是等到某个固定上限。
+  const deadline = Date.now() + 10000;
+  let lastCalls = -1;
+  let quietSince = Date.now();
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 20));
+    if (calls !== lastCalls) { lastCalls = calls; quietSince = Date.now(); }
+    else if (Date.now() - quietSince > 300) break;
+  }
+  const status = scheduler.status();
+  scheduler.dispose();
+
+  assert.equal(status.finishReason, "errored", "an unreachable provider is not a dead row");
+  // 1 次初始 + 3 次重试 = 4 轮。若走 maxContinuations(20) 这里会是 21。
+  assert.equal(runs, 4, `the error budget is 3 retries, not the 20-round cap (runs=${runs})`);
+  assert.equal(calls, 40, `4 rounds × 10 rows (calls=${calls})`);
+  assert.equal(store.needsEmbeddingFor("m#1", 100).length, 10, "everything stays queued");
+  store.close();
+});

package/test/scope-candidates.test.js

@@ -199,6 +199,255 @@ test("dream (non-freeze): same-scope conflict is still auto-adjudicated (regress
   store.close();
 });
 
+// Issue #603 第 1 层：freeze 分支此前绕过全部三个上限，且把「已在队列里的对」
+// 当成新停车报进 frozen。下面三条锁住修完之后的三个性质。
+test("#603 freeze: a pair already in the queue is not re-reported as a new freeze", async () => {
+  const { store, service, vectorIndex } = setup();
+  savePair(service, vectorIndex, "索引策略A", "索引策略B", { agent: "coder" }, { agent: "coder" });
+  const logger = { warn: () => {}, info: () => {} };
+
+  const first = await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), logger, { embedder, vectorIndex }, null);
+  assert.equal(first.phases.conflicts.frozen, 1, "第一次是真插入");
+  assert.equal(store.countConflictPending(), 1);
+
+  const second = await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), logger, { embedder, vectorIndex }, null);
+  assert.equal(second.phases.conflicts.frozen, 0, "第二次检出的是已入队的对，不算新停车");
+  assert.equal(second.status, "noop", "没有新停车就是 noop，不是 ok");
+  assert.equal(store.countConflictPending(), 1, "队列没有被重复写入");
+  store.close();
+});
+
+test("#603 freeze: cap is applied after filtering already-parked pairs, so the queue keeps growing", async () => {
+  const { store, service, vectorIndex } = setup();
+  // 三对互不相交的高相似记忆：贪心配对每轮都能检出三对。
+  savePair(service, vectorIndex, "队列A1", "队列A2", { agent: "coder" }, { agent: "coder" });
+  savePair(service, vectorIndex, "队列B1", "队列B2", { agent: "coder" }, { agent: "coder" });
+  savePair(service, vectorIndex, "队列C1", "队列C2", { agent: "coder" }, { agent: "coder" });
+  const logger = { warn: () => {}, info: () => {} };
+  // 每轮只处理一对，且远小于候选数——裸 slice 会让第一对永远占住这个名额。
+  const cfg = baseConfig({ conflictFreezeEnabled: true, sleepConflictMaxPairsPerRun: 1 });
+
+  await runSleep(llmCtx(), service, cfg, logger, { embedder, vectorIndex }, null);
+  assert.equal(store.countConflictPending(), 1);
+  await runSleep(llmCtx(), service, cfg, logger, { embedder, vectorIndex }, null);
+  assert.equal(store.countConflictPending(), 2, "第二对必须能轮到，不能被第一对饿死");
+  await runSleep(llmCtx(), service, cfg, logger, { embedder, vectorIndex }, null);
+  assert.equal(store.countConflictPending(), 3, "第三对同理");
+
+  const done = await runSleep(llmCtx(), service, cfg, logger, { embedder, vectorIndex }, null);
+  assert.equal(done.phases.conflicts.frozen, 0, "全部入队后不再虚报");
+  assert.equal(done.phases.conflicts.perRunSkipped, 0, "没有新对可处理，不算被截断");
+  store.close();
+});
+
+test("#603 freeze: the pending queue budget stops parking and says so", async () => {
+  const { store, service, vectorIndex } = setup();
+  savePair(service, vectorIndex, "预算A1", "预算A2", { agent: "coder" }, { agent: "coder" });
+  savePair(service, vectorIndex, "预算B1", "预算B2", { agent: "coder" }, { agent: "coder" });
+  savePair(service, vectorIndex, "预算C1", "预算C2", { agent: "coder" }, { agent: "coder" });
+  const warnings = [];
+  const logger = { warn: (m) => warnings.push(String(m)), info: () => {} };
+
+  const result = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictFreezeMaxPending: 2 }),
+    logger, { embedder, vectorIndex }, null
+  );
+  assert.equal(store.countConflictPending(), 2, "只装到队列上限为止");
+  assert.equal(result.phases.conflicts.frozen, 2);
+  assert.equal(result.phases.conflicts.pendingSkipped, 1, "被队列上限挡下的对要如实报出来");
+  assert.ok(warnings.some((w) => /freeze queue full/.test(w)), "要留一条 warn，不能静默丢弃");
+
+  // 队列已满：再跑一轮不会新增，也不会把「满了」报成可续排的 backlog。
+  const again = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictFreezeMaxPending: 2 }),
+    logger, { embedder, vectorIndex }, null
+  );
+  assert.equal(store.countConflictPending(), 2);
+  assert.equal(again.phases.conflicts.frozen, 0);
+  assert.equal(again.phases.conflicts.perRunSkipped, 0, "队列满不是 per-run 截断，不该触发续排");
+  store.close();
+});
+
+// Issue #603 第 2 层：sleep 停车时必须把候选对的相似度一起落库。此前这个数字只
+// 活在 reason 文本里（「相似度 0.87」），面板靠正则回收、排序无从下手——同一轮
+// 产出的对 created_at 全同，队列顺序等于随机。
+test("#603 freeze: the parked row carries the similarity the detector measured", async () => {
+  const { store, service, vectorIndex } = setup();
+  savePair(service, vectorIndex, "排序A1", "排序A2", { agent: "coder" }, { agent: "coder" });
+
+  await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+
+  const [row] = store.listConflictPending();
+  assert.ok(row, "the pair must be parked");
+  // 两条记忆的向量都是 [1,0,0]，余弦为 1。断言「是数字且等于 1」而不是「非空」：
+  // 前者能抓住「传了 undefined / 传了字符串」这类静默降级。
+  assert.equal(typeof row.similarity, "number", "similarity must be a number, not a string or undefined");
+  assert.equal(row.similarity, 1, "identical vectors are similarity 1");
+  store.close();
+});
+
+// 与上一条互补：拿不到相似度时必须是「未知」而不是 0。0 会被排到最后，等于替
+// 用户断言「这两条毫不相似」——那是编造。
+test("#603 freeze: a pair parked without a measured similarity stays unknown", async () => {
+  const { store, service } = setup();
+  // 直接走 service 的停车口（没有向量索引参与 = 没测过相似度）。
+  const a = service.saveWithDedupe({ type: "project", title: "未知A", content: "正文A" }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "未知B", content: "正文B" }).memory;
+  service.saveConflictPending({ run_id: "r1", memory_a: a.id, memory_b: b.id, reason: "人工停车" });
+
+  const [row] = store.listConflictPending();
+  assert.equal(row.similarity, undefined, "no measurement must read back as unknown, not 0");
+  store.close();
+});
+
+// Issue #603 第 4 层：自动裁决档。相似度极高的**同 scope** 对直接保留新条、归档
+// 旧条，不进人工队列；跨 scope 对永不自动（归属是用户的决定）。
+test("#603 auto-resolve: a near-duplicate same-scope pair is superseded without entering the queue", async () => {
+  const { store, service, vectorIndex } = setup();
+  const [first, second] = savePair(service, vectorIndex, "缓存策略A", "缓存策略B", { agent: "coder" }, { agent: "coder" });
+
+  const result = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictAutoResolveEnabled: true, conflictAutoResolveMinSimilarity: 0.95 }),
+    { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null
+  );
+  assert.equal(result.status, "ok");
+
+  // 队列必须是空的：这一对根本没进人工队列。
+  assert.equal(store.countConflictPending(), 0, "auto-resolved pairs must not reach the manual queue");
+  // 不猜 id 顺序，用归档状态反推哪一侧被取代。
+  const archivedIds = [first.id, second.id].filter((id) => store.getById(id).archived);
+  assert.equal(archivedIds.length, 1, "exactly one side is archived");
+  const loser = archivedIds[0];
+  const survivor = [first.id, second.id].find((id) => !store.getById(id).archived);
+  // 留下的那条正文一字不动（supersede 把注记写在败者侧，不污染幸存者）。
+  assert.doesNotMatch(store.getById(survivor).content, /已被取代|superseded by/,
+    "the survivor's body must stay clean");
+  // 败者侧带可追溯注记（#126 的原设计）。
+  assert.match(store.getById(loser).content, /已被取代|superseded by/,
+    "traceability lives on the archived side");
+  // 机器台账也要有一条：自动动作必须能事后回答「什么时候、被谁判的」。
+  const reviewed = typeof store.listConflictReviewed === "function" ? store.listConflictReviewed({ limit: 10 }) : [];
+  assert.ok(reviewed.length >= 1, "auto-resolve must leave a ledger row");
+  assert.equal(reviewed[0].outcome, "supersede");
+  store.close();
+});
+
+test("#603 auto-resolve: a cross-scope pair is never auto-adjudicated, even at similarity 1", async () => {
+  const { store, service, vectorIndex } = setup();
+  const [xNew, xOld] = savePair(service, vectorIndex, "部署清单A", "部署清单B", { agent: "coder" }, { agent: "writer" });
+
+  const result = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictAutoResolveEnabled: true, conflictAutoResolveMinSimilarity: 0.95 }),
+    { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null
+  );
+  assert.equal(result.status, "ok");
+
+  // 向量完全相同（余弦 1），但归属不同 → 只能停车等人判。
+  assert.equal(store.countConflictPending(), 1, "cross-scope pair still goes to the manual queue");
+  assert.equal(store.getById(xOld.id).archived, false, "cross-scope loser is never auto-archived");
+  assert.equal(store.getById(xNew.id).archived, false, "cross-scope winner is untouched too");
+  store.close();
+});
+
+test("#603 auto-resolve: with the switch off nothing is auto-adjudicated", async () => {
+  const { store, service, vectorIndex } = setup();
+  savePair(service, vectorIndex, "主题A", "主题B", { agent: "coder" }, { agent: "coder" });
+
+  const result = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictAutoResolveEnabled: false }),
+    { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null
+  );
+  assert.equal(result.status, "ok");
+  assert.equal(store.countConflictPending(), 1, "with the switch off, nothing is auto-adjudicated");
+  store.close();
+});
+
+// 自动裁决保留的是**信息量更大**的那条，不是更新的那条。
+// 反例来自 live 库：>=0.95 的 20 对里 11 对（55%）新条比旧条短，平均短 132 字——
+// 蒸馏压缩过的一版反而更新时间更晚，按「留新的」会把更完整的那条归档掉。
+test("#603 auto-resolve: the longer copy survives even when the shorter one is newer", async () => {
+  const { store, service, vectorIndex } = setup();
+  // 先存长的那条（更旧），再存短的那条（更新）：新条更短，正是实测里的多数情况。
+  const longBody = "缓存策略要按写入频率分三档：热数据走内存、温数据走 SSD、冷数据归档到对象存储。"
+    + "切换阈值由每小时访问次数决定，低于一次就降档，连续三天高于十次再升档。";
+  const shortBody = "缓存策略按写入频率分档。";
+  const older = service.saveWithDedupe({
+    type: "project", title: "缓存分层", content: longBody
+  }).memory;
+  const newer = service.saveWithDedupe({
+    type: "project", title: "缓存分层摘要", content: shortBody
+  }).memory;
+  vectorIndex.saveEmbedding(older.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(newer.id, [1, 0, 0]);
+  assert.ok(older.content.length > newer.content.length, "fixture: the older copy must be the longer one");
+
+  const result = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictAutoResolveEnabled: true, conflictAutoResolveMinSimilarity: 0.95 }),
+    { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null
+  );
+  assert.equal(result.status, "ok");
+  assert.equal(result.phases.conflicts.autoResolved, 1, "the pair is auto-adjudicated");
+
+  // 幸存者必须是长的那条：留新的会把三档策略削成一句话。
+  assert.equal(store.getById(older.id).archived, false, "the longer, older copy must survive");
+  assert.equal(store.getById(newer.id).archived, true, "the shorter, newer copy is the one archived");
+  store.close();
+});
+
+// 长度相同才是「信息量相当」，此时退回更新时间：新条胜出，且结论确定可重放。
+test("#603 auto-resolve: equal-length copies fall back to the newer one, deterministically", async () => {
+  const { store, service, vectorIndex } = setup();
+  const body = "部署脚本先跑 migrate 再跑 smoke，任一步失败就回滚到上一个 tag。";
+  const older = service.saveWithDedupe({ type: "project", title: "部署甲", content: body }).memory;
+  const newer = service.saveWithDedupe({ type: "project", title: "部署乙", content: body }).memory;
+  vectorIndex.saveEmbedding(older.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(newer.id, [1, 0, 0]);
+
+  const result = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictAutoResolveEnabled: true, conflictAutoResolveMinSimilarity: 0.95 }),
+    { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null
+  );
+  assert.equal(result.status, "ok");
+  assert.equal(result.phases.conflicts.autoResolved, 1);
+  // 等长 → 比 updated_at：后存的赢。长度相等时不至于两边都"更完整"，留新的是安全的。
+  assert.equal(store.getById(newer.id).archived, false, "equal length: the newer copy survives");
+  assert.equal(store.getById(older.id).archived, true);
+  store.close();
+});
+
+test("#603 auto-resolve: a failed adjudication falls back to the manual queue instead of vanishing", async () => {
+  const { store, service, vectorIndex } = setup();
+  savePair(service, vectorIndex, "回退A", "回退B", { agent: "coder" }, { agent: "coder" });
+
+  // 让 supersede 一定失败：把 applyDecisions 依赖的 update 打断。
+  const realUpdate = service.update.bind(service);
+  let calls = 0;
+  service.update = (...args) => {
+    calls++;
+    throw new Error("write refused");
+  };
+
+  const result = await runSleep(
+    llmCtx(), service,
+    baseConfig({ conflictFreezeEnabled: true, conflictAutoResolveEnabled: true, conflictAutoResolveMinSimilarity: 0.95 }),
+    { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null
+  );
+  service.update = realUpdate;
+
+  assert.ok(calls > 0, "the auto path did try to apply");
+  // 自动档没落地 → 这一对必须退回人工队列。丢掉它才是真正的静默丢失。
+  assert.equal(store.countConflictPending(), 1, "a failed auto-resolve must land in the manual queue");
+  assert.equal(result.status, "ok", "the run itself is not a failure");
+  store.close();
+});
+
 test("non-freeze with an LLM: cross-scope pair bypasses adjudication; same-scope pair is adjudicated", async () => {
   const { store, service, vectorIndex } = setup();
   const [yNew, yOld] = savePair(service, vectorIndex, "缓存策略A", "缓存策略B", { agent: "coder" }, { agent: "coder" });

package/test/sleep-action-set.test.js

@@ -373,6 +373,20 @@ test("issue#126r: buildOutcome records a disposition for the new actions", () =>
   assert.equal(outcome.byId.d2, "differentiated");
 });
 
+// #619 / Ephor 第七轮 ②：dream 那条路上，一个「只刷新不铸造」的轮此前 outcome.byId
+// 是空对象——审计行看不出任何目标被处置过。#126 review 在 supersede 上踩过同一个
+// 坑（注释就写在 buildOutcome 里），这次 create_merged 又漏了。刷新要有自己的名字，
+// 不能冒充 created：一个是「新生了这条」，一个是「把既有那条重写了」。
+test("issue#619r: buildOutcome names the create dispositions, refresh is not a birth", () => {
+  const outcome = buildOutcome([
+    { action: "create", id: "fresh-1", type: "pattern" },
+    { action: "create_merged", id: "42b75761", type: "pattern" }
+  ]);
+  assert.equal(outcome.byId["fresh-1"], "created");
+  assert.equal(outcome.byId["42b75761"], "created-refreshed", "刷新不是 created");
+  assert.deepEqual(outcome.byId, { "fresh-1": "created", "42b75761": "created-refreshed" });
+});
+
 test("issue#533r: differentiate leaves the cached vectors alone (nothing changed to re-embed)", async () => {
   const { service, store, vectorIndex } = setup();
   const { a, b } = seedPair(service, vectorIndex, "向量甲", "向量乙");