@remnic/core 9.69.32 → 9.69.34

package/src/orchestration/recall-search-pipeline.ts

@@ -99,6 +99,8 @@ export interface RecallSearchPipelineDeps {
        * string at the input boundary (CLI / HTTP / MCP).
        */
       asOfMs?: number;
+      /** #1952 state-view admission — see filterSearchResultsByRecallSafety. */
+      stateViewActive?: boolean;
       requestingConnector?: string;
     },
   ): Promise<QmdSearchResult[]>;
@@ -172,6 +174,8 @@ export interface RecallSearchPipelineDeps {
       dropUnresolved?: boolean;
       recallNamespaces?: readonly string[];
       requestingConnector?: string;
+      /** #1952 state-view admission — see filterSearchResultsByRecallSafety. */
+      stateViewActive?: boolean;
     },
   ): Promise<{ results: QmdSearchResult[]; memoryByPath: Map<string, MemoryFile> }>;
   loadSearchResultMemoryMap(
@@ -598,6 +602,8 @@ export class RecallSearchPipelineCoordinator {
     deadlineAtMs?: number | null;
     /** Issue #681 — when true, bypass graphTraversalConfidenceFloor. */
     includeLowConfidence?: boolean;
+    /** #1952 state-view admission — resolved by the caller from config/override + change intent. */
+    stateViewActive?: boolean;
   }): Promise<QmdSearchResult[]> {
     // Prefer the threaded set; fall back to a config-derived set so direct
     // callers (unit tests) behave identically to the recall pipeline (#1523).
@@ -844,6 +850,7 @@ export class RecallSearchPipelineCoordinator {
         dropUnresolved: true,
         recallNamespaces: options.recallNamespaces,
         requestingConnector: options.requestingConnector,
+        stateViewActive: options.stateViewActive,
       },
     );
     results = boostInput.results;
@@ -864,6 +871,7 @@ export class RecallSearchPipelineCoordinator {
                 {
                   allowLifecycleFiltered: true,
                   asOfMs: options.asOfMs,
+                  stateViewActive: options.stateViewActive,
                   requestingConnector: options.requestingConnector,
                 },
               ),
@@ -882,6 +890,7 @@ export class RecallSearchPipelineCoordinator {
               {
                 allowLifecycleFiltered: true,
                 asOfMs: options.asOfMs,
+                stateViewActive: options.stateViewActive,
                 requestingConnector: options.requestingConnector,
               },
             ));
@@ -1108,8 +1117,45 @@ export class RecallSearchPipelineCoordinator {
       asOfMs?: number;
       blockedPaths?: Set<string>;
       requestingConnector?: string;
+      /**
+       * #1952 state-aware recall views. When true (config `recallStateViews`
+       * or per-call override, AND a change-intent query — resolved by the
+       * caller), a superseded candidate is admitted iff its successor
+       * (`frontmatter.supersededBy`) is also in this candidate set. The
+       * admitted row carries `id`/`status`/`supersededBy`/`supersededAt` so
+       * the inject seam can label it; every other path is unchanged.
+       */
+      stateViewActive?: boolean;
     },
   ): QmdSearchResult[] {
+    // #1952 state-aware recall views. A superseded row is admitted only
+    // when its successor SURVIVES this filter — a successor rejected by
+    // the connector/lifecycle/validity/dedicated-surface/status gates
+    // must never anchor (or spend a result slot on) its superseded row.
+    // Anchors are therefore collected from rows that survive the pass
+    // below; superseded rows defer admission to the post-pass fixpoint.
+    const stateViewActive = options?.stateViewActive === true;
+    const stateViewSurvivorIds = stateViewActive ? new Set<string>() : null;
+    const stateViewDeferred: number[] = [];
+    const stateViewBuilt: (QmdSearchResult | null)[] | null = stateViewActive
+      ? new Array<QmdSearchResult | null>(results.length).fill(null)
+      : null;
+    const buildRecallRow = (r: QmdSearchResult, memory: MemoryFile | undefined): QmdSearchResult => ({
+      ...r,
+      sourceConnector: memory ? memory.frontmatter.sourceConnector : undefined,
+      origin: memory ? memory.frontmatter.origin : undefined,
+      // #1952: an active state view carries the chain fields the inject
+      // seam labels from (id/status/supersededBy/supersededAt).
+      ...(stateViewActive && memory
+        ? {
+            id: memory.frontmatter.id,
+            status: memory.frontmatter.status,
+            supersededBy: memory.frontmatter.supersededBy,
+            supersededAt: memory.frontmatter.supersededAt,
+          }
+        : {}),
+    });
+    let stateViewAdmittedCount = 0;
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.deps.config);
     let lifecycleFilteredCount = 0;
     let temporalSupersededFilteredCount = 0;
@@ -1120,7 +1166,9 @@ export class RecallSearchPipelineCoordinator {
     let connectorPartitionFilteredCount = 0;
     let supportPassportFilteredCount = 0;
     const filtered: QmdSearchResult[] = [];
-    for (const r of results) {
+    for (let resultIdx = 0; resultIdx < results.length; resultIdx += 1) {
+      const r = results[resultIdx]!;
+      let stateViewPending = false;
       if (options?.blockedPaths && resultHasKey(options.blockedPaths, r)) {
         blockedPathFilteredCount += 1;
         continue;
@@ -1195,16 +1243,23 @@ export class RecallSearchPipelineCoordinator {
           // allowLifecycleFiltered=true to include archived/retired
           // candidates, but superseded memories must still be filtered
           // unless temporalSupersessionIncludeInRecall is set.
-          // Skipped entirely when `as_of` is active (above branch); the
-          // half-open `[valid_at, invalid_at)` evaluation in isValidAsOf
-          // is the authoritative gate for historical recall.
+          // #1952: an active state view ADMITS the superseded row when its
+          // successor also survives this filter — history never renders
+          // unanchored, and a successor rejected by any gate here can
+          // never anchor. Admission defers to the post-pass fixpoint.
+          // Skipped entirely when `as_of` is active (above branch);
+          // isValidAsOf stays the authoritative historical gate.
           shouldFilterSupersededFromRecall(memory.frontmatter, {
             enabled: lifecycleCaps.temporalSupersession,
             includeInRecall: this.deps.config.temporalSupersessionIncludeInRecall,
           })
         ) {
-          temporalSupersededFilteredCount += 1;
-          continue;
+          if (stateViewActive) {
+            stateViewPending = true;
+          } else {
+            temporalSupersededFilteredCount += 1;
+            continue;
+          }
         }
         // Bi-temporal INJECTION filter (issue #1578): when the master gate
         // is on and the caller did NOT pin `as_of`, drop facts whose event-
@@ -1243,11 +1298,57 @@ export class RecallSearchPipelineCoordinator {
       }
       // Derive persisted provenance exclusively from hydrated frontmatter.
       // The formatter parses this value at the model-context render site.
-      filtered.push({
-        ...r,
-        sourceConnector: memory ? memory.frontmatter.sourceConnector : undefined,
-        origin: memory ? memory.frontmatter.origin : undefined,
-      });
+      if (stateViewPending) {
+        // Survived every other gate; admission now hinges on the
+        // successor surviving too — decided by the fixpoint below.
+        stateViewDeferred.push(resultIdx);
+        continue;
+      }
+      const builtRow = buildRecallRow(r, memory);
+      if (stateViewBuilt !== null) {
+        stateViewBuilt[resultIdx] = builtRow;
+        if (memory) {
+          const id = memory.frontmatter.id;
+          if (typeof id === "string" && id.length > 0) stateViewSurvivorIds!.add(id);
+        }
+      }
+      filtered.push(builtRow);
+    }
+    if (stateViewDeferred.length > 0) {
+      // #1952 admission fixpoint: a deferred superseded row joins the
+      // output only when its successor is (or becomes) part of the
+      // filter-surviving set. An admitted row can itself anchor the next
+      // link of a chain, so iterate to a fixpoint.
+      const admitted = new Set<number>();
+      for (let progress = true; progress; ) {
+        progress = false;
+        for (const deferredIdx of stateViewDeferred) {
+          if (admitted.has(deferredIdx)) continue;
+          const deferredMemory = memoryForResult(memoryByPath, results[deferredIdx]!);
+          if (!deferredMemory) continue;
+          if (stateViewSurvivorIds!.has(deferredMemory.frontmatter.supersededBy ?? "")) {
+            admitted.add(deferredIdx);
+            const id = deferredMemory.frontmatter.id;
+            if (typeof id === "string" && id.length > 0) stateViewSurvivorIds!.add(id);
+            progress = true;
+          }
+        }
+      }
+      for (const deferredIdx of stateViewDeferred) {
+        const deferredMemory = memoryForResult(memoryByPath, results[deferredIdx]!);
+        if (admitted.has(deferredIdx) && deferredMemory) {
+          stateViewAdmittedCount += 1;
+          stateViewBuilt![deferredIdx] = buildRecallRow(results[deferredIdx]!, deferredMemory);
+        } else {
+          temporalSupersededFilteredCount += 1;
+        }
+      }
+      // Re-emit in the order candidates entered this filter so an
+      // admitted predecessor keeps its rank position (no slot swap).
+      filtered.length = 0;
+      for (const builtRow of stateViewBuilt!) {
+        if (builtRow) filtered.push(builtRow);
+      }
     }
     if (connectorPartitionFilteredCount > 0) {
       log.debug(
@@ -1269,6 +1370,11 @@ export class RecallSearchPipelineCoordinator {
         `temporal supersession filter removed ${temporalSupersededFilteredCount} superseded candidates`,
       );
     }
+    if (stateViewAdmittedCount > 0) {
+      log.debug(
+        `state views admitted ${stateViewAdmittedCount} superseded candidates anchored on in-set successors (#1952)`,
+      );
+    }
     if (biTemporalExpiredFilteredCount > 0) {
       log.debug(
         `bi-temporal validity filter removed ${biTemporalExpiredFilteredCount} expired-validity candidates from injection (temporal.biTemporal on)`,
@@ -1304,6 +1410,8 @@ export class RecallSearchPipelineCoordinator {
       dropUnresolved?: boolean;
       recallNamespaces?: readonly string[];
       requestingConnector?: string;
+      /** #1952 state-view admission — see filterSearchResultsByRecallSafety. */
+      stateViewActive?: boolean;
     },
   ): Promise<{ results: QmdSearchResult[]; memoryByPath: Map<string, MemoryFile> }> {
     if (results.length === 0) {
@@ -1366,6 +1474,8 @@ export class RecallSearchPipelineCoordinator {
        * string at the input boundary (CLI / HTTP / MCP).
        */
       asOfMs?: number;
+      /** #1952 state-view admission — flows into filterSearchResultsForRecall. */
+      stateViewActive?: boolean;
       requestingConnector?: string;
     },
   ): Promise<QmdSearchResult[]> {

package/src/orchestration/recall-state-view-pipeline.test.ts

@@ -0,0 +1,211 @@
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+import test from "node:test";
+
+import { parseConfig } from "../config.js";
+import { RecallSearchPipelineCoordinator } from "./recall-search-pipeline.js";
+import type { RecallSearchPipelineDeps } from "./recall-search-pipeline.js";
+import type { MemoryFile, QmdSearchResult } from "../types.js";
+import type { StorageManager } from "../index.js";
+
+function result(path_: string, score = 1): QmdSearchResult {
+  return { docid: `qmd-${path_}`, path: path_, score, snippet: path_ };
+}
+
+function memory(path_: string, fm: Partial<MemoryFile["frontmatter"]>): MemoryFile {
+  return {
+    path: path_,
+    content: path_,
+    frontmatter: {
+      created: "2026-07-19T00:00:00.000Z",
+      updated: "2026-07-19T00:00:00.000Z",
+      ...fm,
+    } as unknown as MemoryFile["frontmatter"],
+  };
+}
+
+async function makeCoordinator(memoryDir: string): Promise<RecallSearchPipelineCoordinator> {
+  const config = parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    temporalSupersessionEnabled: true,
+    temporalSupersessionIncludeInRecall: false,
+  });
+  assert.equal(config.recallStateViews, false, "parseConfig default must be false");
+  const deps = {
+    config,
+    storage: {} as StorageManager,
+    readQmdResultMemory: async () => null,
+  } as unknown as RecallSearchPipelineDeps;
+  return new RecallSearchPipelineCoordinator(deps);
+}
+
+const OLD = "facts/job-old.md";
+const NEW = "facts/job-new.md";
+
+function corpus(): { results: QmdSearchResult[]; memories: Map<string, MemoryFile> } {
+  const results = [result(NEW, 0.9), result(OLD, 0.7)];
+  const memories = new Map<string, MemoryFile>([
+    [NEW, memory(NEW, { id: "m-new", status: "active" })],
+    [
+      OLD,
+      memory(OLD, {
+        id: "m-old",
+        status: "superseded",
+        supersededBy: "m-new",
+        supersededAt: "2026-08-01",
+      }),
+    ],
+  ]);
+  return { results, memories };
+}
+
+test("state view admits a superseded candidate when its successor is in the set", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-admit-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const { results, memories } = corpus();
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(
+      safe.map((r) => r.path).sort(),
+      [NEW, OLD],
+      "superseded row must be admitted alongside its successor",
+    );
+    const old = safe.find((r) => r.path === OLD);
+    assert.equal(old?.id, "m-old", "admitted row carries the frontmatter id");
+    assert.equal(old?.status, "superseded");
+    assert.equal(old?.supersededBy, "m-new");
+    assert.equal(old?.supersededAt, "2026-08-01");
+    // Successor stays unlabeled by the filter — labeling is the inject seam's job.
+    assert.equal(safe.find((r) => r.path === NEW)?.supersededBy, undefined);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+test("default (stateViewActive unset) keeps filtering superseded — zero-diff baseline", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-off-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const { results, memories } = corpus();
+    const baseline = coordinator.filterSearchResultsByRecallSafety(results, memories);
+    const explicitOff = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: false,
+    });
+    assert.deepEqual(baseline.map((r) => r.path), [NEW]);
+    assert.deepEqual(explicitOff.map((r) => r.path), [NEW]);
+    // No chain fields leak onto survivors when the view is off.
+    assert.equal(baseline[0]?.supersededBy, undefined);
+    assert.equal(baseline[0]?.id, undefined);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("state view does NOT admit a superseded candidate whose successor is absent", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-orphan-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const results = [result(OLD, 0.7)];
+    const memories = new Map<string, MemoryFile>([
+      [
+        OLD,
+        memory(OLD, {
+          id: "m-old",
+          status: "superseded",
+          supersededBy: "m-absent",
+          supersededAt: "2026-08-01",
+        }),
+      ],
+    ]);
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(safe, [], "orphaned superseded row must stay filtered");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a successor rejected by the status gate cannot anchor its superseded row (no slot consumed)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-anchor-status-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const OTHER = "facts/unrelated.md";
+    const results = [result(OLD, 0.9), result(NEW, 0.8), result(OTHER, 0.7)];
+    const memories = new Map<string, MemoryFile>([
+      [
+        OLD,
+        memory(OLD, {
+          id: "m-old",
+          status: "superseded",
+          supersededBy: "m-new",
+          supersededAt: "2026-08-01",
+        }),
+      ],
+      // In memoryByPath (pre-filter) but rejected by the forgotten-status
+      // gate — pre-fix this id anchored m-old and admitted it.
+      [NEW, memory(NEW, { id: "m-new", status: "forgotten" })],
+      [OTHER, memory(OTHER, { id: "m-other", status: "active" })],
+    ]);
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(
+      safe.map((r) => r.path),
+      [OTHER],
+      "a filter-rejected successor must not anchor its superseded row, and the orphaned row must not consume a slot",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a successor rejected by the dedicated-surface gate cannot anchor its superseded row", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-anchor-surface-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const results = [result(OLD, 0.9), result(NEW, 0.8)];
+    const memories = new Map<string, MemoryFile>([
+      [
+        OLD,
+        memory(OLD, {
+          id: "m-old",
+          status: "superseded",
+          supersededBy: "m-new",
+          supersededAt: "2026-08-01",
+        }),
+      ],
+      [NEW, memory(NEW, { id: "m-new", status: "active", memoryKind: "dream" })],
+    ]);
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(safe, [], "dream-surface successors must not anchor superseded rows");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("an anchored predecessor keeps its rank position when admitted", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-sv-anchor-order-"));
+  try {
+    const coordinator = await makeCoordinator(memoryDir);
+    const { results, memories } = corpus();
+    const safe = coordinator.filterSearchResultsByRecallSafety(results, memories, {
+      stateViewActive: true,
+    });
+    assert.deepEqual(
+      safe.map((r) => r.path),
+      [NEW, OLD],
+      "admission must not reorder candidates relative to their incoming rank",
+    );
+    assert.equal(safe[1]?.supersededBy, "m-new", "admitted row carries the chain fields");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/orchestration/semantic-merge-commit-effects.ts

@@ -137,31 +137,85 @@ export async function readTargetSnapshot(
 
 /**
  * Undo a merged body whose provenance patch never landed, and report what is
- * actually true of storage afterwards: `true` means the target no longer holds
- * unprovenanced merged text, so the caller may honestly create the fact.
+ * actually true of storage afterwards:
+ *  - "reverted" — the target no longer holds this merge's unprovenanced text
+ *    (ours was restored away, or another writer already replaced the body
+ *  - "superseded" — the standing merged body is ANOTHER writer's commit
+ *    (#2813 P1): `committedRevision` names the receipt token OUR CAS minted,
+ *    the reread holds a different standing token, and a concurrent writer's
+ *    deterministic merge is byte-for-byte our merged text — so only the
+ *    token can attribute the standing record. Never revert theirs; the
+ *    caller discards its own staged duplicate and reports the degraded merge;
+ *  - "stands" — unverifiable (unreadable target), or the restore lost its
+ *    race, so assume the merged text stands and refuse to create a duplicate.
  *
- * Three states, because only one of them is ours to undo:
- *  - the body is still our merged text → restore the pre-merge body under a
- *    compare-and-swap on the re-read snapshot;
- *  - another writer already replaced it → nothing of ours remains, so the
- *    restore is skipped rather than clobbering that writer's body;
- *  - the target is unreadable → unverifiable, so assume the merged text stands
- *    and refuse to create a duplicate.
+ * `committedRevision` is the CAS commit receipt (markCasCommittedRevision,
+ * or the successful CAS's return value): the dedicated per-target revision
+ * token from the durable sidecar (#2807) — unique per commit even within one
+ * millisecond. Public `frontmatter.updated` never identifies a commit.
+ * Callers without identity omit it and keep the body-equality
+ * classification above.
  */
+export type RevertMergedContentResult = "reverted" | "superseded" | "stands";
+
 export async function revertMergedContent(
   storage: StorageManager,
   target: MemoryFile,
   mergedContent: string,
-): Promise<boolean> {
+  committedRevision?: string,
+): Promise<RevertMergedContentResult> {
   try {
     const current = await readTargetSnapshot(storage, target);
-    if (!current) return false;
-    if (current.content !== mergedContent) return true;
-    return await storage.updateMemoryIfUnchanged(current, target.content, {
+    if (!current) return "stands";
+    if (current.content !== mergedContent) return "reverted";
+    // #2813 (P1): the merged body standing is provably OURS only while the
+    // target still carries the revision token our CAS minted. A different
+    // token means a concurrent writer committed the same deterministic
+    // body after our lock was released — reverting would delete their valid
+    // merge while their provenance patch may already have landed.
+    if (committedRevision !== undefined) {
+      // #2813 (P1 B): the standing receipt is a THREE-WAY truth. Only a
+      // PROVEN foreign token may take the superseded path — that proof is
+      // what licenses discarding this writer's staged snapshot. The old
+      // fail-open read collapsed an unreadable sidecar into undefined,
+      // which classified as superseded and discarded the recovery
+      // snapshot on unproven grounds. Unavailable (transiently
+      // unreadable, or a reservation pending finalization) and absent
+      // (which cannot corroborate EITHER writer while this receipt is in
+      // hand) are keep-side: the degraded branch preserves the snapshot
+      // and reconciliation retries.
+      let standing: Awaited<ReturnType<StorageManager["readCasRevisionStatus"]>>;
+      try {
+        standing = await storage.readCasRevisionStatus(target.path);
+      } catch (err) {
+        standing = {
+          status: "unavailable",
+          reason: err instanceof Error ? err.message : String(err),
+        };
+      }
+      if (standing.status === "present") {
+        if (standing.revision !== committedRevision) {
+          return "superseded";
+        }
+      } else if (standing.status === "unavailable") {
+        log.warn(
+          `revertMergedContent: CAS revision status for ${target.path} is unavailable (${standing.reason}); ownership cannot be verified — keeping the recovery snapshot instead of discarding or reverting`,
+        );
+        return "stands";
+      } else {
+        log.warn(
+          `revertMergedContent: CAS revision receipt for ${target.path} is absent although this writer holds receipt ${committedRevision}; ownership cannot be verified — keeping the recovery snapshot`,
+        );
+        return "stands";
+      }
+    }
+    return (await storage.updateMemoryIfUnchanged(current, target.content, {
       actor: "semantic-merge-rollback",
-    });
+    }))
+      ? "reverted"
+      : "stands";
   } catch {
-    return false;
+    return "stands";
   }
 }
 
@@ -225,12 +279,13 @@ export async function rewriteMergedTargetGraphEdges(
   storage: {
     dir: string;
     getMemoryByIdIncludingArchived: (id: string) => Promise<MemoryFile | null>;
+    readCasRevision: (filePath: string) => Promise<string | undefined>;
   },
   input: {
     targetId: string;
     memoryRelPath: string;
     mergedContent: string;
-    /** The frontmatter `updated` value the committed-body check validated. */
+    /** The CAS revision token the committed-body check observed. */
     revisionChecked: string | undefined;
     rewriteTypes: readonly GraphType[];
     build: () => Promise<GraphEdge[] | void>;
@@ -247,10 +302,14 @@ export async function rewriteMergedTargetGraphEdges(
   try {
     appended = (await input.build()) ?? undefined;
     const committedNow = await storage.getMemoryByIdIncludingArchived(input.targetId);
+    const committedRevision = committedNow === null ? undefined : await storage.readCasRevision(committedNow.path).catch((err) => {
+      log.warn(`rewriteMergedTargetGraphEdges: failed to read CAS revision for ${committedNow.path}: ${err}`);
+      return undefined;
+    });
     if (
       !committedNow ||
       committedNow.content !== input.mergedContent ||
-      committedNow.frontmatter.updated !== input.revisionChecked
+      committedRevision !== input.revisionChecked
     ) {
       await rollbackNodeEdgeRewrite(storage.dir, input.memoryRelPath, input.rewriteTypes, removedEdges, input.targetId, appended);
       return false;