@remnic/core 9.50.2 → 9.51.0

package/src/orchestration/update-localization.ts

@@ -0,0 +1,173 @@
+import type { MemoryFile, MemoryStatus } from "../types.js";
+import { inferMemoryStatus, isActiveMemoryStatus, toMemoryPathRel } from "../memory-lifecycle-ledger-utils.js";
+import { lookupAttributeByNormalizedKey, normalizeSupersessionKey } from "../temporal-supersession.js";
+
+export interface UpdateLocalizationStorage {
+  dir?: string;
+  readAllMemories(): Promise<MemoryFile[]>;
+  readAllColdMemories?: () => Promise<MemoryFile[]>;
+}
+
+export function mergeMemorySnapshots(
+  hot: MemoryFile[],
+  cold: MemoryFile[],
+  storageDir?: string,
+): MemoryFile[] {
+  const merged: MemoryFile[] = [];
+  const indexById = new Map<string, number>();
+  for (const memory of [...hot, ...cold]) {
+    const id = memory.frontmatter.id;
+    const existingIndex = indexById.get(id);
+    if (existingIndex === undefined) {
+      indexById.set(id, merged.length);
+      merged.push(memory);
+      continue;
+    }
+    const existing = merged[existingIndex];
+    if (
+      !isActiveMemoryStatus(inferLocalizationMemoryStatus(existing, storageDir)) &&
+      isActiveMemoryStatus(inferLocalizationMemoryStatus(memory, storageDir))
+    ) {
+      merged[existingIndex] = memory;
+    }
+  }
+  return merged;
+}
+
+export interface UpdateAnchor {
+  entityRef?: string;
+  category: string;
+  attributes?: Record<string, string>;
+}
+
+export interface UpdateLocalizationSearchHit {
+  id: string;
+  content: string;
+  category: string;
+  score: number;
+}
+
+export interface LocalizedCandidate {
+  id: string;
+  content: string;
+  category: string;
+  source: "anchor" | "search";
+  score: number;
+}
+
+export interface UpdateLocalizationOptions {
+  anchorCandidates: number;
+  searchCandidates: number;
+  maxCandidates: number;
+}
+
+export interface UpdateLocalizationDeps {
+  storage: UpdateLocalizationStorage;
+  qmdSearch: (query: string, limit: number) => Promise<UpdateLocalizationSearchHit[]>;
+}
+
+function cap(value: number): number {
+  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+
+function normalizeEntityRef(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = normalizeSupersessionKey(value);
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+function compareCandidates(left: LocalizedCandidate, right: LocalizedCandidate): number {
+  const leftScore = Number.isFinite(left.score) ? left.score : Number.NEGATIVE_INFINITY;
+  const rightScore = Number.isFinite(right.score) ? right.score : Number.NEGATIVE_INFINITY;
+  if (leftScore !== rightScore) return leftScore > rightScore ? -1 : 1;
+  return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+
+function anchorScore(memory: MemoryFile, anchor: UpdateAnchor): number {
+  const attributes = anchor.attributes;
+  if (attributes && Object.keys(attributes).length > 0) {
+    const candidateAttributes = memory.frontmatter.structuredAttributes;
+    if (!candidateAttributes) return 0;
+    let overlap = 0;
+    for (const key of Object.keys(attributes)) {
+      if (lookupAttributeByNormalizedKey(candidateAttributes, key) !== undefined) overlap++;
+    }
+    return overlap;
+  }
+
+  const created = Date.parse(memory.frontmatter.created);
+  return Number.isFinite(created) ? created : 0;
+}
+
+function toAnchorCandidate(memory: MemoryFile, anchor: UpdateAnchor): LocalizedCandidate {
+  return {
+    id: memory.frontmatter.id,
+    content: memory.content,
+    category: memory.frontmatter.category,
+    source: "anchor",
+    score: anchorScore(memory, anchor),
+  };
+}
+
+export function inferLocalizationMemoryStatus(
+  memory: MemoryFile,
+  storageDir?: string,
+): MemoryStatus {
+  const pathRel = storageDir ? toMemoryPathRel(storageDir, memory.path) : memory.path;
+  return inferMemoryStatus(memory.frontmatter, pathRel);
+}
+
+export async function localizeUpdateCandidates(
+  deps: UpdateLocalizationDeps,
+  anchor: UpdateAnchor,
+  newContent: string,
+  options: UpdateLocalizationOptions,
+): Promise<LocalizedCandidate[]> {
+  const maxCandidates = cap(options.maxCandidates);
+  if (maxCandidates === 0) return [];
+
+  const anchorLimit = cap(options.anchorCandidates);
+  const searchLimit = cap(options.searchCandidates);
+  const anchorCandidates: LocalizedCandidate[] = [];
+  const normalizedAnchorEntityRef = normalizeEntityRef(anchor.entityRef);
+  if (normalizedAnchorEntityRef !== undefined && anchorLimit > 0) {
+    const hot = await deps.storage.readAllMemories();
+    const cold = deps.storage.readAllColdMemories ? await deps.storage.readAllColdMemories() : [];
+    const memories = mergeMemorySnapshots(hot, cold, deps.storage.dir);
+    for (const memory of memories) {
+      if (inferLocalizationMemoryStatus(memory, deps.storage.dir) !== "active") continue;
+      const normalizedCandidateEntityRef = normalizeEntityRef(memory.frontmatter.entityRef);
+      if (normalizedCandidateEntityRef !== normalizedAnchorEntityRef) continue;
+      if (memory.frontmatter.category !== anchor.category) continue;
+      anchorCandidates.push(toAnchorCandidate(memory, anchor));
+    }
+    anchorCandidates.sort(compareCandidates);
+    anchorCandidates.splice(anchorLimit);
+  }
+
+  const searchCandidates: LocalizedCandidate[] = [];
+  if (searchLimit > 0) {
+    const searchHits = await deps.qmdSearch(newContent, searchLimit);
+    for (const hit of searchHits) {
+      searchCandidates.push({
+        id: hit.id,
+        content: hit.content,
+        category: hit.category,
+        source: "search",
+        score: hit.score,
+      });
+    }
+    searchCandidates.sort(compareCandidates);
+    searchCandidates.splice(searchLimit);
+  }
+
+  const merged: LocalizedCandidate[] = [];
+  const seen = new Set<string>();
+  for (const candidate of [...anchorCandidates, ...searchCandidates]) {
+    if (seen.has(candidate.id)) continue;
+    seen.add(candidate.id);
+    merged.push(candidate);
+    if (merged.length >= maxCandidates) break;
+  }
+  return merged;
+}

package/src/orchestrator.ts

@@ -111,7 +111,10 @@ import {
   type RecallSectionBuckets,
 } from "./orchestration/recall-section-coordinator.js";
 import { QmdResultResolver, qmdCollectionPathParts, qmdResultPathCandidates } from "./orchestration/qmd-result-resolver.js";
-import { ContradictionLinkingCoordinator } from "./orchestration/contradiction-linking-coordinator.js";
+import {
+  ContradictionLinkingCoordinator,
+  type ContradictionResolveOutcome,
+} from "./orchestration/contradiction-linking-coordinator.js";
 import {
   ExtractionRunCoordinator,
   type ExtractionRunResult,
@@ -121,6 +124,7 @@ import { ConsolidationRunCoordinator } from "./orchestration/consolidation-run.j
 import { ExtractionPersistCoordinator } from "./orchestration/extraction-persist.js";
 import { RecallInternalCoordinator } from "./orchestration/recall-internal.js";
 import { RecallSearchPipelineCoordinator } from "./orchestration/recall-search-pipeline.js";
+import type { GraphRecallExpansionOptions, GraphRecallExpansionResult } from "./orchestration/graph-recall-seam.js";
 import type { ArtifactRecallOptions } from "./orchestration/recall-search-prefilter.js";
 import type { CorpusReadOptions } from "./corpus-read-cancellation.js";
 import { TurnIngestionCoordinator, type TurnIngestionOptions } from "./orchestration/turn-ingestion.js";
@@ -845,8 +849,8 @@ export class Orchestrator {
         routeEngineOptions: () => this.routeEngineOptions(),
         semanticDedupLookup: (content, limit, targetStorage) =>
           this.semanticDedupLookup(content, limit, targetStorage),
-        checkForContradiction: (content, category, namespaceScope) =>
-          this.checkForContradiction(content, category, namespaceScope),
+        checkForContradiction: (content, category, namespaceScope, anchor) =>
+          this.checkForContradiction(content, category, namespaceScope, anchor),
         applyDeferredContradictionResolve: (contradiction, storage, newMemoryId, postWriteGuard) =>
           this.applyDeferredContradictionResolve(contradiction, storage, newMemoryId, postWriteGuard),
         suggestLinksForMemory: (content, category, namespaceScope) =>
@@ -2550,22 +2554,14 @@ export class Orchestrator {
   }
 
   // Issue #1526 (seam 14): graph-recall expansion moved to
-  // GraphRecallCoordinator. Thin delegation keeps the private API stable
-  // for callers (recallInternal, cold-fallback pipeline) + tests.
-  private async expandResultsViaGraph(options: {
-    memoryResults: QmdSearchResult[];
-    recallNamespaces: string[];
-    recallResultLimit: number;
-    deadlineAtMs?: number | null;
-    includeLowConfidence?: boolean;
-  }): Promise<{
-    merged: QmdSearchResult[];
-    seedPaths: string[];
-    expandedPaths: GraphRecallExpandedEntry[];
-    seedResults: QmdSearchResult[];
-  }> {
+  // GraphRecallCoordinator. Keep this public seam so callers and tests can
+  // override graph expansion on the orchestrator instance.
+  async expandResultsViaGraph(
+    options: GraphRecallExpansionOptions,
+  ): Promise<GraphRecallExpansionResult> {
     return this.graphRecallCoordinator.expandResultsViaGraph(options);
   }
+
   private async recordLastGraphRecallSnapshot(options: {
     storage: StorageManager;
     prompt: string;
@@ -3875,6 +3871,10 @@ export class Orchestrator {
     content: string,
     category: string,
     namespaceScope: string,
+    anchor?: {
+      entityRef?: string;
+      structuredAttributes?: Record<string, string>;
+    },
   ): Promise<{
     supersededId: string;
     confidence: number;
@@ -3887,6 +3887,7 @@ export class Orchestrator {
       content,
       category,
       namespaceScope,
+      anchor,
     );
   }
 
@@ -3909,7 +3910,7 @@ export class Orchestrator {
     storage: StorageManager,
     newMemoryId: string,
     postWriteGuard: boolean,
-  ): Promise<void> {
+  ): Promise<ContradictionResolveOutcome> {
     return this.contradictionLinkingCoordinator.applyDeferredContradictionResolve(
       contradiction,
       storage,

package/src/recall-state.test.ts

@@ -4,7 +4,7 @@ import { chmod, lstat, mkdir, mkdtemp, readFile, readdir, rm, stat, symlink, wri
 import os from "node:os";
 import path from "node:path";
 
-import { LastRecallStore } from "./recall-state.js";
+import { clampGraphRecallExpandedEntries, LastRecallStore } from "./recall-state.js";
 import type { RecallTierExplain } from "./types.js";
 import { listContainedSpillFiles } from "./utils/path-containment.js";
 
@@ -15,6 +15,34 @@ async function freshStore() {
   return { store, dir };
 }
 
+
+test("clampGraphRecallExpandedEntries caps path provenance and preserves legacy omission", () => {
+  const pathNodeIds = Array.from({ length: 80 }, (_, index) => `node-${index}`);
+  const [current, legacy] = clampGraphRecallExpandedEntries([
+    {
+      path: "current.md",
+      score: 1,
+      namespace: "default",
+      seed: "seed",
+      hopDepth: 1,
+      decayedWeight: 1,
+      graphType: "entity",
+      pathNodeIds,
+    },
+    {
+      path: "legacy.md",
+      score: 1,
+      namespace: "default",
+      seed: "seed",
+      hopDepth: 1,
+      decayedWeight: 1,
+      graphType: "entity",
+    },
+  ]);
+  assert.equal(current?.pathNodeIds?.length, 64);
+  assert.deepEqual(current?.pathNodeIds, pathNodeIds.slice(0, 64));
+  assert.equal("pathNodeIds" in (legacy ?? {}), false);
+});
 // ── Tier-explain field is optional and absent by default ───────────────────
 
 test("LastRecallStore.record omits tierExplain when caller did not provide it", async () => {

package/src/recall-state.ts

@@ -93,6 +93,10 @@ export interface GraphRecallExpandedEntry {
    * round-trip through `clampGraphRecallExpandedEntries` without dropping.
    */
   edgeConfidence?: number;
+  /** Graph-relative activation path node ids when provenance is enabled. */
+  pathNodeIds?: string[];
+  /** True when a graph path penalty was applied. */
+  pathPenaltyApplied?: boolean;
 }
 
 export function clampGraphRecallExpandedEntries(
@@ -132,6 +136,15 @@ export function clampGraphRecallExpandedEntries(
       ) {
         out.edgeConfidence = Math.min(1, Math.max(0, item.edgeConfidence));
       }
+      if (
+        Array.isArray(item.pathNodeIds) &&
+        item.pathNodeIds.every((value): value is string => typeof value === "string")
+      ) {
+        out.pathNodeIds = item.pathNodeIds.slice(0, 64);
+      }
+      if (typeof item.pathPenaltyApplied === "boolean") {
+        out.pathPenaltyApplied = item.pathPenaltyApplied;
+      }
       return out;
     })
     .filter((item) => item.path.length > 0 && item.namespace.length > 0)

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

@@ -191,6 +191,51 @@ test("renderXrayText matches golden output for a full snapshot", () => {
   assert.equal(out, expected);
 });
 
+test("renderers omit disabled graph path penalty and node fields", () => {
+  const snap = fullSnapshot();
+  const text = renderXrayText(snap);
+  const markdown = renderXrayMarkdown(snap);
+  assert.ok(text.includes("graph-path: mem-root -> mem-1"));
+  assert.ok(markdown.includes("**Graph path:** `mem-root` → `mem-1`"));
+  for (const output of [text, markdown]) {
+    assert.equal(output.includes("path-penalty"), false);
+    assert.equal(output.includes("path-node-ids"), false);
+    assert.equal(output.includes("Path penalty"), false);
+    assert.equal(output.includes("Path node ids"), false);
+  }
+});
+
+test("renderers emit path provenance fields when enabled", () => {
+  const snap = fullSnapshot();
+  const withPathProvenance: RecallXraySnapshot = {
+    ...snap,
+    results: [
+      {
+        ...snap.results[0],
+        pathPenaltyApplied: true,
+        pathNodeIds: ["activation-root", "activation-mid", "mem-1"],
+      },
+      ...snap.results.slice(1),
+    ],
+  };
+
+  const text = renderXrayText(withPathProvenance);
+  assert.ok(text.includes("    path-penalty: yes"));
+  assert.ok(
+    text.includes(
+      "    path-node-ids: activation-root -> activation-mid -> mem-1",
+    ),
+  );
+
+  const markdown = renderXrayMarkdown(withPathProvenance);
+  assert.ok(markdown.includes("- **Path penalty applied:** `yes`"));
+  assert.ok(
+    markdown.includes(
+      "- **Path node ids:** `activation-root` → `activation-mid` → `mem-1`",
+    ),
+  );
+});
+
 test("renderXrayText handles the minimal/empty case", () => {
   const out = renderXrayText(minimalSnapshot());
   const expected = [

package/src/recall-xray-renderer.ts

@@ -203,6 +203,12 @@ function renderResultTextLines(
       );
     }
   }
+  if (result.pathPenaltyApplied !== undefined) {
+    lines.push(`    path-penalty: ${result.pathPenaltyApplied ? "yes" : "no"}`);
+  }
+  if (result.pathNodeIds && result.pathNodeIds.length > 0) {
+    lines.push(`    path-node-ids: ${result.pathNodeIds.join(" -> ")}`);
+  }
   if (result.auditEntryId) {
     lines.push(`    audit-entry: ${result.auditEntryId}`);
   }
@@ -414,6 +420,16 @@ function renderResultMarkdownLines(
       );
     }
   }
+  if (result.pathPenaltyApplied !== undefined) {
+    lines.push(
+      `- **Path penalty applied:** ${mdInlineCode(result.pathPenaltyApplied ? "yes" : "no")}`,
+    );
+  }
+  if (result.pathNodeIds && result.pathNodeIds.length > 0) {
+    lines.push(
+      `- **Path node ids:** ${result.pathNodeIds.map(mdInlineCode).join(" → ")}`,
+    );
+  }
   if (result.auditEntryId) {
     lines.push(`- **Audit entry:** \`${result.auditEntryId}\``);
   }

package/src/recall-xray.ts

@@ -130,6 +130,10 @@ export interface RecallXrayResult {
    * empty or absent so legacy snapshots round-trip cleanly.
    */
   graphEdgeConfidences?: number[];
+  /** Graph activation node ids recorded for path-scoring provenance. */
+  pathNodeIds?: string[];
+  /** True when a graph path penalty was applied. */
+  pathPenaltyApplied?: boolean;
   auditEntryId?: string;
   /** Human-readable list of filters the candidate *passed*. */
   admittedBy: string[];
@@ -518,6 +522,13 @@ function cloneResult(result: RecallXrayResult): RecallXrayResult {
       }
     }
   }
+  const pathNodeIds = Array.isArray(result.pathNodeIds)
+    ? result.pathNodeIds.filter((x): x is string => typeof x === "string")
+    : undefined;
+  const pathPenaltyApplied =
+    typeof result.pathPenaltyApplied === "boolean"
+      ? result.pathPenaltyApplied
+      : undefined;
   const auditEntryId = nonEmptyString(result.auditEntryId);
   const rejectedBy = nonEmptyString(result.rejectedBy);
   const scoreDecomposition = cloneScoreDecomposition(result.scoreDecomposition);
@@ -532,6 +543,8 @@ function cloneResult(result: RecallXrayResult): RecallXrayResult {
   if (graphEdgeConfidences !== undefined) {
     out.graphEdgeConfidences = graphEdgeConfidences;
   }
+  if (pathNodeIds !== undefined) out.pathNodeIds = pathNodeIds;
+  if (pathPenaltyApplied !== undefined) out.pathPenaltyApplied = pathPenaltyApplied;
   if (auditEntryId !== undefined) out.auditEntryId = auditEntryId;
   if (rejectedBy !== undefined) out.rejectedBy = rejectedBy;
   // Disclosure + token telemetry (issue #677 PR 3/4).  Only attach when

package/src/storage/supersession-side-effects.ts

@@ -0,0 +1,97 @@
+import {
+  buildRetiredFactTombstoneInputs,
+  type TombstoneCreatedBy,
+  type TombstoneReason,
+} from "../lifecycle/tombstones.js";
+import { supersessionKeysForFact } from "../temporal-supersession.js";
+import { stripCitationForTemplate } from "../source-attribution.js";
+import type { MemoryFile, MemoryFrontmatter } from "../types.js";
+import { composeMemoryEnvelope, type SealedMemoryEnvelope } from "../write-envelope.js";
+import { log } from "../logger.js";
+
+type TombstoneInput = {
+  reason: TombstoneReason;
+  createdBy: TombstoneCreatedBy;
+  sourceMemoryId: string;
+  rawContent: string;
+  entityRef?: string;
+  supersessionKey?: string;
+  createdAt?: string;
+  contentHash?: string;
+};
+
+export interface SupersessionSideEffectOptions {
+  oldMemoryId: string;
+  newMemoryId: string;
+  reason: string;
+  now: string;
+  currentBefore: MemoryFile;
+  updatedFm: MemoryFrontmatter;
+  citationTemplate: string;
+  isColdOrArchiveTierPath: (memoryPath: string) => boolean;
+  invalidateColdMemoriesCache: () => void;
+  bumpMemoryCorpusVersion: () => void;
+  appendLifecycleEvent: () => Promise<void>;
+  bumpMemoryStatusVersion: () => void;
+  appendTombstone: (input: TombstoneInput) => Promise<string | null>;
+  writeSealedMemory: (envelope: SealedMemoryEnvelope, extras: { lineage: [string, string] }) => Promise<unknown>;
+}
+
+export async function runSupersessionSideEffects(options: SupersessionSideEffectOptions): Promise<void> {
+  const {
+    oldMemoryId,
+    newMemoryId,
+    reason,
+    now,
+    currentBefore,
+    updatedFm,
+    citationTemplate,
+    isColdOrArchiveTierPath,
+    invalidateColdMemoriesCache,
+    bumpMemoryCorpusVersion,
+    appendLifecycleEvent,
+    bumpMemoryStatusVersion,
+    appendTombstone,
+    writeSealedMemory,
+  } = options;
+  try {
+    if (isColdOrArchiveTierPath(currentBefore.path)) invalidateColdMemoriesCache();
+    bumpMemoryCorpusVersion();
+    await appendLifecycleEvent();
+    bumpMemoryStatusVersion();
+    log.debug(`superseded memory ${oldMemoryId} by ${newMemoryId}: ${reason}`);
+
+    if (currentBefore.frontmatter.category === "fact") {
+      for (const input of buildRetiredFactTombstoneInputs(
+        {
+          id: oldMemoryId,
+          content: stripCitationForTemplate(currentBefore.content, citationTemplate),
+          contentHash: currentBefore.frontmatter.contentHash,
+          entityRef: updatedFm.entityRef,
+          structuredAttributes: currentBefore.frontmatter.structuredAttributes,
+        },
+        {
+          reason: "contradiction_resolution",
+          createdBy: "contradiction_resolution",
+          createdAt: now,
+          supersessionKeysForFact,
+        },
+      )) {
+        await appendTombstone(input);
+      }
+    }
+
+    const auditEnvelope = composeMemoryEnvelope(
+      {
+        content: `Superseded: ${currentBefore.content}\n\nReason: ${reason}`,
+        category: "correction",
+        confidence: 1.0,
+        tags: ["supersession", "auto-resolved"],
+      },
+      { source: "contradiction-detection" },
+    );
+    await writeSealedMemory(auditEnvelope, { lineage: [oldMemoryId, newMemoryId] });
+  } catch (err) {
+    log.error(`failed to supersede memory ${oldMemoryId}:`, err);
+  }
+}

package/src/storage/tombstone-blocked-capture-sync.ts

@@ -10,6 +10,7 @@ import { isErrnoCode } from "../utils/errno.js";
 import { pathMayCarryEntityRefs, requestEntityCanonicalIdReconcile } from "./entity-canonical-id-references.js";
 import { withRawEntityPageMutation } from "./entity-canonical-id-lock.js";
 import { readMaybeEncryptedFileFromChunks, writeMaybeEncryptedFileFromChunks } from "../secure-store/secure-fs.js";
+import * as archiveMutation from "../archive-mutation-version.js";
 import {
   buildExplicitCaptureDedupKey,
   buildCapturePathLockIdentity,
@@ -455,7 +456,11 @@ export abstract class TombstoneBlockedCaptureIndexHost {
       : before.content === incoming.content && isDeepStrictEqual(before.frontmatter, incoming.frontmatter);
   }
 
-  private async invalidateAfterOfflineSyncMutation(filePath: string, ownedMarker?: string): Promise<void> {
+  private async invalidateAfterOfflineSyncMutation(
+    filePath: string,
+    ownedMarker?: string,
+    archiveChanged = true
+  ): Promise<void> {
     this.invalidateAllMemoriesCache();
     this.invalidateKnowledgeIndexCache();
     this.markFactHashIndexNotAuthoritative();
@@ -466,6 +471,8 @@ export abstract class TombstoneBlockedCaptureIndexHost {
     if (filePath.includes(`${path.sep}artifacts${path.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
+    const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
+    archiveMutation.bumpArchiveMutationForPath(memoryDir, archiveChanged, filePath);
     this.bumpMemoryStatusVersion();
   }
 
@@ -571,6 +578,7 @@ export abstract class TombstoneBlockedCaptureIndexHost {
         markDurable();
         deleted = current;
         const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
+        archiveMutation.bumpArchiveMutationForPath(memoryDir, true, current.path);
         markProjectedMemoryPathInvalid(memoryDir, current.frontmatter.id);
         this.invalidateAllMemoriesCache();
         if (current.path.includes(`${path.sep}cold${path.sep}`)) {
@@ -590,7 +598,7 @@ export abstract class TombstoneBlockedCaptureIndexHost {
   protected async runTombstoneBlockedOfflineSyncMutation(
     target: string,
     after: MemoryFile | null,
-    write: () => Promise<void>,
+    write: () => Promise<boolean | void>,
     coordinate = false,
     streamedIdentity?: StreamedOfflineSyncIdentity
   ): Promise<void> {
@@ -626,7 +634,7 @@ export abstract class TombstoneBlockedCaptureIndexHost {
         const marker = affectsBlockedIndex ? await this.getTombstoneBlockedCaptureIndex().prepareWrite() : undefined;
         let durable = false;
         try {
-          await write();
+          const changed = await write();
           durable = true;
           if (marker) {
             try {
@@ -636,7 +644,7 @@ export abstract class TombstoneBlockedCaptureIndexHost {
               log.warn(`storage.offlineSyncFile committed write marker failed: ${err}`);
             }
           }
-          await this.invalidateAfterOfflineSyncMutation(target, marker);
+          await this.invalidateAfterOfflineSyncMutation(target, marker, changed !== false);
         } catch (err) {
           if (marker && !durable) {
             try {
@@ -901,7 +909,7 @@ export abstract class TombstoneBlockedCaptureIndexHost {
     const stateDir = this.tombstoneBlockedCaptureIndexOptions().stateDir;
     await withRawEntityPageMutation(path.dirname(stateDir), target, async () => {
       await this.runTombstoneBlockedOfflineSyncMutation(target, null, async () => {
-        await this.deleteManagedStorageFile(target, deletionMtimeMs);
+        return await this.deleteManagedStorageFile(target, deletionMtimeMs);
       });
     });
   }