@remnic/core 9.45.3 → 9.45.5

package/src/recall-explain-renderer.ts

@@ -302,6 +302,9 @@ export function toRecallXraySnapshotFromLegacy(
     // behavior of the non-markdown surfaces.
     tierExplain: normalizeTierExplain(snapshot.tierExplain) ?? null,
     results,
+    appliedResultLimit: 0,
+    appliedResults: [],
+    headroomResults: [],
     filters,
     budget: { chars: 0, used: 0 },
     // Sanitize legacy session metadata at the adapter boundary so a

package/src/recall-rerank-coordinator.test.ts

@@ -283,6 +283,67 @@ test("zero-semantics: both flags off → stage returns inputs unchanged with zer
   assert.equal(directReads, 0, "no direct reads when disabled");
 });
 
+test("post-MMR partition exposes ordered headroom without changing admitted results", () => {
+  const config = parseConfig({
+    recallMmrEnabled: true,
+    recallMmrLambda: 0.3,
+    recallMmrTopN: 40,
+  });
+  const corpus = makeFakes([]);
+  const coordinator = new RecallRerankCoordinator({
+    getConfig: () => config,
+    getStorage: corpus.getStorage,
+    readQmdResultMemory: async () => null,
+  });
+  const candidates: QmdSearchResult[] = [
+    { docid: "a1", path: "p/a1", snippet: "alpha fact one", score: 0.99 },
+    { docid: "a2", path: "p/a2", snippet: "alpha fact two", score: 0.98 },
+    { docid: "a3", path: "p/a3", snippet: "alpha fact three", score: 0.97 },
+    { docid: "a4", path: "p/a4", snippet: "alpha fact four", score: 0.96 },
+    { docid: "a5", path: "p/a5", snippet: "alpha fact five", score: 0.95 },
+    {
+      docid: "d1",
+      path: "p/d1",
+      snippet: "orthogonal concept rocket fuel chemistry",
+      score: 0.94,
+    },
+  ];
+
+  const partition = coordinator.diversifyRecallResultsWithHeadroom(
+    "memories",
+    candidates,
+    2,
+    "alpha rocket chemistry",
+  );
+  const admitted = coordinator.diversifyAndLimitRecallResults(
+    "memories",
+    candidates,
+    2,
+    "alpha rocket chemistry",
+  );
+
+  assert.deepEqual(
+    partition.appliedResults.map((candidate) => candidate.docid),
+    ["a1", "d1"],
+    "the applied partition is the same post-MMR top slice",
+  );
+  assert.deepEqual(
+    partition.headroomResults.map((candidate) => candidate.docid),
+    ["a2", "a3", "a4", "a5"],
+    "headroom preserves the post-MMR order immediately beyond the applied cap",
+  );
+  assert.deepEqual(
+    partition.appliedResults,
+    admitted,
+    "headroom capture does not change admitted results",
+  );
+  assert.deepEqual(
+    candidates.map((candidate) => candidate.docid),
+    ["a1", "a2", "a3", "a4", "a5", "d1"],
+    "partitioning does not mutate the fetched candidate pool",
+  );
+});
+
 /**
  * Write a fact into the default-namespace storage dir (mirrors the
  * trust-score-recall-paths helper) so recall's recent-memory-scan branch has

package/src/recall-xray-renderer.test.ts

@@ -21,6 +21,9 @@ function minimalSnapshot(): RecallXraySnapshot {
     capturedAt: 1_700_000_000_000,
     tierExplain: null,
     results: [],
+    appliedResultLimit: 0,
+    appliedResults: [],
+    headroomResults: [],
     filters: [],
     budget: { chars: 4096, used: 0 },
   };
@@ -81,6 +84,9 @@ function fullSnapshot(): RecallXraySnapshot {
         rejectedBy: "mmr",
       },
     ],
+    appliedResultLimit: 0,
+    appliedResults: [],
+    headroomResults: [],
     budget: { chars: 4096, used: 1234 },
   };
 }

package/src/recall-xray.test.ts

@@ -19,6 +19,16 @@ function idGen(): () => string {
   return () => `snap-${++n}`;
 }
 
+function xrayResult(memoryId: string): RecallXrayResult {
+  return {
+    memoryId,
+    path: `/notes/${memoryId}.md`,
+    servedBy: "hybrid",
+    admittedBy: [`rank:${memoryId}`],
+    scoreDecomposition: { final: 0.5 },
+  };
+}
+
 // ─── isRecallXrayServedBy ─────────────────────────────────────────────────
 
 test("isRecallXrayServedBy accepts every documented value", () => {
@@ -49,7 +59,9 @@ test("buildXraySnapshot fills defaults for empty input", () => {
   assert.equal(snapshot.capturedAt, 1_700_000_000_000);
   assert.equal(snapshot.tierExplain, null);
   assert.deepEqual(snapshot.results, []);
-  assert.deepEqual(snapshot.filters, []);
+  assert.equal(snapshot.appliedResultLimit, 0);
+  assert.deepEqual(snapshot.appliedResults, []);
+  assert.deepEqual(snapshot.headroomResults, []);
   assert.deepEqual(snapshot.budget, { chars: 0, used: 0 });
   assert.equal(snapshot.sessionKey, undefined);
   assert.equal(snapshot.namespace, undefined);
@@ -454,6 +466,81 @@ test("buildXraySnapshot shallow-copies results so caller mutation does not leak
   assert.deepEqual(snapshot.results[0]!.admittedBy, ["alpha"]);
 });
 
+test("buildXraySnapshot keeps ordered applied and headroom results separate from presentation results", () => {
+  const presentationResults = [xrayResult("presentation")];
+  const appliedResults = [xrayResult("applied-1"), xrayResult("applied-2")];
+  const headroomResults = [xrayResult("headroom-1"), xrayResult("headroom-2")];
+  const snapshot = buildXraySnapshot({
+    query: "q",
+    results: presentationResults,
+    appliedResultLimit: 2,
+    appliedResults,
+    headroomResults,
+    now: fixedNow,
+    snapshotIdGenerator: idGen(),
+  });
+
+  presentationResults[0]!.admittedBy.push("mutated");
+  appliedResults[0]!.admittedBy.push("mutated");
+  headroomResults[0]!.admittedBy.push("mutated");
+  appliedResults.reverse();
+  headroomResults.reverse();
+
+  assert.equal(snapshot.appliedResultLimit, 2);
+  assert.deepEqual(snapshot.results.map((result) => result.memoryId), ["presentation"]);
+  assert.deepEqual(snapshot.appliedResults.map((result) => result.memoryId), [
+    "applied-1",
+    "applied-2",
+  ]);
+  assert.deepEqual(snapshot.headroomResults.map((result) => result.memoryId), [
+    "headroom-1",
+    "headroom-2",
+  ]);
+  assert.deepEqual(snapshot.appliedResults[0]!.admittedBy, ["rank:applied-1"]);
+  assert.deepEqual(snapshot.headroomResults[0]!.admittedBy, ["rank:headroom-1"]);
+});
+
+test("buildXraySnapshot normalizes invalid and fractional applied result limits", () => {
+  for (const [value, expected] of [
+    [-1, 0],
+    [Number.NaN, 0],
+    [Number.POSITIVE_INFINITY, 0],
+    [2.9, 2],
+  ] as const) {
+    const snapshot = buildXraySnapshot({
+      query: "q",
+      appliedResultLimit: value,
+      now: fixedNow,
+      snapshotIdGenerator: idGen(),
+    });
+    assert.equal(snapshot.appliedResultLimit, expected);
+  }
+});
+
+test("buildXraySnapshot validates applied and headroom candidates like presentation results", () => {
+  const invalid = { ...xrayResult("invalid"), servedBy: "unknown-tier" as never };
+  assert.throws(
+    () =>
+      buildXraySnapshot({
+        query: "q",
+        appliedResults: [invalid],
+        now: fixedNow,
+        snapshotIdGenerator: idGen(),
+      }),
+    /servedBy must be one of/,
+  );
+  assert.throws(
+    () =>
+      buildXraySnapshot({
+        query: "q",
+        headroomResults: [invalid],
+        now: fixedNow,
+        snapshotIdGenerator: idGen(),
+      }),
+    /servedBy must be one of/,
+  );
+});
+
 // ─── RecallXrayBuilder ────────────────────────────────────────────────────
 
 test("RecallXrayBuilder accumulates results and filters then builds a snapshot", () => {

package/src/recall-xray.ts

@@ -256,6 +256,9 @@ export interface RecallXraySnapshot {
    */
   tierExplain: RecallTierExplain | null;
   results: RecallXrayResult[];
+  appliedResultLimit: number;
+  appliedResults: RecallXrayResult[];
+  headroomResults: RecallXrayResult[];
   filters: RecallFilterTrace[];
   /**
    * Character budget accounting for the final assembled recall payload.
@@ -282,6 +285,9 @@ export interface BuildXraySnapshotInput {
   query: string;
   tierExplain?: RecallTierExplain | null;
   results?: RecallXrayResult[];
+  appliedResultLimit?: number;
+  appliedResults?: RecallXrayResult[];
+  headroomResults?: RecallXrayResult[];
   filters?: RecallFilterTrace[];
   budget?: { chars?: number; used?: number };
   sessionKey?: string;
@@ -310,6 +316,12 @@ export function buildXraySnapshot(
   const results = Array.isArray(input.results)
     ? input.results.map(cloneResult)
     : [];
+  const appliedResults = Array.isArray(input.appliedResults)
+    ? input.appliedResults.map(cloneResult)
+    : [];
+  const headroomResults = Array.isArray(input.headroomResults)
+    ? input.headroomResults.map(cloneResult)
+    : [];
   const filters = Array.isArray(input.filters)
     ? input.filters.map(cloneFilter)
     : [];
@@ -346,6 +358,9 @@ export function buildXraySnapshot(
     capturedAt: now(),
     tierExplain,
     results,
+    appliedResultLimit: nonNegativeInt(input.appliedResultLimit),
+    appliedResults,
+    headroomResults,
     filters,
     budget: { chars: budgetChars, used: budgetUsed },
     sessionKey: nonEmptyString(input.sessionKey),

package/src/reconcile/cursor.test.ts

@@ -4,10 +4,13 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { test } from "node:test";
 import {
+  clearConvergeRefreshPending,
   defaultConvergeCursorPath,
   deriveConvergeCursorBase,
   hashPeerNamespace,
+  markConvergeRefreshPending,
   normalizeConvergeCursor,
+  normalizeConvergePeerUrl,
   readConvergeCursor,
   writeConvergeCursor,
   type ConvergeCursorState,
@@ -42,6 +45,21 @@ test("hashPeerNamespace: preserves path case while normalizing URL authority and
   );
 });
 
+test("normalizeConvergePeerUrl: strips credentials and request-only URL parts without folding path case", () => {
+  assert.equal(
+    normalizeConvergePeerUrl(" HTTPS://user:secret@PEER.EXAMPLE.COM:443/Memory/?token=abc#fragment "),
+    "https://peer.example.com/Memory",
+  );
+  assert.equal(
+    hashPeerNamespace("https://user:secret@peer.example.com/Memory?token=abc#fragment", "default"),
+    hashPeerNamespace("https://peer.example.com/Memory/", "DEFAULT "),
+  );
+  assert.notEqual(
+    hashPeerNamespace("https://peer.example.com/Memory", "default"),
+    hashPeerNamespace("https://peer.example.com/memory", "default"),
+  );
+});
+
 test("defaultConvergeCursorPath: constructs path under memoryDir state", () => {
   const p = defaultConvergeCursorPath("/tmp/mem", "http://localhost:4318", "general");
   assert.ok(p.includes(path.join(".remnic", "state", "converge-cursors")));
@@ -151,3 +169,33 @@ test("writeConvergeCursor & readConvergeCursor: atomic write roundtrip", async (
     await fs.rm(tmpDir, { recursive: true, force: true });
   }
 });
+
+test("converge refresh obligations survive restart and clear independently", async () => {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "remnic-cursor-refresh-"));
+  const cursorPath = defaultConvergeCursorPath(tmpDir, "https://peer.example.test", "team");
+  try {
+    await markConvergeRefreshPending(cursorPath, {
+      peerUrl: "https://peer.example.test",
+      namespace: "team",
+      target: "receiver",
+    });
+    await markConvergeRefreshPending(cursorPath, {
+      peerUrl: "https://peer.example.test",
+      namespace: "team",
+      target: "local",
+    });
+
+    const restarted = await readConvergeCursor(cursorPath);
+    assert.ok(restarted);
+    assert.deepEqual(restarted.pendingRefreshes, ["local", "receiver"]);
+    assert.deepEqual(restarted.baseFiles, []);
+
+    await clearConvergeRefreshPending(cursorPath, "receiver");
+    assert.deepEqual((await readConvergeCursor(cursorPath))?.pendingRefreshes, ["local"]);
+
+    await clearConvergeRefreshPending(cursorPath, "local");
+    assert.deepEqual((await readConvergeCursor(cursorPath))?.pendingRefreshes, []);
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+});

package/src/reconcile/cursor.ts

@@ -3,6 +3,8 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { ReconcilePlanEntry, ReconcileSemanticAgreement } from "./plan.js";
 
+export type ConvergeRefreshTarget = "local" | "receiver";
+
 export interface ConvergeCursorFileState {
   path: string;
   sha256: string;
@@ -18,22 +20,26 @@ export interface ConvergeCursorState {
   baseFiles: ConvergeCursorFileState[];
   semanticAgreements?: ReconcileSemanticAgreement[];
   completedPaths?: string[];
+  pendingRefreshes?: ConvergeRefreshTarget[];
 }
 
-export function hashPeerNamespace(peerUrl: string, namespace: string): string {
-  let normalizedUrl: string;
+export function normalizeConvergePeerUrl(peerUrl: string): string {
+  const trimmed = peerUrl.trim();
   try {
-    const url = new URL(peerUrl);
-    const credentials =
-      url.username || url.password
-        ? `${url.username}${url.password ? `:${url.password}` : ""}@`
-        : "";
-    normalizedUrl =
-      `${url.protocol.toLowerCase()}//${credentials}${url.hostname.toLowerCase()}` +
-      `${url.port ? `:${url.port}` : ""}${url.pathname.replace(/\/+$/, "")}${url.search}${url.hash}`;
+    const url = new URL(trimmed);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    url.pathname = url.pathname.replace(/\/+$/, "");
+    return url.toString().replace(/\/$/, "");
   } catch {
-    normalizedUrl = peerUrl.trim().replace(/\/+$/, "").toLowerCase();
+    return trimmed.replace(/\/+$/, "");
   }
+}
+
+export function hashPeerNamespace(peerUrl: string, namespace: string): string {
+  const normalizedUrl = normalizeConvergePeerUrl(peerUrl);
   const normalizedNs = namespace.trim().toLowerCase();
   return createHash("sha256")
     .update(`${normalizedUrl}\0${normalizedNs}`)
@@ -148,6 +154,11 @@ export function normalizeConvergeCursor(input: unknown): ConvergeCursorState {
       }
     }
   }
+  const pendingRefreshes: ConvergeRefreshTarget[] = [];
+  if (Array.isArray(obj.pendingRefreshes)) {
+    if (obj.pendingRefreshes.includes("local")) pendingRefreshes.push("local");
+    if (obj.pendingRefreshes.includes("receiver")) pendingRefreshes.push("receiver");
+  }
   return {
     version: 1,
     peerUrl: obj.peerUrl.trim(),
@@ -156,6 +167,7 @@ export function normalizeConvergeCursor(input: unknown): ConvergeCursorState {
     baseFiles,
     semanticAgreements,
     completedPaths,
+    pendingRefreshes,
   };
 }
 
@@ -191,3 +203,38 @@ export async function writeConvergeCursor(
     throw error;
   }
 }
+
+export async function markConvergeRefreshPending(
+  cursorPath: string,
+  options: {
+    peerUrl: string;
+    namespace: string;
+    target: ConvergeRefreshTarget;
+  },
+): Promise<void> {
+  const current = await readConvergeCursor(cursorPath);
+  const pendingRefreshes = new Set(current?.pendingRefreshes ?? []);
+  pendingRefreshes.add(options.target);
+  await writeConvergeCursor(cursorPath, {
+    version: 1,
+    peerUrl: current?.peerUrl ?? options.peerUrl,
+    namespace: current?.namespace ?? options.namespace,
+    lastConvergedAt: current?.lastConvergedAt,
+    baseFiles: current?.baseFiles ?? [],
+    semanticAgreements: current?.semanticAgreements ?? [],
+    completedPaths: current?.completedPaths ?? [],
+    pendingRefreshes: [...pendingRefreshes].sort(),
+  });
+}
+
+export async function clearConvergeRefreshPending(
+  cursorPath: string,
+  target: ConvergeRefreshTarget,
+): Promise<void> {
+  const current = await readConvergeCursor(cursorPath);
+  if (!current?.pendingRefreshes?.includes(target)) return;
+  await writeConvergeCursor(cursorPath, {
+    ...current,
+    pendingRefreshes: current.pendingRefreshes.filter((pending) => pending !== target),
+  });
+}

package/src/reconcile/manifest.test.ts

@@ -2,6 +2,7 @@ import * as assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 import { test } from "node:test";
 import { ContentHashIndex } from "../storage/content-hash-index.js";
+import { parseFrontmatter } from "../storage.js";
 import { type ReconcileManifest, buildReconcileManifest, collapseActiveFactDuplicates } from "./manifest.js";
 import { planReconciliation } from "./plan.js";
 
@@ -34,6 +35,7 @@ test("reconcile manifest keeps file identity separate from canonical semantic id
 
   const manifest = await buildReconcileManifest({
     files: [{ path: "facts/fact-a.md", sha256: serializedHash, bytes: Buffer.byteLength(serialized) }],
+    parseMemory: parseFrontmatter,
     readFile: async () => Buffer.from(serialized),
   });
 
@@ -59,6 +61,7 @@ test("reconcile manifest hashes parsed legacy content and uses effective lifecyc
 
   const manifest = await buildReconcileManifest({
     files: [...rawByPath].map(([path, raw]) => ({ path, sha256: fileHash(raw.toString()) })),
+    parseMemory: parseFrontmatter,
     readFile: async (file) => rawByPath.get(file.path) ?? null,
   });
 
@@ -79,6 +82,7 @@ test("reconcile manifest keeps file identity when memory bytes cannot be trusted
 
   const manifest = await buildReconcileManifest({
     files,
+    parseMemory: parseFrontmatter,
     readFile: async (file) => {
       if (file.path === "facts/locked.md") throw new Error("locked");
       return file.path === "facts/changed.md" ? changed : readable;

package/src/reconcile/manifest.ts

@@ -34,9 +34,14 @@ export interface ReconcileManifest {
   files: ReconcileManifestFile[];
 }
 
+export type ReconcileMemoryParser = (
+  raw: string,
+) => { frontmatter: MemoryFrontmatter; content: string } | null;
+
 export interface BuildReconcileManifestOptions {
   files: Iterable<ReconcileFileState>;
   readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>;
+  parseMemory: ReconcileMemoryParser;
   cachedFiles?: Iterable<ReconcileManifestFile>;
 }
 
@@ -51,49 +56,46 @@ function isMemoryPath(filePath: string): boolean {
   return MEMORY_DIRS.has(segments[index] ?? "");
 }
 
-function parseScalar(value: string | undefined): string | undefined {
-  if (value === undefined) return undefined;
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return undefined;
-  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-    try {
-      const parsed = JSON.parse(trimmed) as unknown;
-      return typeof parsed === "string" ? parsed : trimmed;
-    } catch {
-      return trimmed.slice(1, -1).replace(/\\"/g, '"');
-    }
-  }
-  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1).replace(/''/g, "'");
-  }
-  return trimmed;
-}
 
-function parsedMemoryIdentity(filePath: string, raw: Buffer | string): ReconcileMemoryIdentity | undefined {
+function parsedMemoryIdentity(
+  filePath: string,
+  raw: Buffer | string,
+  parseMemory: ReconcileMemoryParser,
+): ReconcileMemoryIdentity | undefined {
   if (!isMemoryPath(filePath)) return undefined;
-  const match = (Buffer.isBuffer(raw) ? raw.toString("utf8") : raw).match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return undefined;
-  const fields = new Map<string, string>();
-  for (const line of match[1].split("\n")) {
-    const separator = line.indexOf(":");
-    if (separator > 0) fields.set(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
-  }
-  const id = parseScalar(fields.get("id"));
-  if (!id) return undefined;
-  const category = parseScalar(fields.get("category")) ?? "fact";
-  const storedHash = parseScalar(fields.get("contentHash"));
+  const parsed = parseMemory(Buffer.isBuffer(raw) ? raw.toString("utf8") : raw);
+  if (!parsed?.frontmatter.id) return undefined;
+  const storedHash = parsed.frontmatter.contentHash;
   const contentHash =
     storedHash && SHA256_PATTERN.test(storedHash)
       ? storedHash.toLowerCase()
-      : ContentHashIndex.computeHash(match[2].trim());
-  const status = inferMemoryStatus(
-    {
-      status: parseScalar(fields.get("status")) as MemoryStatus | undefined,
-      archivedAt: parseScalar(fields.get("archivedAt")),
-    } as MemoryFrontmatter,
-    filePath
-  );
-  return { id, category, contentHash, status };
+      : ContentHashIndex.computeHash(parsed.content);
+  return {
+    id: parsed.frontmatter.id,
+    category: parsed.frontmatter.category,
+    contentHash,
+    status: inferMemoryStatus(parsed.frontmatter, filePath),
+  };
+}
+
+export async function buildReconcileManifestFile(
+  file: ReconcileFileState,
+  readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>,
+  parseMemory: ReconcileMemoryParser,
+): Promise<ReconcileManifestFile> {
+  let raw: Buffer | string | null = null;
+  if (isMemoryPath(file.path)) {
+    try {
+      raw = await readFile(file);
+    } catch {
+      raw = null;
+    }
+  }
+  if (raw !== null && createHash("sha256").update(raw).digest("hex") !== file.sha256.toLowerCase()) {
+    raw = null;
+  }
+  const memory = raw === null ? undefined : parsedMemoryIdentity(file.path, raw, parseMemory);
+  return { ...file, ...(memory ? { memory } : {}) };
 }
 
 export async function buildReconcileManifest(options: BuildReconcileManifestOptions): Promise<ReconcileManifest> {
@@ -110,19 +112,7 @@ export async function buildReconcileManifest(options: BuildReconcileManifestOpti
       continue;
     }
 
-    let raw: Buffer | string | null = null;
-    if (isMemoryPath(file.path)) {
-      try {
-        raw = await options.readFile(file);
-      } catch {
-        raw = null;
-      }
-    }
-    if (raw !== null && createHash("sha256").update(raw).digest("hex") !== file.sha256.toLowerCase()) {
-      raw = null;
-    }
-    const memory = raw === null ? undefined : parsedMemoryIdentity(file.path, raw);
-    files.push({ ...file, ...(memory ? { memory } : {}) });
+    files.push(await buildReconcileManifestFile(file, options.readFile, options.parseMemory));
   }
   files.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
   return {

package/src/reconcile/plan.test.ts

@@ -222,6 +222,10 @@ test("newest-wins compares delete revision times with surviving modifications",
   assert.equal(entryFor(entries, "facts/peer-deletion-wins.md").resolution, "peer-wins");
   assert.equal(entryFor(entries, "facts/peer-modification-wins.md").resolution, "peer-wins");
   assert.equal(entryFor(entries, "facts/local-deletion-wins.md").resolution, "local-wins");
+  assert.equal(entryFor(entries, "facts/peer-deletion-wins.md").deletionMtimeMs, 3000);
+  assert.equal(entryFor(entries, "facts/local-deletion-wins.md").deletionMtimeMs, 3000);
+  assert.equal(entryFor(entries, "facts/local-modification-wins.md").deletionMtimeMs, undefined);
+  assert.equal(entryFor(entries, "facts/peer-modification-wins.md").deletionMtimeMs, undefined);
 });
 
 test("namespaces are planned independently and reported separately", () => {

package/src/reconcile/plan.ts

@@ -62,6 +62,8 @@ export interface ReconcilePlanEntry {
   baseSha256?: string;
   /** Set only when `action` is `conflict`. */
   resolution?: ReconcileResolution;
+  /** Original revision time when conflict resolution propagates a deletion. */
+  deletionMtimeMs?: number;
   /**
    * Which side holds the retracted revision. Set only when `action` is
    * `suppress`: with different digests on each side and only one retracted,
@@ -652,6 +654,15 @@ export function planNamespaceReconciliation(
       // a deliberate deletion. Without a base the peer simply never saw the
       // path, and a bootstrap merge must push — both sides hold unique data.
       if (baseSha256 !== undefined) {
+        const peerDeletionMtime = peerDeletionMtimeMs.get(path);
+        const resolution = baseSha256 === localFile.sha256
+          ? "unresolved"
+          : resolveConflict(
+              policy,
+              localFile.mtimeMs,
+              peerDeletionMtime,
+              "unresolved",
+            );
         entries.push({
           path,
           namespace,
@@ -659,14 +670,10 @@ export function planNamespaceReconciliation(
           reason: baseSha256 === localFile.sha256 ? "peer_deleted" : "local_modified_peer_deleted",
           localSha256: localFile.sha256,
           baseSha256,
-          resolution: baseSha256 === localFile.sha256
-            ? "unresolved"
-            : resolveConflict(
-                policy,
-                localFile.mtimeMs,
-                peerDeletionMtimeMs.get(path),
-                "unresolved",
-              ),
+          resolution,
+          ...(resolution === "peer-wins" && peerDeletionMtime !== undefined
+            ? { deletionMtimeMs: peerDeletionMtime }
+            : {}),
         });
         continue;
       }
@@ -756,6 +763,15 @@ export function planNamespaceReconciliation(
       continue;
     }
     if (baseSha256 !== undefined) {
+      const localDeletionMtime = localDeletionMtimeMs.get(path);
+      const resolution = baseSha256 === peerFile.sha256
+        ? "unresolved"
+        : resolveConflict(
+            policy,
+            localDeletionMtime,
+            peerFile.mtimeMs,
+            "unresolved",
+          );
       entries.push({
         path,
         namespace,
@@ -763,14 +779,10 @@ export function planNamespaceReconciliation(
         reason: baseSha256 === peerFile.sha256 ? "local_deleted" : "local_deleted_peer_modified",
         peerSha256: peerFile.sha256,
         baseSha256,
-        resolution: baseSha256 === peerFile.sha256
-          ? "unresolved"
-          : resolveConflict(
-              policy,
-              localDeletionMtimeMs.get(path),
-              peerFile.mtimeMs,
-              "unresolved",
-            ),
+        resolution,
+        ...(resolution === "local-wins" && localDeletionMtime !== undefined
+          ? { deletionMtimeMs: localDeletionMtime }
+          : {}),
       });
       continue;
     }