@remnic/core 9.69.22 → 9.69.24

package/src/dedup/merge.test.ts

@@ -0,0 +1,3542 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile, chmod } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { test, mock } from "node:test";
+import { parseConfig } from "../config.js";
+import { createVersion, listVersions, type VersionTrigger } from "../page-versioning.js";
+import { inferIntentFromText } from "../intent.js";
+import {
+  applySemanticMergeAtPersist,
+  runMergedTargetPostEffects,
+  type ApplySemanticMergeOptions,
+} from "../orchestration/semantic-merge-persist.js";
+import { buildMergedTargetPromotionPayload } from "../orchestration/semantic-merge-promotion-payload.js";
+import { appendEdge, GraphIndex, type GraphEdge } from "../graph.js";
+import { PersistenceIndexCoordinator } from "../orchestration/persistence-index.js";
+import { createBatchPromotedCopyProbe, promotionWithholdsToolScope } from "../orchestration/extraction-persist-promotion.js";
+import { persistMergedTargetThreadEpisode, persistRepairedContentHash } from "../orchestration/semantic-merge-commit-effects.js";
+import { ThreadingManager } from "../threading.js";
+import { withholdToolScopedFromSharedNamespace } from "../tool-scoped-memory.js";
+import type { ExtractionPersistDeps } from "../orchestration/extraction-persist-deps.js";
+import { StorageManager } from "../index.js";
+import { sanitizeMemoryContent } from "../sanitize.js";
+import { ContentHashIndex } from "../storage/content-hash-index.js";
+import { initLogger, resetLogger, type LoggerBackend } from "../logger.js";
+import {
+  DEFAULT_UNTRUSTED_ORIGINS,
+  renderAuthorityFence,
+} from "../security/origin-authority.js";
+import { renderAuthorityBoundContent } from "../recall-context-composition.js";
+import type {
+  MemoryFile,
+  MemoryFrontmatter,
+  MemoryStatus,
+  MemorySubject,
+  ProvenanceSource,
+  PluginConfig,
+} from "../types.js";
+import { confidenceTier } from "../types.js";
+import {
+  DEFAULT_SEMANTIC_MERGE_CANDIDATES,
+  DEFAULT_SEMANTIC_MERGE_MIN,
+  decideSemanticMerge,
+  MERGEABLE_MEMORY_CATEGORIES,
+  parseSemanticMergeConfig,
+  type MergeCandidate,
+  type MergeJudgeRawVerdict,
+} from "./merge.js";
+import type { SemanticDedupHit } from "./semantic.js";
+import { invalidationCommitFingerprint } from "../storage/deletion-revision-store.js";
+
+// The merge snapshot trigger must stay a literal union: a widened
+// `VersionTrigger` (e.g. annotated `readonly string[]`) would let an unknown
+// trigger compile and then fail `readManifest` at runtime.
+// @ts-expect-error "not-a-trigger" is not a VersionTrigger
+const rejectedTrigger: VersionTrigger = "not-a-trigger";
+void rejectedTrigger;
+
+// ── Fixtures (synthetic; no real paths, hosts, or memory content) ─────────────
+
+const INCOMING = "Deploys of the billing service run on Tuesdays at 09:00 UTC.";
+const EXISTING = "Billing service deploys happen on Tuesdays.";
+const MERGED = "Billing service deploys run on Tuesdays at 09:00 UTC.";
+
+const MERGE_CONFIG = {
+  enabled: true,
+  minSimilarity: 0.8,
+  maxCandidates: 3,
+  categories: ["fact", "preference"],
+  shadowMode: false,
+} as const;
+
+function hits(...scores: Array<[string, number]>): SemanticDedupHit[] {
+  return scores.map(([id, score]) => ({ id, score }));
+}
+
+function candidateResolver(
+  overrides: { category?: string; status?: string; content?: string } = {},
+) {
+  return async (memoryId: string) => ({
+    content: overrides.content ?? `${EXISTING} (${memoryId})`,
+    category: overrides.category ?? "fact",
+    status: overrides.status ?? "active",
+  });
+}
+
+const mergeJudge = async (input: {
+  candidates: readonly MergeCandidate[];
+}): Promise<MergeJudgeRawVerdict> => ({
+  decision: "merge",
+  targetId: input.candidates[0]?.memoryId ?? null,
+  mergedContent: MERGED,
+  reason: "same deploy cadence",
+});
+
+// ── Decision: band, gates, and backend-failure taxonomy ──────────────────────
+
+test("decideSemanticMerge: only the [minSimilarity, dedupThreshold) band merges", async () => {
+  for (const [score, expected] of [
+    [0.79, "create"],
+    [0.8, "merge"],
+    [0.91, "merge"],
+    [0.92, "create"],
+    [0.99, "create"],
+  ] as Array<[number, string]>) {
+    const decision = await decideSemanticMerge({
+      content: INCOMING,
+      category: "fact",
+      config: MERGE_CONFIG,
+      dedupThreshold: 0.92,
+      lookup: async () => hits(["mem-1", score]),
+      resolveCandidate: candidateResolver(),
+      judge: mergeJudge,
+    });
+    assert.equal(decision.action, expected, `score ${score}`);
+  }
+});
+
+test("decideSemanticMerge: maxCandidates=0 short-circuits before any lookup", async () => {
+  let lookups = 0;
+  const decision = await decideSemanticMerge({
+    content: INCOMING,
+    category: "fact",
+    config: { ...MERGE_CONFIG, maxCandidates: 0 },
+    dedupThreshold: 0.92,
+    lookup: async () => {
+      lookups++;
+      return hits(["mem-1", 0.85]);
+    },
+    resolveCandidate: candidateResolver(),
+    judge: mergeJudge,
+  });
+  assert.equal(lookups, 0, "0 must disable merging without touching the backend");
+  assert.deepEqual(decision, { action: "create", reason: "disabled" });
+});
+
+test("decideSemanticMerge: a lookup failure is backend_unavailable, not no_candidates", async () => {
+  const decision = await decideSemanticMerge({
+    content: INCOMING,
+    category: "fact",
+    config: MERGE_CONFIG,
+    dedupThreshold: 0.92,
+    lookup: async () => {
+      throw new Error("embedding backend down");
+    },
+    resolveCandidate: candidateResolver(),
+    judge: mergeJudge,
+  });
+  assert.deepEqual(decision, { action: "create", reason: "backend_unavailable" });
+});
+
+test("decideSemanticMerge: every non-active status is ineligible", async () => {
+  const inactive: MemoryStatus[] = [
+    "pending_review",
+    "rejected",
+    "quarantined",
+    "superseded",
+    "archived",
+    "forgotten",
+  ];
+  for (const status of inactive) {
+    const decision = await decideSemanticMerge({
+      content: INCOMING,
+      category: "fact",
+      config: MERGE_CONFIG,
+      dedupThreshold: 0.92,
+      lookup: async () => hits(["mem-1", 0.85]),
+      resolveCandidate: candidateResolver({ status }),
+      judge: mergeJudge,
+    });
+    assert.deepEqual(decision, { action: "create", reason: "no_candidates" }, status);
+  }
+});
+
+test("decideSemanticMerge: category gate and cross-category candidates create", async () => {
+  const offCategory = await decideSemanticMerge({
+    content: INCOMING,
+    category: "moment",
+    config: MERGE_CONFIG,
+    dedupThreshold: 0.92,
+    lookup: async () => hits(["mem-1", 0.85]),
+    resolveCandidate: candidateResolver(),
+    judge: mergeJudge,
+  });
+  assert.deepEqual(offCategory, { action: "create", reason: "disabled" });
+
+  const mismatched = await decideSemanticMerge({
+    content: INCOMING,
+    category: "fact",
+    config: MERGE_CONFIG,
+    dedupThreshold: 0.92,
+    lookup: async () => hits(["mem-1", 0.85]),
+    resolveCandidate: candidateResolver({ category: "preference" }),
+    judge: mergeJudge,
+  });
+  assert.deepEqual(mismatched, { action: "create", reason: "no_candidates" });
+});
+
+test("decideSemanticMerge: fabricated ids, bad content, and refusals all create", async () => {
+  const base = {
+    content: INCOMING,
+    category: "fact",
+    config: MERGE_CONFIG,
+    dedupThreshold: 0.92,
+    lookup: async () => hits(["mem-1", 0.85]),
+    resolveCandidate: candidateResolver(),
+  };
+  const cases: Array<[MergeJudgeRawVerdict, string]> = [
+    [{ decision: "merge", targetId: "mem-not-a-candidate", mergedContent: MERGED, reason: "x" }, "judge_invalid"],
+    [{ decision: "merge", targetId: "mem-1", mergedContent: "   ", reason: "x" }, "judge_invalid"],
+    [{ decision: "merge", targetId: "mem-1", mergedContent: "z".repeat(100_000), reason: "x" }, "judge_invalid"],
+    [{ decision: "contradicts", reason: "state changed" }, "judge_contradicts"],
+    [{ decision: "create", reason: "different concept" }, "judge_create"],
+  ];
+  for (const [verdict, reason] of cases) {
+    const decision = await decideSemanticMerge({ ...base, judge: async () => verdict });
+    assert.deepEqual(decision, { action: "create", reason }, reason);
+  }
+  const thrown = await decideSemanticMerge({
+    ...base,
+    judge: async () => {
+      throw new Error("timeout");
+    },
+  });
+  assert.deepEqual(thrown, { action: "create", reason: "judge_error" });
+});
+
+test("decideSemanticMerge: highest-similarity candidate wins with a stable tiebreak", async () => {
+  const seen: string[] = [];
+  const decision = await decideSemanticMerge({
+    content: INCOMING,
+    category: "fact",
+    config: MERGE_CONFIG,
+    dedupThreshold: 0.92,
+    lookup: async () => hits(["mem-b", 0.84], ["mem-c", 0.9], ["mem-a", 0.9]),
+    resolveCandidate: candidateResolver(),
+    judge: async (input) => {
+      seen.push(...input.candidates.map((c) => c.memoryId));
+      return { decision: "merge", targetId: input.candidates[0].memoryId, mergedContent: MERGED, reason: "x" };
+    },
+  });
+  assert.deepEqual(seen, ["mem-a", "mem-c", "mem-b"]);
+  assert.equal(decision.action === "merge" && decision.targetId, "mem-a");
+});
+
+// Round N+17 (A): eligible-first candidate truncation.
+test("decideSemanticMerge: ineligible hits ranked above a valid target never crowd it out", async () => {
+  // The index truncates at the requested limit, exactly like the real
+  // embedding backend. maxCandidates=1 with the raw top-of-index hits being
+  // ineligible (inactive, foreign connector, off-category): pre-fix, the
+  // fetch asked for maxCandidates hits, the filters removed them all, and
+  // the valid target ranked immediately below never reached the judge.
+  const ALL_HITS: SemanticDedupHit[] = [
+    { id: "stale-target", score: 0.9 },
+    { id: "foreign-connector-target", score: 0.89, sourceConnector: "connector-a" },
+    { id: "off-category-target", score: 0.88 },
+    { id: "valid-target", score: 0.85 },
+  ];
+  const offered: string[] = [];
+  let lookupLimit = 0;
+  const decision = await decideSemanticMerge({
+    content: INCOMING,
+    category: "fact",
+    config: { ...MERGE_CONFIG, maxCandidates: 1 },
+    dedupThreshold: 0.92,
+    lookup: async (_content, limit) => {
+      lookupLimit = limit;
+      return ALL_HITS.slice(0, limit);
+    },
+    resolveCandidate: async (memoryId) => ({
+      content: `${EXISTING} (${memoryId})`,
+      category: memoryId === "off-category-target" ? "preference" : "fact",
+      status: memoryId === "stale-target" ? "superseded" : "active",
+    }),
+    judge: async (input) => {
+      offered.push(...input.candidates.map((c) => c.memoryId));
+      return {
+        decision: "merge",
+        targetId: input.candidates[0]?.memoryId ?? null,
+        mergedContent: MERGED,
+        reason: "same deploy cadence",
+      };
+    },
+  });
+  assert.ok(lookupLimit > 1, "the fetch must overshoot maxCandidates so filtering precedes truncation");
+  assert.deepEqual(
+    offered,
+    ["valid-target"],
+    "the judge must receive the first ELIGIBLE neighbor, not the raw top-of-index hit",
+  );
+  assert.equal(decision.action, "merge");
+  assert.equal(decision.action === "merge" && decision.targetId, "valid-target");
+});
+
+// ── Config parsing ───────────────────────────────────────────────────────────
+
+test("parseSemanticMergeConfig: defaults are off with a valid band", () => {
+  const { semanticMerge } = parseConfig({});
+  assert.equal(semanticMerge.enabled, false);
+  assert.equal(semanticMerge.minSimilarity, DEFAULT_SEMANTIC_MERGE_MIN);
+  assert.equal(semanticMerge.maxCandidates, DEFAULT_SEMANTIC_MERGE_CANDIDATES);
+  assert.equal(semanticMerge.shadowMode, false);
+  assert.deepEqual(semanticMerge.categories, [
+    "fact",
+    "preference",
+    "decision",
+    "relationship",
+    "skill",
+  ]);
+});
+
+test("parseSemanticMergeConfig: CLI strings coerce, and 0 stays 0", () => {
+  const { semanticMerge } = parseSemanticMergeConfig({
+    semanticMerge: { enabled: "false", shadowMode: "true", maxCandidates: "0" },
+  });
+  assert.equal(semanticMerge.enabled, false);
+  assert.equal(semanticMerge.shadowMode, true);
+  assert.equal(semanticMerge.maxCandidates, 0);
+  const enabled = parseSemanticMergeConfig({ semanticMerge: { enabled: "1" } });
+  assert.equal(enabled.semanticMerge.enabled, true);
+});
+
+test("parseSemanticMergeConfig: an empty or inverted band is rejected", () => {
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { minSimilarity: 0.92 } }),
+    /strictly below semanticDedupThreshold/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { minSimilarity: 0.95 }, semanticDedupThreshold: 0.9 }),
+    /strictly below semanticDedupThreshold/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { enabled: "sometimes" } }),
+    /semanticMerge.enabled must be a boolean/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { maxCandidates: -1 } }),
+    /maxCandidates must be an integer/,
+  );
+});
+
+test("parseSemanticMergeConfig: non-integer maxCandidates is rejected, not floored", () => {
+  for (const bad of [0.5, 3.7, "2.5"]) {
+    assert.throws(
+      () => parseSemanticMergeConfig({ semanticMerge: { maxCandidates: bad } }),
+      /maxCandidates must be an integer/,
+      String(bad),
+    );
+  }
+  // 0 stays the documented disable value, CLI string form included.
+  assert.equal(
+    parseSemanticMergeConfig({ semanticMerge: { maxCandidates: 0 } }).semanticMerge.maxCandidates,
+    0,
+  );
+  assert.equal(
+    parseSemanticMergeConfig({ semanticMerge: { maxCandidates: "0" } }).semanticMerge.maxCandidates,
+    0,
+  );
+});
+// #2330 round N+8 (P2-D, checklist #46): presence is OWN-property presence.
+// A composed programmatic config can carry `semanticMerge: { enabled: undefined }`
+// — present-but-invalid — and an object built with Object.create can satisfy a
+// bracket read through its prototype. Both must be told apart from an absent
+// key: absent defaults, present-but-invalid throws, inherited never applies.
+test("parseSemanticMergeConfig: present-but-undefined keys throw instead of silently defaulting (P2-D)", () => {
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { enabled: undefined } }),
+    /semanticMerge\.enabled/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { shadowMode: undefined } }),
+    /semanticMerge\.shadowMode/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { maxCandidates: undefined } }),
+    /maxCandidates/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { minSimilarity: undefined } }),
+    /minScore/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { categories: undefined } }),
+    /categories must be an array/,
+  );
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: undefined }),
+    /semanticMerge must be an object/,
+  );
+});
+
+test("parseSemanticMergeConfig: inherited keys are ignored — own-property presence decides (P2-D)", () => {
+  const inheritedFields = parseSemanticMergeConfig({
+    semanticMerge: Object.create({
+      enabled: true,
+      shadowMode: true,
+      maxCandidates: 9,
+      minSimilarity: 0.9,
+      categories: ["fact"],
+    }),
+  });
+  assert.equal(inheritedFields.semanticMerge.enabled, false);
+  assert.equal(inheritedFields.semanticMerge.shadowMode, false);
+  assert.equal(
+    inheritedFields.semanticMerge.maxCandidates,
+    DEFAULT_SEMANTIC_MERGE_CANDIDATES,
+  );
+  assert.equal(inheritedFields.semanticMerge.minSimilarity, DEFAULT_SEMANTIC_MERGE_MIN);
+  assert.deepEqual(inheritedFields.semanticMerge.categories, [
+    "fact",
+    "preference",
+    "decision",
+    "relationship",
+    "skill",
+  ]);
+  // An inherited semanticMerge BLOCK on the config object is equally absent.
+  const inheritedBlock = parseSemanticMergeConfig(
+    Object.create({ semanticMerge: { enabled: true } }) as Record<string, unknown>,
+  );
+  assert.equal(inheritedBlock.semanticMerge.enabled, false);
+});
+
+test("parseSemanticMergeConfig: a present non-object block is rejected; only absent means defaults", () => {
+  for (const bad of [true, "enabled", null, 1, ["fact"]]) {
+    assert.throws(
+      () => parseSemanticMergeConfig({ semanticMerge: bad }),
+      /semanticMerge must be an object/,
+      JSON.stringify(bad),
+    );
+  }
+  const defaults = parseSemanticMergeConfig({});
+  assert.equal(defaults.semanticMerge.enabled, false);
+  assert.equal(defaults.semanticMerge.maxCandidates, DEFAULT_SEMANTIC_MERGE_CANDIDATES);
+});
+
+test("parseSemanticMergeConfig: malformed categories are rejected, not silently defaulted", () => {
+  for (const bad of ["fact", ["fact", 7], ["fact", ""], {}]) {
+    assert.throws(
+      () => parseSemanticMergeConfig({ semanticMerge: { categories: bad } }),
+      /categories must be an array/,
+      JSON.stringify(bad),
+    );
+  }
+  assert.deepEqual(
+    parseSemanticMergeConfig({ semanticMerge: { categories: ["preference"] } }).semanticMerge
+      .categories,
+    ["preference"],
+  );
+});
+
+// ── Persistence ──────────────────────────────────────────────────────────────
+
+interface MergeHarness {
+  deps: ExtractionPersistDeps;
+  storage: StorageManager;
+  target: MemoryFile;
+  /** Simulate another writer committing a new body to the target. */
+  setTargetContent: (content: string) => Promise<void>;
+  calls: {
+    contentUpdates: Array<{ id: string; content: string; actor?: string }>;
+    frontmatterPatches: Array<{ id: string; patch: Partial<MemoryFrontmatter>; actor?: string }>;
+    hashRemovals: string[];
+    hashAdds: string[];
+    hashRegistrations: Array<{ id: string; hash: string }>;
+    reindexed: string[];
+    lookupStorages: string[];
+  };
+}
+
+const TARGET_SOURCE: ProvenanceSource = {
+  sessionKey: "project/example/2026-08-20T00:00:00.000Z",
+  observedAt: "2026-08-20T00:00:00.000Z",
+  quote: "deploys happen on Tuesdays",
+};
+
+const INCOMING_SOURCE: ProvenanceSource = {
+  sessionKey: "project/example/2026-08-21T00:00:00.000Z",
+  observedAt: "2026-08-21T00:00:00.000Z",
+  quote: "deploys run at 09:00 UTC",
+};
+
+async function harness(
+  overrides: {
+    config?: Partial<Record<string, unknown>>;
+    targetCategory?: string;
+    targetStatus?: MemoryStatus;
+    /** Stamp `toolScoped: true` on the target's frontmatter (finding A). */
+    targetToolScoped?: boolean;
+    /** Stamp `subject` on the target's frontmatter (finding A). */
+    targetSubject?: MemorySubject;
+    /** Stamp `origin` on the target's frontmatter (finding A). */
+    targetOrigin?: string;
+    /** Stamp `confidence`/`confidenceTier` on the target's frontmatter (final round A). */
+    targetConfidence?: number;
+    /** Stamp `provenance` on the target's frontmatter (finding B). */
+    targetProvenance?: "verified" | "unverified" | "none";
+    /** Stamp `faithfulness` on the target's frontmatter (finding C). */
+    targetFaithfulness?: { verdict: "entailed" | "contradicted" | "unsupported" | "unchecked" | "skipped_no_span" };
+    /** Stamp `sourceConnector` on the target's frontmatter (finding D). */
+    targetSourceConnector?: string;
+    /** Stamp `valid_at` on the target's frontmatter (round N+2 A). */
+    targetValidAt?: string;
+    /** Stamp `invalid_at` on the target's frontmatter (round N+2 A). */
+    targetInvalidAt?: string;
+    /** Stamp `memoryKind` on the target's frontmatter (round N+2 B). */
+    targetMemoryKind?: MemoryFrontmatter["memoryKind"];
+    /** Stamp stale intent routing fields on the target's frontmatter (round N+3 A). */
+    targetIntent?: { goal: string; actionType: string; entityTypes: string[] };
+    /** Top-level parseConfig overrides (citation enablement, round N+2 C). */
+    topLevelConfig?: Record<string, unknown>;
+    lookupHits?: SemanticDedupHit[];
+    mutateOnWrite?: string;
+    /**
+     * Simulate a concurrent writer replacing the target between the content
+     * commit and the provenance patch — the window the id-keyed patch left
+     * open.
+     */
+    mutateAtPatch?: string;
+    /** Force the frontmatter patch to fail after the content update commits. */
+    frontmatterFails?: boolean;
+    /** Force the automatic rollback of that committed content to fail. */
+    rollbackFails?: boolean;
+  } = {},
+): Promise<MergeHarness> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-"));
+  const factsDir = path.join(dir, "facts", "2026-08-20");
+  await mkdir(factsDir, { recursive: true });
+  const targetPath = path.join(factsDir, "fact-target.md");
+  const targetCategory = overrides.targetCategory ?? "fact";
+  const frontmatter = {
+    id: "fact-target",
+    category: targetCategory,
+    ...(overrides.targetStatus ? { status: overrides.targetStatus } : {}),
+    ...(overrides.targetToolScoped ? { toolScoped: true as const } : {}),
+    ...(overrides.targetSubject ? { subject: overrides.targetSubject } : {}),
+    ...(overrides.targetOrigin ? { origin: overrides.targetOrigin } : {}),
+    ...(overrides.targetProvenance ? { provenance: overrides.targetProvenance } : {}),
+    ...(overrides.targetConfidence !== undefined
+      ? {
+          confidence: overrides.targetConfidence,
+          confidenceTier: confidenceTier(overrides.targetConfidence),
+        }
+      : {}),
+    ...(overrides.targetFaithfulness ? { faithfulness: overrides.targetFaithfulness } : {}),
+    ...(overrides.targetSourceConnector ? { sourceConnector: overrides.targetSourceConnector } : {}),
+    ...(overrides.targetValidAt ? { valid_at: overrides.targetValidAt } : {}),
+    ...(overrides.targetInvalidAt ? { invalid_at: overrides.targetInvalidAt } : {}),
+    ...(overrides.targetMemoryKind ? { memoryKind: overrides.targetMemoryKind } : {}),
+    ...(overrides.targetIntent
+      ? {
+          intentGoal: overrides.targetIntent.goal,
+          intentActionType: overrides.targetIntent.actionType,
+          intentEntityTypes: overrides.targetIntent.entityTypes,
+        }
+      : {}),
+    sources: [TARGET_SOURCE],
+  } as unknown as MemoryFrontmatter;
+  await writeFile(targetPath, `---\nid: fact-target\ncategory: fact\n---\n\n${EXISTING}\n`, "utf8");
+  const target: MemoryFile = { path: targetPath, frontmatter, content: EXISTING };
+  // Live state: the CAS compares against what is on disk NOW, so a stub that
+  // returned the original snapshot forever could never fail a compare.
+  let state: MemoryFile = { ...target };
+
+  const calls: MergeHarness["calls"] = {
+    contentUpdates: [],
+    frontmatterPatches: [],
+    hashRemovals: [],
+    hashAdds: [],
+    hashRegistrations: [],
+    reindexed: [],
+    lookupStorages: [],
+  };
+  const commit = async (content: string): Promise<void> => {
+    state = { ...state, content };
+    await writeFile(targetPath, `---\nid: fact-target\ncategory: fact\n---\n\n${content}\n`, "utf8");
+  };
+  // Live state: reads come off the file, so a stub can neither invent a
+  // restore that never touched storage nor compare a snapshot against itself.
+  const read = async (): Promise<MemoryFile> => {
+    const raw = await readFile(targetPath, "utf8");
+    const body = raw.slice(raw.indexOf("---", 3) + 4).trim();
+    return { path: targetPath, frontmatter: state.frontmatter, content: body };
+  };
+  const unchanged = async (expected: MemoryFile): Promise<boolean> => {
+    const current = await read();
+    // The production compare, not a content-only approximation (checklist #21).
+    return invalidationCommitFingerprint(current) === invalidationCommitFingerprint(expected);
+  };
+  const storage = {
+    dir,
+    getMemoryByIdIncludingArchived: async (id: string) =>
+      id === state.frontmatter.id ? await read() : null,
+    readMemoryByPath: async (p: string) => (p === targetPath ? await read() : null),
+    // The id-keyed APIs: they re-read and overwrite/stamp whatever is there
+    // now. Present so that a revert to either unsafe call fails on the
+    // assertions below rather than on a missing stub method.
+    updateMemory: async (id: string, content: string, options?: { actor?: string }) => {
+      if (id !== state.frontmatter.id) return false;
+      if (overrides.mutateOnWrite !== undefined && options?.actor === "semantic-merge") {
+        await commit(overrides.mutateOnWrite);
+      }
+      calls.contentUpdates.push({ id, content, actor: options?.actor });
+      await commit(content);
+      return true;
+    },
+    updateMemoryFrontmatter: async (id: string, patch: Partial<MemoryFrontmatter>) => {
+      calls.frontmatterPatches.push({ id, patch });
+      return overrides.frontmatterFails !== true;
+    },
+    // Signature-faithful to StorageManager.updateMemoryIfUnchanged: the
+    // compare is on the caller's snapshot, not on the id.
+    updateMemoryIfUnchanged: async (
+      expected: MemoryFile,
+      content: string,
+      options?: { actor?: string },
+    ) => {
+      if (overrides.rollbackFails && options?.actor === "semantic-merge-rollback") return false;
+      if (overrides.mutateOnWrite !== undefined && options?.actor === "semantic-merge") {
+        await commit(overrides.mutateOnWrite);
+      }
+      if (!(await unchanged(expected))) return false;
+      calls.contentUpdates.push({ id: expected.frontmatter.id, content, actor: options?.actor });
+      await commit(content);
+      return true;
+    },
+    // Signature-faithful to StorageManager.writeMemoryFrontmatterIfUnchanged.
+    writeMemoryFrontmatterIfUnchanged: async (
+      expected: MemoryFile,
+      patch: Partial<MemoryFrontmatter>,
+      options?: { actor?: string },
+    ) => {
+      // A concurrent writer inside the patch window: after the caller's
+      // verifying read, before storage takes its own lock.
+      if (overrides.mutateAtPatch !== undefined) await commit(overrides.mutateAtPatch);
+      if (!(await unchanged(expected))) return false;
+      calls.frontmatterPatches.push({ id: expected.frontmatter.id, patch, actor: options?.actor });
+      return overrides.frontmatterFails !== true;
+    },
+    removeFactContentHashesForMemories: async (memories: MemoryFile[]) => {
+      calls.hashRemovals.push(...memories.map((m) => m.content));
+    },
+    restoreFactHashAfterApproval: async (id: string) => {
+      calls.hashAdds.push(id);
+    },
+    registerFactContentHash: async (id: string, hash: string, _expectedContent: string) => {
+      calls.hashRegistrations.push({ id, hash });
+    },
+  } as unknown as StorageManager;
+
+  const config = parseConfig({
+    memoryDir: dir,
+    versioningEnabled: true,
+    ...(overrides.topLevelConfig ?? {}),
+    semanticMerge: { enabled: true, ...(overrides.config ?? {}) },
+  }) as PluginConfig;
+
+  const deps = {
+    config,
+    getLocalLlm: () => null,
+    semanticDedupLookup: async (_content: string, _limit: number, targetStorage: StorageManager) => {
+      calls.lookupStorages.push(targetStorage.dir);
+      return overrides.lookupHits ?? hits(["fact-target", 0.85]);
+    },
+    indexPersistedMemory: async (_storage: StorageManager, memoryId: string) => {
+      calls.reindexed.push(memoryId);
+    },
+  } as unknown as ExtractionPersistDeps;
+
+  return { deps, storage, target, setTargetContent: commit, calls };
+}
+
+const acceptingJudge = async (input: {
+  candidates: readonly MergeCandidate[];
+}): Promise<MergeJudgeRawVerdict> => ({
+  decision: "merge",
+  targetId: input.candidates[0]?.memoryId ?? null,
+  mergedContent: MERGED,
+  reason: "same underlying deploy cadence",
+});
+
+test("applySemanticMergeAtPersist: merges in place with snapshot, provenance, hash resync, and reindex", async () => {
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+
+  assert.deepEqual(outcome, { action: "merged", targetId: "fact-target", mergedContent: MERGED, provenancePatched: true });
+  // Same id, same file path — an update, never a new fragment.
+  assert.deepEqual(h.calls.contentUpdates, [
+    { id: "fact-target", content: MERGED, actor: "semantic-merge" },
+  ]);
+  assert.equal(await readFile(h.target.path, "utf8").then((t) => t.includes(MERGED)), true);
+
+  // Rollback data exists under the dedicated trigger.
+  const history = await listVersions(h.target.path, { enabled: true, maxVersionsPerPage: 20, sidecarDir: ".versions" }, h.storage.dir);
+  assert.equal(history.versions.length, 1);
+  assert.equal(history.versions[0].trigger, "semantic-merge");
+
+  // Provenance is appended, never replaced, and the merge is stamped.
+  assert.equal(h.calls.frontmatterPatches.length, 1);
+  const patch = h.calls.frontmatterPatches[0].patch;
+  assert.equal(patch.derived_via, "merge");
+  assert.equal(patch.reinforcement_count, 1);
+  assert.equal(patch.sources?.length, 2);
+  assert.equal(patch.sources?.[1].quote, INCOMING_SOURCE.quote);
+
+  // Hash index: the pre-merge form is removed, the target re-registered.
+  assert.deepEqual(h.calls.hashRemovals, [EXISTING]);
+  assert.deepEqual(h.calls.hashAdds, ["fact-target"]);
+  assert.deepEqual(h.calls.reindexed, ["fact-target"]);
+  // Candidates come from the write's own namespace-scoped storage.
+  assert.deepEqual(h.calls.lookupStorages, [h.storage.dir]);
+});
+
+// #2330 round N+10 (B): the merge commits into a target living under
+// `cold/` and then hands the target to indexPersistedMemory for the
+// embedding-fallback refresh. PersistenceIndexCoordinator used to resolve
+// the id with the HOT-only getMemoryById, found nothing, and returned — the
+// fallback index kept serving the pre-merge text. This drives the REAL
+// coordinator against a REAL cold-tier file.
+test("applySemanticMergeAtPersist: a cold-tier target merge refreshes the embedding fallback index (round N+10 B)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-cold-idx-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    // Seed straight into cold/ at the tier layout buildTierMemoryPath uses
+    // (cold/<category>/<created-date>/<id>.md) — a long-lived merge target
+    // that was demoted to the cold tier.
+    const targetPath = path.join(dir, "cold", "facts", "2026-08-20", "fact-target.md");
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(
+      targetPath,
+      [
+        "---",
+        "id: fact-target",
+        "category: fact",
+        "created: 2026-08-20T00:00:00.000Z",
+        "updated: 2026-08-20T00:00:00.000Z",
+        "status: active",
+        "---",
+        "",
+        EXISTING,
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+    assert.ok(
+      await storage.getMemoryByIdIncludingArchived("fact-target"),
+      "the cold-tier target must resolve through the cold-aware lookup",
+    );
+    const indexed: Array<{ id: string; content: string; path: string }> = [];
+    const config = parseConfig({
+      memoryDir: dir,
+      versioningEnabled: true,
+      embeddingFallbackEnabled: true,
+      semanticMerge: { enabled: true },
+    });
+    const coordinator = new PersistenceIndexCoordinator({
+      config,
+      embeddingFallback: {
+        isAvailable: async () => true,
+        indexFile: async (id: string, content: string, p: string) => {
+          indexed.push({ id, content, path: p });
+        },
+        removeFromIndex: async () => {},
+      },
+    } as unknown as ConstructorParameters<typeof PersistenceIndexCoordinator>[0]);
+    const deps = {
+      config,
+      getLocalLlm: () => null,
+      semanticDedupLookup: async () => [{ id: "fact-target", score: 0.85 }],
+      indexPersistedMemory: (s: StorageManager, id: string) =>
+        coordinator.indexPersistedMemory(s, id),
+    } as unknown as ExtractionPersistDeps;
+
+    const outcome = await applySemanticMergeAtPersist(deps, {
+      storage,
+      content: INCOMING,
+      category: "fact",
+      sources: [INCOMING_SOURCE],
+      judgeCall: (options) => acceptingJudge(options),
+    });
+    assert.equal(outcome.action, "merged", `merge outcome: ${JSON.stringify(outcome)}`);
+
+    assert.deepEqual(
+      indexed.map((entry) => ({ id: entry.id, content: entry.content })),
+      [{ id: "fact-target", content: MERGED }],
+      `the fallback index must serve the merged text for the cold-tier target (got ${JSON.stringify(indexed)})`,
+    );
+    assert.ok(
+      indexed[0]?.path.includes(path.join("cold")),
+      `the indexed path must be the target's cold-tier location (got ${indexed[0]?.path})`,
+    );
+  } finally {
+    await StorageManager.clearAllStaticCaches();
+  }
+});
+
+test("applySemanticMergeAtPersist: intent routing recomputes intent fields from the committed merged body", async () => {
+  const h = await harness({
+    targetIntent: { goal: "close_deal", actionType: "summarize", entityTypes: ["client"] },
+    topLevelConfig: { intentRoutingEnabled: true },
+  });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  const patch = h.calls.frontmatterPatches.at(-1)?.patch;
+  assert.ok(patch, "the merge must land a conditional frontmatter patch");
+  // The recomputation the ordinary write path runs over the same body:
+  // category + tags + RAW pre-citation content of the committed record.
+  const expected = inferIntentFromText(`fact ${""} ${MERGED}`);
+  assert.equal(patch.intentGoal, expected.goal);
+  assert.equal(patch.intentActionType, expected.actionType);
+  assert.deepEqual(patch.intentEntityTypes, expected.entityTypes);
+  // Concretely: the merged body's "deploys" cue routes to release, and the
+  // target's stale client-deal routing is replaced, not retained.
+  assert.equal(patch.intentGoal, "release");
+  assert.equal(patch.intentActionType, "unknown");
+  assert.deepEqual(patch.intentEntityTypes, []);
+});
+
+test("applySemanticMergeAtPersist: intent routing off leaves intent fields untouched", async () => {
+  const h = await harness({
+    targetIntent: { goal: "close_deal", actionType: "summarize", entityTypes: ["client"] },
+  });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  const patch = h.calls.frontmatterPatches.at(-1)?.patch;
+  assert.ok(patch);
+  assert.equal("intentGoal" in patch, false);
+  assert.equal("intentActionType" in patch, false);
+  assert.equal("intentEntityTypes" in patch, false);
+});
+
+test("applySemanticMergeAtPersist: shadow mode decides but never mutates", async () => {
+  const h = await harness({ config: { shadowMode: true } });
+  const before = await readFile(h.target.path, "utf8");
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "shadow_would_merge" });
+  assert.equal(await readFile(h.target.path, "utf8"), before);
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+  const history = await listVersions(h.target.path, { enabled: true, maxVersionsPerPage: 20, sidecarDir: ".versions" }, h.storage.dir);
+  assert.deepEqual(history.versions, []);
+});
+
+test("applySemanticMergeAtPersist: disabled config runs no lookup and no judge", async () => {
+  const h = await harness({ config: { enabled: false } });
+  let judged = 0;
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: async (options) => {
+      judged++;
+      return acceptingJudge(options);
+    },
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "disabled" });
+  assert.deepEqual(h.calls.lookupStorages, []);
+  assert.equal(judged, 0);
+});
+
+test("applySemanticMergeAtPersist: an inactive target and a caller skip both create", async () => {
+  const inactive = await harness({ targetStatus: "superseded" });
+  const inactiveOutcome = await applySemanticMergeAtPersist(inactive.deps, {
+    storage: inactive.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(inactiveOutcome.action, "created");
+  assert.deepEqual(inactive.calls.contentUpdates, []);
+
+  const skipped = await harness();
+  const skippedOutcome = await applySemanticMergeAtPersist(skipped.deps, {
+    storage: skipped.storage,
+    content: INCOMING,
+    category: "fact",
+    skip: true,
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(skippedOutcome, { action: "created", reason: "disabled" });
+  assert.deepEqual(skipped.calls.lookupStorages, []);
+});
+
+test("applySemanticMergeAtPersist: versioning off refuses to merge (no rollback data)", async () => {
+  const h = await harness();
+  const noVersioning = {
+    ...h.deps,
+    config: { ...h.deps.config, versioningEnabled: false },
+  } as unknown as ExtractionPersistDeps;
+  const outcome = await applySemanticMergeAtPersist(noVersioning, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "snapshot_unavailable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+});
+
+// ── Finding 1: connector boundaries survive a merge ──────────────────────────
+
+test("decideSemanticMerge: a foreign-connector neighbor is never a merge target", async () => {
+  const base = {
+    content: INCOMING,
+    category: "fact",
+    config: MERGE_CONFIG,
+    dedupThreshold: 0.92,
+    resolveCandidate: candidateResolver(),
+    judge: mergeJudge,
+  };
+  // Connector B's fact must not rewrite connector A's memory: A's
+  // `sourceConnector` frontmatter would still name A after the merge.
+  const foreign = await decideSemanticMerge({
+    ...base,
+    sourceConnector: "connector-b",
+    lookup: async () => [{ id: "mem-a", score: 0.85, sourceConnector: "connector-a" }],
+  });
+  assert.deepEqual(foreign, { action: "create", reason: "no_candidates" });
+
+  // An unattributed neighbor is equally ineligible for a scoped candidate.
+  const unattributed = await decideSemanticMerge({
+    ...base,
+    sourceConnector: "connector-b",
+    lookup: async () => hits(["mem-operator", 0.85]),
+  });
+  assert.deepEqual(unattributed, { action: "create", reason: "no_candidates" });
+
+  // Same connector merges, and a whitespace-only scope is "unattributed".
+  const same = await decideSemanticMerge({
+    ...base,
+    sourceConnector: "connector-b",
+    lookup: async () => [{ id: "mem-b", score: 0.85, sourceConnector: "connector-b" }],
+  });
+  assert.equal(same.action, "merge");
+  // Finding B: an UNSCOPED incoming fact must not merge into a
+  // connector-owned target either — the merge would rewrite A's body while
+  // A's `sourceConnector` frontmatter still names A, so recall would label
+  // the unscoped claims as A's. Merge selection requires BOTH sides
+  // unscoped or the identical connector (stricter than the dedup gates).
+  const unscoped = await decideSemanticMerge({
+    ...base,
+    sourceConnector: "   ",
+    lookup: async () => [{ id: "mem-a", score: 0.85, sourceConnector: "connector-a" }],
+  });
+  assert.deepEqual(unscoped, { action: "create", reason: "no_candidates" });
+  const bothUnscoped = await decideSemanticMerge({
+    ...base,
+    sourceConnector: "   ",
+    lookup: async () => hits(["mem-operator", 0.85]),
+  });
+  assert.equal(bothUnscoped.action, "merge");
+});
+
+test("applySemanticMergeAtPersist: the incoming fact's connector scopes the lookup", async () => {
+  const h = await harness({
+    lookupHits: [{ id: "fact-target", score: 0.85, sourceConnector: "connector-a" }],
+  });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sourceConnector: "connector-b",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "no_candidates" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.equal(await readFile(h.target.path, "utf8").then((t) => t.includes(EXISTING)), true);
+});
+
+// ── Finding 2: the write is conditional on the judged snapshot ───────────────
+
+test("applySemanticMergeAtPersist: a target changed after judging creates, never clobbers", async () => {
+  const CONCURRENT = "Billing service deploys happen on Tuesdays, paused during freeze weeks.";
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    // Another extraction lands between the judge resolving the target body
+    // and the write. `MERGED` was composed from the older body.
+    judgeCall: async (options) => {
+      const verdict = await acceptingJudge(options);
+      await h.setTargetContent(CONCURRENT);
+      return verdict;
+    },
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "target_changed" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  // The concurrent writer's details survive verbatim.
+  const onDisk = await readFile(h.target.path, "utf8");
+  assert.equal(onDisk.includes(CONCURRENT), true);
+  assert.equal(onDisk.includes(MERGED), false);
+});
+
+test("applySemanticMergeAtPersist: a failed compare-and-swap creates instead of overwriting", async () => {
+  const RACED = "Billing service deploys happen on Tuesdays, except during a freeze.";
+  const h = await harness({ mutateOnWrite: RACED });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "target_changed" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  const onDisk = await readFile(h.target.path, "utf8");
+  assert.equal(onDisk.includes(RACED), true);
+  assert.equal(onDisk.includes(MERGED), false);
+});
+
+// ── Finding 3: a failed frontmatter patch really restores the body ───────────
+
+test("applySemanticMergeAtPersist: a failed frontmatter patch restores the pre-merge body", async () => {
+  const h = await harness({ frontmatterFails: true });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  // Reporting `created` is only honest once the target no longer holds the
+  // merged text — otherwise the caller writes a duplicate. Read the body back
+  // out of storage: a rollback that only claimed success would pass an
+  // assertion on the recorded calls alone.
+  assert.deepEqual(outcome, { action: "created", reason: "update_failed" });
+  const restored = await h.storage.getMemoryByIdIncludingArchived("fact-target");
+  assert.equal(restored?.content, EXISTING);
+  const onDisk = await readFile(h.target.path, "utf8");
+  assert.equal(onDisk.includes(EXISTING), true);
+  assert.equal(onDisk.includes(MERGED), false);
+  assert.deepEqual(h.calls.contentUpdates, [
+    { id: "fact-target", content: MERGED, actor: "semantic-merge" },
+    { id: "fact-target", content: EXISTING, actor: "semantic-merge-rollback" },
+  ]);
+  // Neither hash resync nor reindex may run for a merge that did not stand.
+  assert.deepEqual(h.calls.hashRemovals, []);
+  assert.deepEqual(h.calls.reindexed, []);
+});
+
+test("applySemanticMergeAtPersist: a writer inside the patch window keeps its body and blocks a false merge", async () => {
+  const RACED = "Billing service deploys are paused during freeze weeks.";
+  // Another writer replaces the target after the content commit and after the
+  // verifying read — the window an id-keyed frontmatter patch left open. That
+  // patch would have stamped this merge's provenance onto the other writer's
+  // body and still returned `merged`, so the caller would drop the fact.
+  const h = await harness({ mutateAtPatch: RACED });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  // Never `merged`: the merged body was overwritten, so the fact is unwritten.
+  assert.deepEqual(outcome, { action: "created", reason: "update_failed" });
+  // No provenance was attached to a body this merge never composed.
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+  // The other writer's body survives verbatim — the rollback must not treat
+  // someone else's content as its own to revert.
+  const current = await h.storage.getMemoryByIdIncludingArchived("fact-target");
+  assert.equal(current?.content, RACED);
+  assert.deepEqual(
+    h.calls.contentUpdates.map((c) => c.actor),
+    ["semantic-merge"],
+  );
+  const onDisk = await readFile(h.target.path, "utf8");
+  assert.equal(onDisk.includes(MERGED), false);
+  assert.equal(onDisk.includes(EXISTING), false);
+  assert.deepEqual(h.calls.hashRemovals, []);
+  assert.deepEqual(h.calls.reindexed, []);
+});
+
+test("applySemanticMergeAtPersist: an unrollbackable patch failure reports merged, not created", async () => {
+  const h = await harness({ frontmatterFails: true, rollbackFails: true });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  // The merged text IS in the target; claiming `created` would duplicate it.
+  assert.deepEqual(outcome, {
+    action: "merged",
+    targetId: "fact-target",
+    mergedContent: MERGED,
+    provenancePatched: false,
+  });
+  assert.equal(await readFile(h.target.path, "utf8").then((t) => t.includes(MERGED)), true);
+  // Item C — the degraded success still repairs the indexes before returning:
+  // hash resync and reindex run, so QMD and the fact-hash index do not hold
+  // the pre-merge identity until unrelated maintenance.
+  assert.deepEqual(h.calls.hashRemovals, [EXISTING]);
+  // Round N+16 (C): the degraded repair registers the COMMITTED body's hash
+  // (asserted in the N+16 C test below) instead of restoring the persisted
+  // pre-merge identity the old hash-adds route re-registered.
+  assert.deepEqual(h.calls.hashAdds, []);
+  assert.deepEqual(
+    h.calls.hashRegistrations,
+    [{ id: "fact-target", hash: ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text) }],
+  );
+  assert.deepEqual(h.calls.reindexed, ["fact-target"]);
+});
+
+// ── Round N+16 (C): the degraded repair must index what storage HOLDS. With
+// the body committed and both the frontmatter patch and its rollback failed,
+// the record holds the MERGED body under the PRE-merge `contentHash`.
+// `restoreFactHashAfterApproval` prefers that persisted value, so the repair
+// used to re-register the stale identity and exact dedup never saw the merged
+// body — a second copy of the same content could be written. ────────────────
+
+test("applySemanticMergeAtPersist: the degraded repair registers the COMMITTED body's hash, not the stale persisted one (round N+16 C)", async () => {
+  const h = await harness({ frontmatterFails: true, rollbackFails: true });
+  // The double failure leaves the frontmatter holding the PRE-merge identity.
+  const STALE = ContentHashIndex.computeHash(sanitizeMemoryContent(EXISTING).text);
+  h.target.frontmatter.contentHash = STALE;
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  assert.equal(outcome.provenancePatched, false);
+  const EXPECTED = ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text);
+  assert.notEqual(EXPECTED, STALE, "fixture sanity: merged and pre-merge bodies must differ");
+  assert.deepEqual(
+    h.calls.hashRegistrations,
+    [{ id: "fact-target", hash: EXPECTED }],
+    "the degraded repair must register the committed merged body's hash — never the stale persisted frontmatter value",
+  );
+  assert.equal(
+    h.calls.hashAdds.length,
+    0,
+    "the degraded path must not route hash restoration through the persisted-frontmatter reader",
+  );
+});
+
+test("registerFactContentHash: exact dedup finds the degraded record's merged body (round N+16 C)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-hash-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const { id } = await storage.writeMemory("fact", EXISTING, { source: "extraction" });
+    // Reproduce the degraded state the way the merge creates it: the body is
+    // compare-and-swapped to the merged text while the frontmatter keeps the
+    // old identity (updateMemoryIfUnchanged preserves contentHash).
+    const before = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id)!;
+    assert.equal(
+      await storage.updateMemoryIfUnchanged(before, MERGED, { actor: "semantic-merge" }),
+      true,
+    );
+    const degraded = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id)!;
+    const staleHash = degraded.frontmatter.contentHash;
+    const mergedHash = ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text);
+    assert.ok(staleHash, "fixture sanity: the pre-merge identity is persisted");
+    assert.notEqual(staleHash, mergedHash, "fixture sanity: the persisted identity is stale");
+    assert.equal(
+      await storage.hasFactContentHash(MERGED),
+      false,
+      "the degraded record's merged body must not already be indexed",
+    );
+    // The PRE-FIX repair: remove + restore-from-record re-registers the STALE
+    // persisted identity, so the merged body stays invisible to exact dedup.
+    await storage.removeFactContentHashesForMemories([degraded]);
+    await storage.restoreFactHashAfterApproval(id);
+    assert.equal(
+      await storage.hasFactContentHash(MERGED),
+      false,
+      "the persisted-frontmatter reader cannot find the merged body — the N+16 C bug",
+    );
+    assert.equal(await storage.hasFactContentHash(EXISTING), true, "it re-registered the stale pre-merge identity instead");
+    // The FIXED repair: register the hash of what is actually STORED.
+    await storage.removeFactContentHashesForMemories([degraded]);
+    await storage.registerFactContentHash(id, mergedHash, MERGED);
+    assert.equal(
+      await storage.hasFactContentHash(MERGED),
+      true,
+      "exact dedup must find the committed merged body's hash",
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+// ── Round N+19 (B): the degraded repair must also be DURABLE. The N+16 C
+// registration lives in the process-local fact-hash index while the record's
+// PERSISTED frontmatter still carries the stale pre-merge `contentHash` — and
+// a restart's first-use index rebuild derives hashes from the corpus, where
+// the persisted value wins whenever it disagrees with the current body. The
+// repair must therefore also restamp the persisted identity. ────────────────
+
+test("applySemanticMergeAtPersist: the degraded repair persists the committed body's hash in the frontmatter (round N+19 B)", async () => {
+  const h = await harness({ frontmatterFails: true, rollbackFails: true });
+  const STALE = ContentHashIndex.computeHash(sanitizeMemoryContent(EXISTING).text);
+  h.target.frontmatter.contentHash = STALE;
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  // The provenance patch itself failed (frontmatterFails); the repair must
+  // still attempt a CAS-guarded restamp of ONLY the content identity. The
+  // provenance patch also carries a contentHash, so identify the repair as
+  // the LAST patch — the degraded branch runs after the failed patch.
+  const EXPECTED = ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text);
+  const patches = h.calls.frontmatterPatches;
+  assert.equal(patches.length, 2, "the failed provenance patch, then the durable repair");
+  const repair = patches[1];
+  assert.deepEqual(
+    Object.keys(repair.patch),
+    ["contentHash"],
+    "the repair patch must touch only the content identity — provenance fields stay unpatched on the degraded record",
+  );
+  assert.equal(repair.patch.contentHash, EXPECTED);
+  assert.equal(repair.actor, "semantic-merge");
+});
+
+test("persistRepairedContentHash: the repaired hash survives a restart's corpus rebuild (round N+19 B)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-hash-durable-"));
+  try {
+    const storage = new StorageManager(dir);
+    const { id } = await storage.writeMemory("fact", EXISTING, { source: "extraction" });
+    // Reproduce the degraded state the way the merge creates it: the body is
+    // compare-and-swapped to the merged text while the frontmatter keeps the
+    // old identity (updateMemoryIfUnchanged preserves contentHash).
+    const before = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id)!;
+    assert.equal(await storage.updateMemoryIfUnchanged(before, MERGED, { actor: "semantic-merge" }), true);
+    const mergedHash = ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text);
+    // The N+16 C repair alone (process-local registration).
+    await storage.registerFactContentHash(id, mergedHash, MERGED);
+    // Simulated restart WITHOUT the durable repair: the fresh instance ALWAYS
+    // rebuilds the index from the durable corpus on first use, and the corpus
+    // reader prefers the stale persisted identity — the pre-fix loss this
+    // regression pins.
+    const lost = new StorageManager(dir);
+    assert.equal(
+      await lost.hasFactContentHash(MERGED),
+      false,
+      "pre-fix behavior: the process-local registration does not survive the corpus rebuild",
+    );
+    // The durable repair restamps the persisted identity (CAS-guarded).
+    await persistRepairedContentHash(storage, id, MERGED, mergedHash);
+    const repaired = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id)!;
+    assert.equal(repaired.frontmatter.contentHash, mergedHash, "the persisted identity is the merged body's hash");
+    const restarted = new StorageManager(dir);
+    assert.equal(
+      await restarted.hasFactContentHash(MERGED),
+      true,
+      "the corpus rebuild must serve the merged-body hash after the durable repair",
+    );
+    assert.equal(
+      await restarted.hasFactContentHash(EXISTING),
+      false,
+      "the stale pre-merge identity must no longer be the record's registered hash",
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+// ── Round N+20 (B): hash registration is body-coupled. A writer that
+// replaces the target between this writer's content commit and the degraded
+// repair keeps its own record; registering OUR (now-obsolete) merged-body
+// hash on it created a phantom exact-dedup hit that suppressed a later real
+// extraction of that body. ─────────────────────────────────────────────────
+
+test("registerFactContentHash: a record replaced after the commit gets no phantom hash (round N+20 B)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-hash-phantom-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const REPLACED = "Deploys were moved to Thursdays by the platform team.";
+    const { id } = await storage.writeMemory("fact", EXISTING, { source: "extraction" });
+    const before = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id)!;
+    await storage.updateMemoryIfUnchanged(before, MERGED, { actor: "semantic-merge" });
+    const mergedHash = ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text);
+    // Another writer replaces the target after this writer's content commit,
+    // before the degraded repair's registration runs.
+    const degraded = (await storage.readAllMemories()).find((m) => m.frontmatter.id === id)!;
+    await storage.updateMemoryIfUnchanged(degraded, REPLACED, { actor: "other-writer" });
+    await storage.registerFactContentHash(id, mergedHash, MERGED);
+    assert.equal(
+      (await storage.readAllMemories()).find((m) => m.frontmatter.id === id)?.content,
+      REPLACED,
+      "fixture sanity: the record was replaced after the degraded writer's commit",
+    );
+    assert.equal(
+      await storage.hasFactContentHash(MERGED),
+      false,
+      "no phantom exact-dedup hit for a body the record no longer holds",
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+// ── Round N+20 (C): a degraded SUCCESS (body committed and kept) commits its
+// recovery snapshot. Pre-fix, the staged version kept `pending` forever, and
+// pruneExcessVersions excludes pending entries — repeated degraded merges
+// grew the manifest and snapshot directory past maxVersionsPerPage with no
+// later prune able to recover the bound. ────────────────────────────────────
+
+test("applySemanticMergeAtPersist: consecutive degraded merges keep the manifest within the page cap (round N+20 C)", async () => {
+  const h = await harness({ frontmatterFails: true, rollbackFails: true, topLevelConfig: { versioningMaxPerPage: 2 } });
+  const versioning = { enabled: true, maxVersionsPerPage: 2, sidecarDir: ".versions" };
+  for (let i = 1; i <= 2; i++) {
+    await createVersion(h.target.path, `${EXISTING} (history fill ${i})`, "write", versioning, undefined, undefined, h.storage.dir);
+  }
+  for (let i = 1; i <= 2; i++) {
+    const outcome = await applySemanticMergeAtPersist(h.deps, {
+      storage: h.storage,
+      content: INCOMING,
+      category: "fact",
+      judgeCall: (options) => acceptingJudge(options),
+    });
+    assert.equal(outcome.action, "merged", `degraded merge ${i} must report merged`);
+    assert.equal(outcome.provenancePatched, false, `degraded merge ${i} is the double-failure path`);
+  }
+  const history = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.ok(
+    history.versions.length <= versioning.maxVersionsPerPage,
+    `the manifest must stay within maxVersionsPerPage (got ${history.versions.length}: ${history.versions.map((v) => `${v.versionId}${v.pending ? "p" : ""}`).join(",")})`,
+  );
+  assert.equal(
+    history.versions.some((version) => version.pending === true),
+    false,
+    "a degraded success's recovery snapshot must be committed, not pending forever",
+  );
+  assert.equal(history.versions.at(-1)?.trigger, "semantic-merge", "the newest entry is the kept recovery point");
+});
+
+// ── Item A: extraction metadata a merge cannot carry ─────────────────────────
+
+test("applySemanticMergeAtPersist: new metadata the merge cannot carry bypasses merging", async () => {
+  const cases: Array<[string, ApplySemanticMergeOptions["incomingMetadata"]]> = [
+    ["structuredAttributes", { structuredAttributes: { region: "us-east" } }],
+    ["bi-temporal bounds", { biTemporal: true }],
+    ["an agent subject the unlabeled target lacks", { subject: "agent" }],
+    ["a new validAt", { validAt: "2026-08-21T00:00:00.000Z" }],
+    ["a tag the target lacks", { tags: ["deploy"] }],
+    ["a higher importance", { importanceScore: 0.9 }],
+    ["a stronger provenance", { provenanceStrength: "verified" }],
+  ];
+  for (const [label, incomingMetadata] of cases) {
+    const h = await harness();
+    const outcome = await applySemanticMergeAtPersist(h.deps, {
+      storage: h.storage,
+      content: INCOMING,
+      category: "fact",
+      judgeCall: (options) => acceptingJudge(options),
+      incomingMetadata,
+    });
+    assert.deepEqual(
+      outcome,
+      { action: "created", reason: "metadata_unpreservable" },
+      label,
+    );
+    assert.deepEqual(h.calls.contentUpdates, [], label);
+    assert.equal(
+      await readFile(h.target.path, "utf8").then((t) => t.includes(MERGED)),
+      false,
+      label,
+    );
+  }
+});
+
+test("applySemanticMergeAtPersist: metadata the target already carries still merges", async () => {
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+    // No new tag, no higher importance, no stronger provenance: nothing the
+    // write path would persist is lost, so the merge runs.
+    incomingMetadata: { tags: [], importanceScore: 0, provenanceStrength: "none" },
+  });
+  assert.deepEqual(outcome, { action: "merged", targetId: "fact-target", mergedContent: MERGED, provenancePatched: true });
+  assert.deepEqual(h.calls.contentUpdates, [
+    { id: "fact-target", content: MERGED, actor: "semantic-merge" },
+  ]);
+});
+
+// ── Item B: the merged body registers under the write path's identity ────────
+
+test("applySemanticMergeAtPersist: the merged fact restamps contentHash off the canonical raw form", async () => {
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  const patch = h.calls.frontmatterPatches[0].patch;
+  // The SAME canonical form normal persistence hashes: sanitized raw
+  // pre-citation content — never a cited variant of the merged body.
+  assert.equal(
+    patch.contentHash,
+    ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text),
+  );
+});
+
+test("applySemanticMergeAtPersist: a non-fact merge stamps no contentHash", async () => {
+  const h = await harness({ targetCategory: "preference" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "preference",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  assert.equal(h.calls.frontmatterPatches[0].patch.contentHash, undefined);
+});
+
+test("applySemanticMergeAtPersist: real storage registers the merged body in the fact-hash index", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-hash-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, { source: "test" });
+  const deps = {
+    config: parseConfig({
+      memoryDir: dir,
+      versioningEnabled: true,
+      semanticMerge: { enabled: true },
+    }),
+    getLocalLlm: () => null,
+    semanticDedupLookup: async () => [{ id: created.id, score: 0.85 }],
+    indexPersistedMemory: async () => {},
+  } as unknown as ExtractionPersistDeps;
+  const outcome = await applySemanticMergeAtPersist(deps, {
+    storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "merged", targetId: created.id, mergedContent: MERGED, provenancePatched: true });
+  // The merged body is registered in the exact-dedup index under the same
+  // canonical form the write path hashes; the pre-merge identity is gone.
+  assert.equal(await storage.hasFactContentHash(MERGED), true);
+  assert.equal(await storage.hasFactContentHash(EXISTING), false);
+});
+
+test("applySemanticMergeAtPersist: repair registers the merged hash for a cold-tier target whose patch hash sync failed (round N+13 C)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-cold-hash-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    // Cold-tier target (same tier layout as the embedding-index test above):
+    // a long-lived merge target that was demoted to cold/.
+    const targetPath = path.join(dir, "cold", "facts", "2026-08-20", "fact-cold-target.md");
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    const existingHash = ContentHashIndex.computeHash(sanitizeMemoryContent(EXISTING).text);
+    await writeFile(
+      targetPath,
+      [
+        "---",
+        "id: fact-cold-target",
+        "category: fact",
+        "created: 2026-08-20T00:00:00.000Z",
+        "updated: 2026-08-20T00:00:00.000Z",
+        "status: active",
+        `contentHash: ${existingHash}`,
+        "---",
+        "",
+        EXISTING,
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+    // Make the fact-hash index authoritative BEFORE the merge. The corpus
+    // rebuild is cold-aware, so a post-merge rebuild would register the
+    // merged hash no matter what the repair did — pre-loading pins the
+    // assertion to the in-process repair path the finding names.
+    assert.equal(await storage.isFactContentHashAuthoritative(), true);
+
+    // One-shot swallow: the provenance patch's internal hash sync fails
+    // (logged, non-fatal — the write stands), so ONLY repairIndexes can
+    // register the merged hash.
+    let swallowed = false;
+    const originalAdd = ContentHashIndex.prototype.addFactByHash;
+    const addSpy = mock.method(
+      ContentHashIndex.prototype,
+      "addFactByHash",
+      function (this: ContentHashIndex, hash: string) {
+        if (!swallowed) {
+          swallowed = true;
+          throw new Error("simulated swallowed frontmatter-hash sync failure");
+        }
+        return originalAdd.call(this, hash);
+      },
+    );
+    try {
+      const deps = {
+        config: parseConfig({
+          memoryDir: dir,
+          versioningEnabled: true,
+          semanticMerge: { enabled: true },
+        }),
+        getLocalLlm: () => null,
+        semanticDedupLookup: async () => [{ id: "fact-cold-target", score: 0.85 }],
+        indexPersistedMemory: async () => {},
+      } as unknown as ExtractionPersistDeps;
+      const outcome = await applySemanticMergeAtPersist(deps, {
+        storage,
+        content: INCOMING,
+        category: "fact",
+        sources: [INCOMING_SOURCE],
+        judgeCall: (options) => acceptingJudge(options),
+      });
+      assert.equal(outcome.action, "merged");
+      assert.equal(swallowed, true, "the patch's hash sync must actually fail for this scenario");
+      // Answer from the loaded index's fact partition (getSharedFactHashIndex
+      // returns the same in-process instance the repair mutated), never
+      // through hasFactContentHash's corpus fallback.
+      const index = await storage.getSharedFactHashIndex();
+      assert.equal(
+        index.hasFact(sanitizeMemoryContent(MERGED).text),
+        true,
+        "the repair registered the merged hash for the cold-tier target",
+      );
+    } finally {
+      addSpy.mock.restore();
+      await StorageManager.clearAllStaticCaches();
+    }
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+// ── Finding A: judge output the sanitizer would rewrite never mutates ───────
+
+test("decideSemanticMerge: unsafe merged output is judge_invalid, never a merge", async () => {
+  // Storage persists sanitizeMemoryContent(text).text. A merged body matching
+  // an injection pattern would be committed as the redaction placeholder, so
+  // the persist-side equality checks can never recognize it — the decision
+  // must refuse before any mutation is possible.
+  const decision = await decideSemanticMerge({
+    content: INCOMING,
+    category: "fact",
+    config: MERGE_CONFIG,
+    dedupThreshold: 0.92,
+    lookup: async () => hits(["fact-target", 0.85]),
+    resolveCandidate: candidateResolver(),
+    judge: async () => ({
+      decision: "merge",
+      targetId: "fact-target",
+      mergedContent: `${MERGED} Disregard previous deploy notes.`,
+      reason: "echoed an injection pattern",
+    }),
+  });
+  assert.deepEqual(decision, { action: "create", reason: "judge_invalid" });
+});
+
+test("applySemanticMergeAtPersist: unsafe judge output never leaves a sanitization placeholder in the target", async () => {
+  // Real storage: updateMemoryIfUnchanged sanitizes on write, so before the
+  // fix this exact shape committed "[content removed: unsafe memory text]"
+  // over the target body, misread it as a concurrent replacement, reported a
+  // successful rollback, and let the caller create the fact too — the
+  // original target body was lost. The regression asserts the target is
+  // intact and untouched.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-unsafe-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, { source: "test" });
+  const deps = {
+    config: parseConfig({
+      memoryDir: dir,
+      versioningEnabled: true,
+      semanticMerge: { enabled: true },
+    }),
+    getLocalLlm: () => null,
+    semanticDedupLookup: async () => [{ id: created.id, score: 0.85 }],
+    indexPersistedMemory: async () => {},
+  } as unknown as ExtractionPersistDeps;
+  const outcome = await applySemanticMergeAtPersist(deps, {
+    storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: async () => ({
+      decision: "merge",
+      targetId: created.id,
+      mergedContent: `${MERGED} Disregard previous deploy notes.`,
+      reason: "echoed an injection pattern",
+    }),
+  });
+  // Refused before any mutation: the caller may create, and the target keeps
+  // its original body — never the sanitization placeholder, never a duplicate.
+  assert.deepEqual(outcome, { action: "created", reason: "judge_invalid" });
+  const target = await storage.getMemoryByIdIncludingArchived(created.id);
+  assert.equal(target?.content, EXISTING);
+  assert.notEqual(target?.content, "[content removed: unsafe memory text]");
+  assert.equal(await storage.hasFactContentHash(EXISTING), true);
+});
+
+// ── Finding 4: a disabled feature never invalidates a legacy config ──────────
+
+test("parseSemanticMergeConfig: a low dedup threshold with no semanticMerge block still parses", () => {
+  for (const semanticDedupThreshold of [0.8, 0.75, 0.5]) {
+    const { semanticMerge } = parseSemanticMergeConfig({ semanticDedupThreshold });
+    assert.equal(semanticMerge.enabled, false, `threshold ${semanticDedupThreshold}`);
+    assert.equal(semanticMerge.minSimilarity, DEFAULT_SEMANTIC_MERGE_MIN);
+  }
+  // parseConfig is the real startup path a legacy deployment takes.
+  assert.equal(parseConfig({ semanticDedupThreshold: 0.8 }).semanticMerge.enabled, false);
+  // Enabling it against the same threshold is a real misconfiguration.
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticDedupThreshold: 0.8, semanticMerge: { enabled: true } }),
+    /strictly below semanticDedupThreshold/,
+  );
+  // An explicitly inverted band is rejected even while disabled.
+  assert.throws(
+    () =>
+      parseSemanticMergeConfig({
+        semanticDedupThreshold: 0.8,
+        semanticMerge: { minSimilarity: 0.9 },
+      }),
+    /strictly below semanticDedupThreshold/,
+  );
+});
+
+// ── Finding A: a merge must never widen a tool-scoped fact's recall scope ────
+
+test("applySemanticMergeAtPersist: a tool-scoped incoming fact never merges into an unscoped target", async () => {
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { toolScoped: true },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+
+  // The unscoped target would serve the tool-specific claims to every
+  // connector; the write path (which stamps `toolScoped: true`) must run.
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+  const history = await listVersions(h.target.path, { enabled: true, maxVersionsPerPage: 20, sidecarDir: ".versions" }, h.storage.dir);
+  assert.equal(history.versions.length, 0, "a bypassed merge must leave no snapshot");
+});
+
+test("applySemanticMergeAtPersist: a tool-scoped target keeps its stricter scope through a merge", async () => {
+  const h = await harness({ targetToolScoped: true });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { toolScoped: true },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "merged", targetId: "fact-target", mergedContent: MERGED, provenancePatched: true });
+  // The merge patch carries no `toolScoped` key at all — the stricter flag
+  // survives because the patch never touches it, never because it is rewritten.
+  assert.equal(h.calls.frontmatterPatches.length, 1);
+  assert.equal("toolScoped" in h.calls.frontmatterPatches[0].patch, false);
+});
+
+// ── Finding A: a merge must not relabel content across the subject guard ────
+
+
+test("applySemanticMergeAtPersist: a user-subject fact never merges into an agent-labeled target", async () => {
+  const h = await harness({ targetSubject: "agent" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { subject: "user" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+
+  // Merging would increment reinforcement_count on an agent-labeled memory
+  // while its body now carries user-specific claims — the promotion path
+  // treats reinforced agent memories as shared-promotion candidates. The
+  // create path must run so the fact persists under its own subject.
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+  const history = await listVersions(h.target.path, { enabled: true, maxVersionsPerPage: 20, sidecarDir: ".versions" }, h.storage.dir);
+  assert.equal(history.versions.length, 0, "a bypassed merge must leave no snapshot");
+});
+
+test("applySemanticMergeAtPersist: an identical subject still merges", async () => {
+  const h = await harness({ targetSubject: "agent" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { subject: "agent" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "merged", targetId: "fact-target", mergedContent: MERGED, provenancePatched: true });
+});
+
+// ── Finding C: promoted copies are reconciled only by the create path ────────
+
+test("applySemanticMergeAtPersist: a target with promoted copies bypasses the merge before any mutation", async () => {
+  const h = await harness();
+  const probedIds: string[] = [];
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    targetHasPromotedCopies: async (targetId) => {
+      probedIds.push(targetId);
+      return true;
+    },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+
+  assert.deepEqual(outcome, { action: "created", reason: "promoted_copy_present" });
+  assert.deepEqual(probedIds, ["fact-target"], "the probe runs for the judged target only");
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+  const history = await listVersions(h.target.path, { enabled: true, maxVersionsPerPage: 20, sidecarDir: ".versions" }, h.storage.dir);
+  assert.equal(history.versions.length, 0, "the bypass must precede the rollback snapshot");
+});
+
+// ── Round N+11 (A): only ACTIVE promoted copies block a merge ────────────────
+
+test("mergeTargetHasPromotedCopies: a namespace holding only a superseded copy does not block the merge (round N+11 A)", async () => {
+  const sourceDir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-scan-src-"));
+  const sharedDir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-scan-shr-"));
+  try {
+    // A superseded copy in the shared namespace, linked back to the target.
+    const copyDir = path.join(sharedDir, "facts", "2026-08-20");
+    await mkdir(copyDir, { recursive: true });
+    await writeFile(
+      path.join(copyDir, "copy-superseded.md"),
+      [
+        "---",
+        "id: fact-copy-superseded",
+        "category: fact",
+        "created: 2026-08-20T00:00:00.000Z",
+        "updated: 2026-08-20T00:00:00.000Z",
+        "status: superseded",
+        "sourceMemoryId: fact-target",
+        "---",
+        "",
+        EXISTING,
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+    const sourceStorage = new StorageManager(sourceDir);
+    const sharedStorage = new StorageManager(sharedDir);
+    await sourceStorage.ensureDirectories();
+    await sharedStorage.ensureDirectories();
+    const config = parseConfig({ memoryDir: sourceDir }) as PluginConfig;
+    const probe = createBatchPromotedCopyProbe(
+      config,
+      () => ({
+        storageFor: async (namespace: string) =>
+          namespace === config.sharedNamespace ? sharedStorage : sourceStorage,
+      }),
+      null,
+    );
+    // A superseded copy serves no body, so it must not read as promoted.
+    assert.equal(
+      await probe.check(sourceStorage, "fact-target"),
+      false,
+      "a namespace holding only a superseded copy must not report promoted copies",
+    );
+
+    // End to end: the REAL probe wired into the merge gate lets judge-approved
+    // updates merge instead of accumulating as new fragments.
+    const h = await harness();
+    const outcome = await applySemanticMergeAtPersist(h.deps, {
+      storage: h.storage,
+      content: INCOMING,
+      category: "fact",
+      sources: [INCOMING_SOURCE],
+      targetHasPromotedCopies: (targetId) => probe.check(h.storage, targetId),
+      judgeCall: (options) => acceptingJudge(options),
+    });
+    assert.deepEqual(outcome, { action: "merged", targetId: "fact-target", mergedContent: MERGED, provenancePatched: true });
+  } finally {
+    await StorageManager.clearAllStaticCaches();
+    await rm(sourceDir, { recursive: true, force: true });
+    await rm(sharedDir, { recursive: true, force: true });
+  }
+});
+
+// ── Round N+11 (C): a failed CAS must not discard the oldest rollback point ──
+
+test("applySemanticMergeAtPersist: a failed CAS at a full version history keeps the oldest rollback point (round N+11 C)", async () => {
+  const RACED = "Billing service deploys happen on Tuesdays, except during a freeze.";
+  const h = await harness({ mutateOnWrite: RACED, topLevelConfig: { versioningMaxPerPage: 3 } });
+  const versioning = { enabled: true, maxVersionsPerPage: 3, sidecarDir: ".versions" };
+  for (let i = 1; i <= 3; i++) {
+    await createVersion(h.target.path, `${EXISTING} (history fill ${i})`, "write", versioning, undefined, undefined, h.storage.dir);
+  }
+  const before = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.equal(before.versions.length, 3, "history starts full at the cap");
+
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "target_changed" });
+
+  const after = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.ok(
+    after.versions.some((v) => v.versionId === "1"),
+    `the oldest rollback point must survive the failed attempt (got ${JSON.stringify(after.versions.map((v) => v.versionId))})`,
+  );
+});
+
+test("applySemanticMergeAtPersist: a committed merge still finalizes the prune back to the cap (round N+11 C)", async () => {
+  const h = await harness({ topLevelConfig: { versioningMaxPerPage: 3 } });
+  const versioning = { enabled: true, maxVersionsPerPage: 3, sidecarDir: ".versions" };
+  for (let i = 1; i <= 3; i++) {
+    await createVersion(h.target.path, `${EXISTING} (history fill ${i})`, "write", versioning, undefined, undefined, h.storage.dir);
+  }
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  const after = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.equal(after.versions.length, 3, "a committed merge prunes the history back to the configured cap");
+  assert.equal(after.versions.at(-1)?.trigger, "semantic-merge");
+});
+
+// ── Round N+12 (A): a rejected frontmatter patch must leave version history
+// untouched — pruning finalizes only after BOTH compare-and-swaps commit. ────
+
+test("applySemanticMergeAtPersist: a rejected frontmatter patch at a full version history keeps the oldest rollback point (round N+12 A)", async () => {
+  const h = await harness({ frontmatterFails: true, topLevelConfig: { versioningMaxPerPage: 3 } });
+  const versioning = { enabled: true, maxVersionsPerPage: 3, sidecarDir: ".versions" };
+  for (let i = 1; i <= 3; i++) {
+    await createVersion(h.target.path, `${EXISTING} (history fill ${i})`, "write", versioning, undefined, undefined, h.storage.dir);
+  }
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "update_failed" });
+
+  const after = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.ok(
+    after.versions.some((v) => v.versionId === "1"),
+    `the oldest rollback point must survive the unsuccessful attempt (got ${JSON.stringify(after.versions.map((v) => v.versionId))})`,
+  );
+  assert.equal(
+    await readFile(h.target.path, "utf8").then((raw) => raw.includes(EXISTING)),
+    true,
+    "the rolled-back target body is the pre-merge text",
+  );
+});
+
+// ── Round N+13 (B): staging itself mutates history — an aborted attempt must
+// roll the staged snapshot back out, or repeated failures grow history past
+// the cap and a later successful merge's prune trades real rollback states
+// for duplicate failed-attempt snapshots. ────────────────────────────────────
+
+test("applySemanticMergeAtPersist: a lost CAS race rolls the staged snapshot back out of history (round N+13 B)", async () => {
+  const RACED = "Billing service deploys happen on Tuesdays, except during a freeze.";
+  const h = await harness({ mutateOnWrite: RACED, topLevelConfig: { versioningMaxPerPage: 3 } });
+  const versioning = { enabled: true, maxVersionsPerPage: 3, sidecarDir: ".versions" };
+  for (let i = 1; i <= 3; i++) {
+    await createVersion(h.target.path, `${EXISTING} (history fill ${i})`, "write", versioning, undefined, undefined, h.storage.dir);
+  }
+  const before = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.equal(before.versions.length, 3, "history starts full at the cap");
+
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "target_changed" });
+
+  const after = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.deepEqual(
+    after.versions.map((v) => v.versionId),
+    before.versions.map((v) => v.versionId),
+    "a lost CAS race must leave exactly the pre-attempt history",
+  );
+  assert.equal(after.currentVersion, before.currentVersion, "currentVersion must return to the pre-attempt newest");
+});
+
+test("applySemanticMergeAtPersist: a reverted metadata failure rolls the staged snapshot back out of history (round N+13 B)", async () => {
+  const h = await harness({ frontmatterFails: true, topLevelConfig: { versioningMaxPerPage: 3 } });
+  const versioning = { enabled: true, maxVersionsPerPage: 3, sidecarDir: ".versions" };
+  for (let i = 1; i <= 3; i++) {
+    await createVersion(h.target.path, `${EXISTING} (history fill ${i})`, "write", versioning, undefined, undefined, h.storage.dir);
+  }
+  const before = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.equal(before.versions.length, 3, "history starts full at the cap");
+
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "update_failed" });
+
+  const after = await listVersions(h.target.path, versioning, h.storage.dir);
+  assert.deepEqual(
+    after.versions.map((v) => v.versionId),
+    before.versions.map((v) => v.versionId),
+    "a successfully reverted metadata failure must leave exactly the pre-attempt history",
+  );
+  assert.equal(after.currentVersion, before.currentVersion, "currentVersion must return to the pre-attempt newest");
+});
+
+// ── Final round: origin authority, log privacy, least-privilege subject ──────
+
+test("applySemanticMergeAtPersist: a cross-origin merge into a user-authority target is refused (finding A)", async () => {
+  const h = await harness({ targetOrigin: "user" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    incomingMetadata: { origin: "tool_output" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, [], "the user-authority target must keep its body");
+  assert.equal(
+    (await readFile(h.target.path, "utf8")).includes(INCOMING),
+    false,
+    "the target file must not carry the untrusted text",
+  );
+
+  // The rendered-authority contract, not just frontmatter. Under the target's
+  // retained `origin: user` the merged body would reach model context with NO
+  // authority fence — the escalation the refusal prevents:
+  assert.equal(
+    renderAuthorityBoundContent(MERGED, "user", { enabled: true, untrustedOrigins: DEFAULT_UNTRUSTED_ORIGINS }),
+    MERGED,
+    "the would-be merged body renders UNFENCED under the retained user origin",
+  );
+  // Persisted instead through the create path, the incoming body renders
+  // fenced under its own untrusted origin:
+  assert.equal(
+    renderAuthorityBoundContent(INCOMING, "tool_output", { enabled: true, untrustedOrigins: DEFAULT_UNTRUSTED_ORIGINS }),
+    renderAuthorityFence(INCOMING, "tool_output"),
+    "the created fact's body renders inside the authority fence",
+  );
+});
+
+test("applySemanticMergeAtPersist: an identical origin still merges", async () => {
+  const h = await harness({ targetOrigin: "user" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    incomingMetadata: { origin: "user" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  // Final round: the promotion re-reads the committed record, so origin is
+  // asserted off that record — the exact source the promotion now stamps from.
+  const committedRecord = await h.storage.getMemoryByIdIncludingArchived("fact-target");
+  assert.equal(committedRecord?.frontmatter.origin, "user");
+});
+
+test("applySemanticMergeAtPersist: a user-origin fact still merges into a legacy unstamped target", async () => {
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    incomingMetadata: { origin: "user" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  // The unstamped target renders as `unknown` (fenced) at recall, so the
+  // merged body is fenced at least as strictly as the incoming fact — no
+  // escalation, and legacy targets keep receiving user-origin facts.
+  assert.deepEqual(outcome, { action: "merged", targetId: "fact-target", mergedContent: MERGED, provenancePatched: true });
+});
+
+test("applySemanticMergeAtPersist: shadow-mode create telemetry carries no fact content (finding B)", async () => {
+  const entries: Array<{ level: string; message: string }> = [];
+  const backend: LoggerBackend = {
+    info: (msg: string) => entries.push({ level: "info", message: msg }),
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  };
+  initLogger(backend, true);
+  try {
+    const h = await harness({ config: { shadowMode: true } });
+    const outcome = await applySemanticMergeAtPersist(h.deps, {
+      storage: h.storage,
+      content: INCOMING,
+      category: "fact",
+      judgeCall: async () => ({
+        decision: "create",
+        targetId: null,
+        mergedContent: null,
+        reason: "distinct underlying concept",
+      }),
+    });
+    assert.deepEqual(outcome, { action: "created", reason: "judge_create" });
+
+    const line = entries.find((e) => e.message.includes("semantic-merge[shadow]: would create"))
+      ?.message;
+    assert.ok(line, "the shadow create line must be logged at info level");
+    assert.ok(line.includes("category=fact"), "category is logged");
+    assert.ok(line.includes(`length=${INCOMING.length}`), "content length is logged");
+    assert.ok(line.includes('reason="judge_create"'), "reason is logged");
+    assert.ok(!line.includes(INCOMING.slice(0, 60)), "no content prefix may appear");
+    for (const token of INCOMING.split(" ")) {
+      if (token.length >= 4) {
+        assert.ok(!line.includes(token), `log must not carry fact content (found "${token}")`);
+      }
+    }
+  } finally {
+    resetLogger();
+  }
+});
+
+test("applySemanticMergeAtPersist: an absent incoming subject never reinforces an agent target (finding C)", async () => {
+  const h = await harness({ targetSubject: "agent" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    // Subject classification disabled: the write path stamps no subject, and
+    // the guard must treat that absent subject as the least-privileged "user".
+    incomingMetadata: {},
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, [], "the agent target must keep its body");
+  assert.deepEqual(
+    h.calls.frontmatterPatches,
+    [],
+    "an unclassified fact must not bump reinforcement_count on an agent target",
+  );
+});
+
+// ── Final round: the create-path parity gate ─────────────────────────────────
+
+test("applySemanticMergeAtPersist: a merged outcome carries the committed merged body (finding A)", async () => {
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  if (outcome.action !== "merged") {
+    assert.fail(`expected a merge, got ${JSON.stringify(outcome)}`);
+  }
+  // The caller's merged-target promotion copies THIS body. It is the judge's
+  // merged text — the committed union of old and new claims — never the
+  // incoming fact alone.
+  assert.equal(outcome.mergedContent, MERGED);
+  assert.notEqual(outcome.mergedContent, INCOMING);
+  const committed = await h.storage.getMemoryByIdIncludingArchived("fact-target");
+  assert.equal(committed?.content, outcome.mergedContent);
+});
+
+test("applySemanticMergeAtPersist: a weaker incoming provenance retags the merged body, never upgrades it (finding B)", async () => {
+  const h = await harness({ targetProvenance: "verified" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { provenanceStrength: "unverified" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, {
+    action: "merged",
+    targetId: "fact-target",
+    mergedContent: MERGED,
+    provenancePatched: true,
+  });
+  // trust-score.ts maps `verified` to the maximum provenance contribution;
+  // the combined body now holds unverified claims, so the tag must drop.
+  assert.equal(
+    h.calls.frontmatterPatches[0]?.patch.provenance,
+    "unverified",
+    "the merged body must not stay tagged verified",
+  );
+});
+
+test("applySemanticMergeAtPersist: an unprovenanced incoming fact downgrades a verified target to none (finding B)", async () => {
+  // Extraction omits `provenance` when the strength is "none", so an absent
+  // incoming value is the weakest case, not a neutral one.
+  const h = await harness({ targetProvenance: "verified" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: {},
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  assert.equal(h.calls.frontmatterPatches[0]?.patch.provenance, "none");
+});
+
+test("applySemanticMergeAtPersist: equal provenance merges without touching the tag (finding B)", async () => {
+  const h = await harness({ targetProvenance: "unverified" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { provenanceStrength: "unverified" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  assert.equal(
+    "provenance" in (h.calls.frontmatterPatches[0]?.patch ?? {}),
+    false,
+    "an equal tag needs no rewrite",
+  );
+});
+
+test("applySemanticMergeAtPersist: an incoming faithfulness verdict the target cannot preserve bypasses the merge (finding C)", async () => {
+  // Shadow mode: the contradicted fact carries a verdict but no
+  // pending_review status, so only the parity gate can catch it. The target
+  // keeps `entailed`; the trust stage would keep injecting the combined
+  // body instead of applying the incoming negative evidence.
+  const h = await harness({ targetFaithfulness: { verdict: "entailed" } });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { faithfulness: { verdict: "contradicted" } },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+});
+
+test("applySemanticMergeAtPersist: an effectively identical faithfulness verdict still merges (finding C)", async () => {
+  // `skipped_no_span` and `unchecked` both read as "unchecked" to the trust
+  // stage, so the verdict IS preserved and the merge proceeds.
+  const h = await harness({ targetFaithfulness: { verdict: "skipped_no_span" } });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { faithfulness: { verdict: "unchecked" } },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+});
+
+test("applySemanticMergeAtPersist: a one-sided faithfulness verdict bypasses the merge — gate-disabled incoming into a judged target (finding C)", async () => {
+  // Faithfulness gate off for the incoming fact: its claims were never
+  // checked, but the target's `entailed` maps to the trust stage's maximum
+  // contribution. Merging would let unchecked claims inherit an entailment
+  // rendered over the target's claims alone, so the merge bypasses and the
+  // create path stores the fact without a verdict, exactly as it would.
+  const h = await harness({ targetFaithfulness: { verdict: "entailed" } });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+});
+
+test("applySemanticMergeAtPersist: a one-sided faithfulness verdict bypasses the merge — judged incoming into a legacy target (finding C)", async () => {
+  // Mirror of the gate-off case: the incoming `entailed` covers only the
+  // incoming claims, and no verdict was ever rendered over the target's.
+  // The combined body must not carry a one-sided verdict, so the merge
+  // bypasses and the create path persists the verdict it computed.
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { faithfulness: { verdict: "entailed" } },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+});
+
+test("applySemanticMergeAtPersist: even an EQUAL entailed verdict bypasses the merge (round N+9 A)", async () => {
+  // Both sides carry `entailed` — the equality the finding-C gate called
+  // preservable. But the target's verdict was rendered over its PRE-merge
+  // body; the committed record would hold the judge's mergedContent, a body
+  // the faithfulness gate never saw. The trust stage maps `entailed` to its
+  // maximum contribution, so the committed record must not carry it: the
+  // merge bypasses and the create path persists the verdict it computed.
+  // (Re-running the gate inside the compare-and-swap window would need a
+  // per-merge LLM call; bypass is the safe mechanism.)
+  const h = await harness({ targetFaithfulness: { verdict: "entailed" } });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { faithfulness: { verdict: "entailed" } },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+});
+
+test("applySemanticMergeAtPersist: an unscoped fact never merges into a connector-owned cold target (finding D)", async () => {
+  // The lookup hit carries NO sourceConnector — exactly what the hot-only
+  // enrichment in persistence-index.ts produces for a cold-tier target or a
+  // failed enrichment read. The lookup-side scope check therefore sees two
+  // unscoped sides and passes; only the cold-aware re-read of the target can
+  // supply the authoritative connector and fail the merge closed.
+  const h = await harness({
+    targetSourceConnector: "connector-a",
+    lookupHits: [{ id: "fact-target", score: 0.85 }],
+  });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, [], "the connector-owned body must keep its claims");
+  assert.equal(
+    (await readFile(h.target.path, "utf8")).includes(MERGED),
+    false,
+    "the target file must not carry the merged body",
+  );
+});
+
+test("applySemanticMergeAtPersist: an identical connector scope still merges (finding D)", async () => {
+  const h = await harness({
+    targetSourceConnector: "connector-a",
+    lookupHits: [{ id: "fact-target", score: 0.85, sourceConnector: "connector-a" }],
+  });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    sourceConnector: "connector-a",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+});
+
+// ── Final round: min confidence across a merge; no promotion from an inactive target ──
+
+test("applySemanticMergeAtPersist: a lower incoming confidence downgrades the merged record (final round A)", async () => {
+  const h = await harness({ targetConfidence: 0.9 });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { confidence: 0.5 },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  // The create path would have stored the incoming fact at 0.5 ("inferred").
+  // The merged record must not keep 0.9/"explicit": lifecycle scoring,
+  // preference consolidation, and the merged-target promotion all read these
+  // fields off the committed record.
+  const patch = h.calls.frontmatterPatches[0]?.patch;
+  assert.equal(patch?.confidence, 0.5);
+  assert.equal(patch?.confidenceTier, "inferred");
+});
+
+test("applySemanticMergeAtPersist: the committed merged record carries the lower confidence (final round A)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-conf-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, {
+    source: "test",
+    confidence: 0.9,
+  });
+  const deps = {
+    config: parseConfig({
+      memoryDir: dir,
+      versioningEnabled: true,
+      semanticMerge: { enabled: true },
+    }),
+    getLocalLlm: () => null,
+    semanticDedupLookup: async () => [{ id: created.id, score: 0.85 }],
+    indexPersistedMemory: async () => {},
+  } as unknown as ExtractionPersistDeps;
+  const outcome = await applySemanticMergeAtPersist(deps, {
+    storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { confidence: 0.5 },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  const committed = await storage.getMemoryByIdIncludingArchived(created.id);
+  assert.equal(committed?.frontmatter.confidence, 0.5);
+  assert.equal(committed?.frontmatter.confidenceTier, "inferred");
+  // The committed record is the promotion payload's sole source, so the
+  // shared/profile copy stamps the downgraded value too.
+  const payload = await buildMergedTargetPromotionPayload(storage, {
+    targetId: created.id,
+    mergedContent: MERGED,
+    provenancePatched: true,
+  });
+  assert.ok(payload);
+  assert.equal(payload.confidence, 0.5);
+});
+
+test("applySemanticMergeAtPersist: an incoming confidence at or above the target's never rewrites confidence (final round A)", async () => {
+  const h = await harness({ targetConfidence: 0.9 });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { confidence: 0.95 },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  // min(0.95, 0.9) is the target's own 0.9 — already on the record, so the
+  // patch carries no confidence keys at all.
+  const patch = h.calls.frontmatterPatches[0]?.patch ?? {};
+  assert.equal("confidence" in patch, false);
+  assert.equal("confidenceTier" in patch, false);
+});
+
+test("applySemanticMergeAtPersist: an unreadable incoming confidence bypasses the merge (final round A)", async () => {
+  for (const bad of [Number.NaN, 1.5, -0.1]) {
+    const h = await harness({ targetConfidence: 0.9 });
+    const outcome = await applySemanticMergeAtPersist(h.deps, {
+      storage: h.storage,
+      content: INCOMING,
+      category: "fact",
+      incomingMetadata: { confidence: bad },
+      judgeCall: (options) => acceptingJudge(options),
+    });
+    assert.deepEqual(
+      outcome,
+      { action: "created", reason: "metadata_unpreservable" },
+      String(bad),
+    );
+    assert.deepEqual(h.calls.contentUpdates, [], String(bad));
+  }
+});
+
+test("buildMergedTargetPromotionPayload: never promotes from an inactive committed target (final round B)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-inactive-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, { source: "test" });
+  // The merge has committed — the target body IS the merged body. Then a
+  // concurrent lifecycle operation retires the target BEFORE the promotion
+  // reread: the multi-writer interleaving, simulated directly.
+  const snapshot = await storage.getMemoryByIdIncludingArchived(created.id);
+  assert.ok(snapshot);
+  assert.equal(await storage.updateMemoryIfUnchanged(snapshot, MERGED), true);
+  for (const status of ["superseded", "archived"] as const) {
+    assert.equal(
+      await storage.updateMemoryFrontmatter(created.id, { status }),
+      true,
+      status,
+    );
+    // Null, never a payload: the caller skips promoteMemoryToShared, so no
+    // new active copy resurrects what the lifecycle operation retired.
+    assert.equal(
+      await buildMergedTargetPromotionPayload(storage, {
+        targetId: created.id,
+        mergedContent: MERGED,
+    provenancePatched: true,
+      }),
+      null,
+      status,
+    );
+  }
+  // A still-active committed target still grounds the promotion.
+  assert.equal(
+    await storage.updateMemoryFrontmatter(created.id, { status: "active" }),
+    true,
+  );
+  const payload = await buildMergedTargetPromotionPayload(storage, {
+    targetId: created.id,
+    mergedContent: MERGED,
+    provenancePatched: true,
+  });
+  assert.ok(payload);
+  assert.equal(payload.content, MERGED);
+});
+
+function realStorageDeps(
+  dir: string,
+  createdId: string,
+  hitConnector?: string,
+): ExtractionPersistDeps {
+  return {
+    config: parseConfig({
+      memoryDir: dir,
+      versioningEnabled: true,
+      semanticMerge: { enabled: true },
+    }),
+    getLocalLlm: () => null,
+    semanticDedupLookup: async () => [
+      { id: createdId, score: 0.85, ...(hitConnector ? { sourceConnector: hitConnector } : {}) },
+    ],
+    indexPersistedMemory: async () => {},
+  } as unknown as ExtractionPersistDeps;
+}
+
+test("buildMergedTargetPromotionPayload: carries the committed tool-scope marker and connector (finding A)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-scope-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, {
+    source: "test",
+    sourceConnector: "connector-a",
+    toolScoped: true,
+  });
+  // Same-connector incoming fact that is NOT independently tool-scoped: the
+  // parity gate keeps the target's narrower scope and lets the merge run.
+  const outcome = await applySemanticMergeAtPersist(
+    realStorageDeps(dir, created.id, "connector-a"),
+    {
+      storage,
+      content: INCOMING,
+      category: "fact",
+      sources: [INCOMING_SOURCE],
+      sourceConnector: "connector-a",
+      judgeCall: (options) => acceptingJudge(options),
+    },
+  );
+  assert.equal(outcome.action, "merged");
+  const payload = await buildMergedTargetPromotionPayload(storage, {
+    targetId: created.id,
+    mergedContent: MERGED,
+    provenancePatched: true,
+  });
+  assert.ok(payload);
+  // The content heuristics alone would NOT withhold the merged body — only
+  // the committed marker keeps the promoted copy out of the shared namespace.
+  assert.equal(
+    withholdToolScopedFromSharedNamespace({
+      content: payload.content,
+      sourceConnector: payload.sourceConnector,
+    }),
+    false,
+  );
+  assert.equal(payload.toolScoped, true);
+  assert.equal(payload.sourceConnector, "connector-a");
+  // The exact gate promoteMemoryToShared runs over the spread payload.
+  assert.equal(promotionWithholdsToolScope(payload), true);
+});
+
+test("buildMergedTargetPromotionPayload: an unscoped target promotes a payload without scope fields (finding A)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-plain-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, { source: "test" });
+  const outcome = await applySemanticMergeAtPersist(realStorageDeps(dir, created.id), {
+    storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  const payload = await buildMergedTargetPromotionPayload(storage, {
+    targetId: created.id,
+    mergedContent: MERGED,
+    provenancePatched: true,
+  });
+  assert.ok(payload);
+  assert.equal("toolScoped" in payload, false);
+  assert.equal("sourceConnector" in payload, false);
+  assert.equal(promotionWithholdsToolScope(payload), false);
+});
+
+test("applySemanticMergeAtPersist: suggested links attach to the merged target and stay traversable (finding B)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-links-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, { source: "test" });
+  const neighbor = await storage.writeMemory(
+    "fact",
+    "Releases are cut after the deploy window closes.",
+    { source: "test" },
+  );
+  const linked = await storage.writeMemory(
+    "fact",
+    "The on-call rotation follows the release train.",
+    { source: "test" },
+  );
+  await storage.addLinksToMemory(created.id, [
+    { targetId: linked.id, linkType: "supports", strength: 0.9 },
+  ]);
+  const outcome = await applySemanticMergeAtPersist(realStorageDeps(dir, created.id), {
+    storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingLinks: [
+      { targetId: neighbor.id, linkType: "related", strength: 0.8, reason: "same cadence" },
+      { targetId: linked.id, linkType: "supports", strength: 0.5 },
+    ],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  // Traversal surfaces (dependency propagation, recall-navigate) read
+  // frontmatter.links off the committed record — so the round-tripped
+  // record IS the navigation contract.
+  const committed = await storage.getMemoryByIdIncludingArchived(created.id);
+  assert.ok(committed);
+  const links = committed.frontmatter.links ?? [];
+  assert.equal(links.length, 2, JSON.stringify(links));
+  assert.ok(
+    links.some((l) => l.targetId === neighbor.id && l.linkType === "related"),
+    "the suggested link must be attached to the target",
+  );
+  assert.ok(
+    links.some(
+      (l) => l.targetId === linked.id && l.linkType === "supports" && l.strength === 0.9,
+    ),
+    "the committed link is deduped against, not replaced by, the incoming duplicate",
+  );
+});
+
+test("applySemanticMergeAtPersist: no suggested links leaves the target's committed links untouched (finding B)", async () => {
+  const h = await harness();
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  // An empty links patch would ERASE committed links — the key must be absent.
+  assert.equal("links" in (h.calls.frontmatterPatches[0]?.patch ?? {}), false);
+});
+
+test("applySemanticMergeAtPersist: a suggested link naming the merge target itself is discarded, not attached (finding B)", async () => {
+  // Memory linking and the merge judge both search on the incoming content,
+  // so the suggested neighbor is often the merge target itself. Attaching it
+  // would make the surviving record its own neighbor — recall-navigate would
+  // return the current memory and burn traversal budget for nothing.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-selflink-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, { source: "test" });
+  const neighbor = await storage.writeMemory(
+    "fact",
+    "Releases are cut after the deploy window closes.",
+    { source: "test" },
+  );
+  const outcome = await applySemanticMergeAtPersist(realStorageDeps(dir, created.id), {
+    storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingLinks: [
+      { targetId: created.id, linkType: "related", strength: 0.8, reason: "same cadence" },
+      { targetId: neighbor.id, linkType: "related", strength: 0.7 },
+    ],
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+  const committed = await storage.getMemoryByIdIncludingArchived(created.id);
+  assert.ok(committed);
+  const links = committed.frontmatter.links ?? [];
+  assert.equal(
+    links.some((l) => l.targetId === created.id),
+    false,
+    "no self-edge on the committed record",
+  );
+  assert.ok(
+    links.some((l) => l.targetId === neighbor.id && l.linkType === "related"),
+    "other suggested links still attach",
+  );
+});
+
+test("parseSemanticMergeConfig: unknown or never-mergeable categories are rejected with the valid list (finding C)", () => {
+  for (const bad of [["facts"], ["fact", "procedue"], ["procedure"], ["reasoning_trace"], ["moment"], ["correction"]]) {
+    assert.throws(
+      () => parseSemanticMergeConfig({ semanticMerge: { categories: bad } }),
+      /Valid categories: fact, preference, entity, decision, relationship, principle, commitment, skill, rule/,
+      JSON.stringify(bad),
+    );
+  }
+  assert.throws(
+    () => parseSemanticMergeConfig({ semanticMerge: { categories: ["facts"] } }),
+    /The episodic and immutable categories \(procedure, reasoning_trace, moment, correction\) never merge/,
+  );
+  assert.deepEqual(
+    parseSemanticMergeConfig({
+      semanticMerge: { categories: [...MERGEABLE_MEMORY_CATEGORIES, "rule"] },
+    }).semanticMerge.categories,
+    [...MERGEABLE_MEMORY_CATEGORIES, "rule"],
+  );
+});
+
+// ── Round N+2: validity bounds, memoryKind parity, raw hash, strict config ───
+
+test("applySemanticMergeAtPersist: a target with invalid_at never takes unbounded claims (round N+2 A)", async () => {
+  // inferMemoryStatus ignores temporal validity, so this target is still
+  // lifecycle-active — only the parity gate stands between the fresh claim
+  // and isValidityExpiredNow removing the merged body from normal recall.
+  const h = await harness({ targetInvalidAt: "2026-08-01T00:00:00.000Z" });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: {},
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(outcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(h.calls.contentUpdates, []);
+  assert.deepEqual(h.calls.frontmatterPatches, []);
+
+  // A valid_at the incoming fact does not carry is equally unmergable: the
+  // merged body would silently inherit the target's bound.
+  const bounded = await harness({ targetValidAt: "2026-08-01T00:00:00.000Z" });
+  const boundedOutcome = await applySemanticMergeAtPersist(bounded.deps, {
+    storage: bounded.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: {},
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(boundedOutcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(bounded.calls.contentUpdates, []);
+});
+
+test("applySemanticMergeAtPersist: a bounded-compatible pair still merges (round N+2 A)", async () => {
+  const VALID = "2026-08-01T00:00:00.000Z";
+  const h = await harness({ targetValidAt: VALID });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { validAt: VALID },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(outcome.action, "merged");
+});
+
+test("applySemanticMergeAtPersist: mismatched memoryKind bypasses to the create path (round N+2 B)", async () => {
+  // A time-specific (episode) fact into a note target: the merged record
+  // would keep `note`, so the incoming claims never reach the episode cache
+  // or the episode-only verification/promotion paths. The refusal is the
+  // documented rule — episode-cache membership follows the record's kind,
+  // and the create path stamps the kind it computed.
+  const episode = await harness({ targetMemoryKind: "note" });
+  const episodeOutcome = await applySemanticMergeAtPersist(episode.deps, {
+    storage: episode.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { memoryKind: "episode" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(episodeOutcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(episode.calls.contentUpdates, []);
+  assert.deepEqual(episode.calls.frontmatterPatches, []);
+
+  // The reverse: a stable note into an episode target would wrongly expose
+  // the merged claims through the episode-only paths.
+  const note = await harness({ targetMemoryKind: "episode" });
+  const noteOutcome = await applySemanticMergeAtPersist(note.deps, {
+    storage: note.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { memoryKind: "note" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(noteOutcome, { action: "created", reason: "metadata_unpreservable" });
+  assert.deepEqual(note.calls.contentUpdates, []);
+
+  // A kinded fact into an unkinded legacy target also bypasses: the merged
+  // record would carry no kind for claims the classifier did see.
+  const legacy = await harness();
+  const legacyOutcome = await applySemanticMergeAtPersist(legacy.deps, {
+    storage: legacy.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { memoryKind: "note" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.deepEqual(legacyOutcome, { action: "created", reason: "metadata_unpreservable" });
+});
+
+test("applySemanticMergeAtPersist: equal kinds and classification-off still merge (round N+2 B)", async () => {
+  const equal = await harness({ targetMemoryKind: "note" });
+  const equalOutcome = await applySemanticMergeAtPersist(equal.deps, {
+    storage: equal.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: { memoryKind: "note" },
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(equalOutcome.action, "merged");
+
+  // episodeNoteMode off: the incoming fact carries no kind, no episode path
+  // consults the field, and a kinded target keeps merging.
+  const off = await harness({ targetMemoryKind: "note" });
+  const offOutcome = await applySemanticMergeAtPersist(off.deps, {
+    storage: off.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    incomingMetadata: {},
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(offOutcome.action, "merged");
+});
+
+test("applySemanticMergeAtPersist: a cited merged body hashes as its raw pre-citation form (round N+2 C)", async () => {
+  const CITED_MERGED = `${MERGED} [Source: agent=test-agent, session=project/example/1, ts=2026-08-20T00:00:00Z]`;
+  const h = await harness({ topLevelConfig: { inlineSourceAttributionEnabled: true } });
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: async () => ({
+      decision: "merge",
+      targetId: "fact-target",
+      mergedContent: CITED_MERGED,
+      reason: "same cadence, citation retained from the stored target",
+    }),
+  });
+  assert.equal(outcome.action, "merged");
+  const stamped = h.calls.frontmatterPatches.at(-1)?.patch.contentHash;
+  // The ordinary write path hashes sanitizeMemoryContent(contentHashSource)
+  // — the raw fact body BEFORE any citation is attached (storage.ts).
+  const ordinaryWriteHash = ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text);
+  const citedFormHash = ContentHashIndex.computeHash(sanitizeMemoryContent(CITED_MERGED).text);
+  assert.equal(stamped, ordinaryWriteHash);
+  assert.notEqual(stamped, citedFormHash);
+});
+
+test("applySemanticMergeAtPersist: real storage dedups the raw equivalent of a cited merge (round N+2 C)", async () => {
+  const CITED_MERGED = `${MERGED} [Source: agent=test-agent, session=project/example/1, ts=2026-08-20T00:00:00Z]`;
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-cited-"));
+  const storage = new StorageManager(dir);
+  await storage.ensureDirectories();
+  const created = await storage.writeMemory("fact", EXISTING, { source: "test" });
+  const deps = {
+    config: parseConfig({
+      memoryDir: dir,
+      versioningEnabled: true,
+      inlineSourceAttributionEnabled: true,
+      semanticMerge: { enabled: true },
+    }),
+    getLocalLlm: () => null,
+    semanticDedupLookup: async () => [{ id: created.id, score: 0.85 }],
+    indexPersistedMemory: async () => {},
+  } as unknown as ExtractionPersistDeps;
+  const outcome = await applySemanticMergeAtPersist(deps, {
+    storage,
+    content: INCOMING,
+    category: "fact",
+    sources: [INCOMING_SOURCE],
+    judgeCall: async () => ({
+      decision: "merge",
+      targetId: created.id,
+      mergedContent: CITED_MERGED,
+      reason: "same cadence, citation retained",
+    }),
+  });
+  assert.equal(outcome.action, "merged");
+  // The raw-body identity is registered, so the equivalent raw fact dedups
+  // instead of fragmenting; the cited form is NOT a separate identity.
+  assert.equal(await storage.hasFactContentHash(MERGED), true);
+  assert.equal(await storage.hasFactContentHash(CITED_MERGED), false);
+});
+
+test("parseSemanticMergeConfig: present-but-unparseable maxCandidates throws; absent still defaults (round N+2 D)", () => {
+  for (const bad of [
+    "abc",
+    Number.NaN,
+    Number.POSITIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    { count: 3 },
+    null,
+  ]) {
+    assert.throws(
+      () => parseSemanticMergeConfig({ semanticMerge: { enabled: true, maxCandidates: bad } }),
+      /semanticMerge\.maxCandidates must be an integer >= 0/,
+      String(bad),
+    );
+  }
+  // Only an absent key takes the default; an unparseable value under
+  // enabled: true must not silently arm judge lookups at 3.
+  assert.equal(
+    parseSemanticMergeConfig({ semanticMerge: {} }).semanticMerge.maxCandidates,
+    DEFAULT_SEMANTIC_MERGE_CANDIDATES,
+  );
+  assert.equal(
+    parseSemanticMergeConfig({ semanticMerge: { maxCandidates: "12" } }).semanticMerge.maxCandidates,
+    12,
+  );
+});
+// ── Round N+7: trust gate, promotion reconciliation, citation, graph parity ──
+
+test("buildMergedTargetPromotionPayload: a degraded merge never yields a promotion payload (round N+7 A)", async () => {
+  // Patch fails AND rollback fails: the target holds the merged body with its
+  // OLD confidence/provenance/sources/hash. A payload built off that record
+  // would publish the merged claims under the target's stronger pre-merge
+  // metadata, so the payload builder must refuse the degraded outcome.
+  const h = await harness({ frontmatterFails: true, rollbackFails: true });
+  const degraded = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(degraded.action, "merged");
+  if (degraded.action !== "merged") return;
+  assert.equal(degraded.provenancePatched, false);
+  assert.equal(
+    await buildMergedTargetPromotionPayload(h.storage, degraded),
+    null,
+    "no shared/profile copy may be built from an unpatched provenance record",
+  );
+
+  // Positive control: a fully patched merge of the same shape still promotes.
+  const ok = await harness();
+  const patched = await applySemanticMergeAtPersist(ok.deps, {
+    storage: ok.storage,
+    content: INCOMING,
+    category: "fact",
+    judgeCall: (options) => acceptingJudge(options),
+  });
+  assert.equal(patched.action, "merged");
+  if (patched.action !== "merged") return;
+  assert.equal(patched.provenancePatched, true);
+  const payload = await buildMergedTargetPromotionPayload(ok.storage, patched);
+  assert.ok(payload);
+  assert.equal(payload?.sourceMemoryId, "fact-target");
+});
+
+test("buildMergedTargetPromotionPayload: a failed post-commit reread fails open to a logged null (round N+18 B)", async () => {
+  // The merge has already committed; the hash-index repair makes any retry
+  // dedupe against the committed body. A reread that throws here (secure
+  // store locked, corpus read I/O error) must degrade to "no promotion" —
+  // never abort the caller's remaining durable effects (thread episode,
+  // temporal/tag tracking, harmonic construction, graph rebuild, behavior
+  // signals, artifact write).
+  const entries: Array<{ level: string; message: string }> = [];
+  const backend: LoggerBackend = {
+    info: (msg: string) => entries.push({ level: "info", message: msg }),
+    warn: (msg: string) => entries.push({ level: "warn", message: msg }),
+    error: () => {},
+    debug: () => {},
+  };
+  initLogger(backend, true);
+  try {
+    const lockedStore = {
+      getMemoryByIdIncludingArchived: async () => {
+        throw new Error("secure store locked");
+      },
+    } as unknown as StorageManager;
+    const payload = await buildMergedTargetPromotionPayload(lockedStore, {
+      targetId: "fact-target",
+      mergedContent: "merged body",
+      provenancePatched: true,
+    });
+    assert.equal(payload, null, "a reread failure must resolve to null, not a rejection");
+    const line = entries.find(
+      (e) => e.level === "warn" && e.message.includes("semantic-merge") && e.message.includes("fact-target"),
+    )?.message;
+    assert.ok(line, "the skipped promotion must be surfaced as a warn");
+  } finally {
+    resetLogger();
+  }
+});
+
+test("applySemanticMergeAtPersist: the committed merged body preserves the incoming citation (round N+7 C)", async () => {
+  const OLD_CIT = "[Source: agent=agent-a, session=proj/s-old, ts=2026-08-19T00:00:00Z]";
+  const NEW_CIT = "[Source: agent=agent-a, session=proj/s-new, ts=2026-08-21T00:00:00Z]";
+  const h = await harness({ topLevelConfig: { inlineSourceAttributionEnabled: true } });
+  // The target carries an older citation from its original write; the judge's
+  // merged body embeds it. Without the incoming marker, the combined body
+  // reads as wholly attributed to the earlier source.
+  await h.setTargetContent(`${EXISTING} ${OLD_CIT}`);
+  const MERGED_WITH_OLD = `${MERGED} ${OLD_CIT}`;
+  const mergeOptions = {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    // The caller's single cited body for this write — the same string the
+    // verbatim artifact stores, so memory and artifact share one timestamp.
+    incomingCitedContent: `${INCOMING} ${NEW_CIT}`,
+    judgeCall: async () => ({
+      decision: "merge",
+      targetId: "fact-target",
+      mergedContent: MERGED_WITH_OLD,
+      reason: "same cadence, target citation embedded",
+    }),
+  } as ApplySemanticMergeOptions;
+  const outcome = await applySemanticMergeAtPersist(h.deps, mergeOptions);
+  assert.equal(outcome.action, "merged");
+  const committed = await h.storage.getMemoryByIdIncludingArchived("fact-target");
+  // BOTH attributions survive on the committed body.
+  assert.equal(committed?.content, `${MERGED_WITH_OLD} ${NEW_CIT}`);
+  if (outcome.action !== "merged") return;
+  assert.equal(outcome.mergedContent, `${MERGED_WITH_OLD} ${NEW_CIT}`);
+  // The hash rule survives too: identity stays on the RAW pre-citation body
+  // with BOTH markers stripped — never on the cited combined form.
+  const stamped = h.calls.frontmatterPatches.at(-1)?.patch.contentHash;
+  assert.equal(stamped, ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text));
+});
+
+// #2330 round N+8 (P2-C): a target written under the DEFAULT citation format
+// that later merges under a CUSTOM template carries BOTH markers on the
+// committed body. Canonicalization must strip every recognized form before
+// hashing — the default-only fast path left the custom timestamped marker in
+// the hash input, giving the merged record a different identity than the
+// equivalent raw write.
+test("applySemanticMergeAtPersist: mixed default+custom citation markers hash as the raw body (P2-C)", async () => {
+  const DEFAULT_CIT = "[Source: agent=agent-a, session=proj/s-old, ts=2026-08-19T00:00:00Z]";
+  const CUSTOM_TEMPLATE = "[src:{agent}/{sessionId}@{date}]";
+  const CUSTOM_CIT = "[src:agent-a/proj-s-new@2026-08-21]";
+  const h = await harness({
+    topLevelConfig: {
+      inlineSourceAttributionEnabled: true,
+      inlineSourceAttributionFormat: CUSTOM_TEMPLATE,
+    },
+  });
+  // The target carries the default-format marker from its original write; the
+  // incoming fact was cited with the now-configured custom template.
+  await h.setTargetContent(`${EXISTING} ${DEFAULT_CIT}`);
+  const MERGED_WITH_OLD = `${MERGED} ${DEFAULT_CIT}`;
+  const outcome = await applySemanticMergeAtPersist(h.deps, {
+    storage: h.storage,
+    content: INCOMING,
+    category: "fact",
+    incomingCitedContent: `${INCOMING} ${CUSTOM_CIT}`,
+    judgeCall: async () => ({
+      decision: "merge",
+      targetId: "fact-target",
+      mergedContent: MERGED_WITH_OLD,
+      reason: "same cadence, mixed citation templates",
+    }),
+  } as ApplySemanticMergeOptions);
+  assert.equal(outcome.action, "merged");
+  const committed = await h.storage.getMemoryByIdIncludingArchived("fact-target");
+  // BOTH attributions survive on the committed body.
+  assert.equal(committed?.content, `${MERGED_WITH_OLD} ${CUSTOM_CIT}`);
+  // Identity stays on the RAW pre-citation body with BOTH forms stripped.
+  const stamped = h.calls.frontmatterPatches.at(-1)?.patch.contentHash;
+  assert.equal(stamped, ContentHashIndex.computeHash(sanitizeMemoryContent(MERGED).text));
+});
+
+/** Minimal real-dir harness for the merged-target post-effects executor. */
+async function postEffectsHarness(options: {
+  graphEdgeThrows?: boolean;
+} = {}): Promise<{
+  deps: ExtractionPersistDeps;
+  storage: StorageManager;
+  dir: string;
+  targetRelPath: string;
+}> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-pe-"));
+  const factsDay = path.join(dir, "facts", "2026-08-20");
+  await mkdir(factsDay, { recursive: true });
+  const targetPath = path.join(factsDay, "fact-target.md");
+  await writeFile(
+    targetPath,
+    `---\nid: fact-target\ncategory: fact\nentityRef: entity-billing-service\n---\n\n${MERGED}\n`,
+    "utf8",
+  );
+  const storage = {
+    dir,
+    getMemoryByIdIncludingArchived: async (id: string) =>
+      id === "fact-target"
+        ? {
+            path: targetPath,
+            frontmatter: { id, category: "fact", entityRef: "entity-billing-service" },
+            content: MERGED,
+          }
+        : null,
+  } as unknown as StorageManager;
+  const deps = {
+    config: parseConfig({ memoryDir: dir }),
+    ...(options.graphEdgeThrows
+      ? {
+          buildGraphEdge: async () => {
+            throw new Error("graph append I/O failure");
+          },
+        }
+      : {}),
+  } as unknown as ExtractionPersistDeps;
+  return { deps, storage, dir, targetRelPath: path.relative(dir, targetPath) };
+}
+
+const ALL_GRAPH_CAPS = {
+  entityGraph: true,
+  timeGraph: true,
+  causalGraph: true,
+  multiGraphMemory: true,
+  graphWriteSessionAdjacency: false,
+} as const;
+
+async function seedGraphFile(dir: string, type: "entity" | "time" | "causal", edges: unknown[]) {
+  const graphsDir = path.join(dir, "state", "graphs");
+  await mkdir(graphsDir, { recursive: true });
+  await writeFile(
+    path.join(graphsDir, `${type}.jsonl`),
+    edges.map((e) => JSON.stringify(e)).join("\n") + "\n",
+    "utf8",
+  );
+}
+
+async function readGraphFile(dir: string, type: "entity" | "time" | "causal") {
+  try {
+    const raw = await readFile(path.join(dir, "state", "graphs", `${type}.jsonl`), "utf8");
+    return raw
+      .split("\n")
+      .filter((line) => line.trim().length > 0)
+      .map((line) => JSON.parse(line));
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+test("runMergedTargetPostEffects: a failing graph rebuild leaves the prior edges intact (round N+7 E)", async () => {
+  const h = await postEffectsHarness({ graphEdgeThrows: true });
+  const OTHER = "facts/2026-08-19/other.md";
+  const priorEntity = { from: h.targetRelPath, to: OTHER, type: "entity", weight: 1, label: "entity-billing-service", ts: "2026-08-19T00:00:00.000Z" };
+  const priorTime = { from: OTHER, to: h.targetRelPath, type: "time", weight: 1, label: "thread-0", ts: "2026-08-19T00:00:00.000Z" };
+  const priorCausal = { from: OTHER, to: h.targetRelPath, type: "causal", weight: 1, label: "because", ts: "2026-08-19T00:00:00.000Z" };
+  await seedGraphFile(h.dir, "entity", [priorEntity]);
+  await seedGraphFile(h.dir, "time", [priorTime]);
+  await seedGraphFile(h.dir, "causal", [priorCausal]);
+
+  await runMergedTargetPostEffects(h.deps, h.storage, { targetId: "fact-target", mergedContent: MERGED }, {
+    category: "fact",
+    incomingContent: INCOMING,
+    incomingConfidence: 0.9,
+    namespace: "default",
+    graphCaps: ALL_GRAPH_CAPS,
+    graphContext: { allMemsForGraph: [], memoryPathById: new Map() },
+    threadIdForEdge: undefined,
+    threadEpisodeIdsForGraph: undefined,
+  });
+
+  // Failure leaves the OLD complete set, never none: the target's generated
+  // edges in every enabled graph type survive the failed rebuild verbatim.
+  assert.deepEqual(await readGraphFile(h.dir, "entity"), [priorEntity]);
+  assert.deepEqual(await readGraphFile(h.dir, "time"), [priorTime]);
+  assert.deepEqual(await readGraphFile(h.dir, "causal"), [priorCausal]);
+});
+
+// #2330 round N+8 (P2-B): the production append failure must reach the
+// restore path. GraphIndex.onMemoryWritten used to swallow every append
+// error, so the caller's restore catch never ran and the edges
+// removeNodeEdgesForRewrite had dropped were permanently lost. The test
+// above fakes the failure at deps.buildGraphEdge; this one injects it at the
+// REAL seam — appendEdge's appendFile — by making the entity JSONL
+// read-only, and runs the real PersistenceIndexCoordinator → GraphIndex chain.
+test("runMergedTargetPostEffects: a REAL append failure restores prior edges at the GraphIndex seam (P2-B)", async () => {
+  if (process.getuid?.() === 0) {
+    // A root process may open a 0444 file for append, so the EACCES injection
+    // would not fail. CI runners and dev boxes run unprivileged; skip for root.
+    return;
+  }
+  const h = await postEffectsHarness();
+  const OTHER = "facts/2026-08-19/other.md";
+  const priorTime = { from: OTHER, to: h.targetRelPath, type: "time", weight: 1, label: "thread-0", ts: "2026-08-19T00:00:00.000Z" };
+  // An entity edge this node did NOT generate: removal skips writing
+  // entity.jsonl entirely, so the read-only mode survives until the append.
+  const unrelatedEntity = { from: OTHER, to: "facts/2026-08-18/unrelated.md", type: "entity", weight: 1, label: "entity-billing-service", ts: "2026-08-19T00:00:00.000Z" };
+  await seedGraphFile(h.dir, "entity", [unrelatedEntity]);
+  await seedGraphFile(h.dir, "time", [priorTime]);
+  const entityPath = path.join(h.dir, "state", "graphs", "entity.jsonl");
+  await chmod(entityPath, 0o444);
+  try {
+    const graphConfig = parseConfig({ memoryDir: h.dir });
+    const graphIndex = new GraphIndex(h.dir, graphConfig);
+    const coordinator = new PersistenceIndexCoordinator({
+      config: graphConfig,
+      graphIndexFor: () => graphIndex,
+    } as unknown as ConstructorParameters<typeof PersistenceIndexCoordinator>[0]);
+    const deps = {
+      ...h.deps,
+      // The REAL chain: runMergedTargetPostEffects → coordinator.buildGraphEdge
+      // → GraphIndex.onMemoryWritten → appendEdge. No stubbed seam anywhere.
+      buildGraphEdge: coordinator.buildGraphEdge.bind(coordinator),
+    } as unknown as ExtractionPersistDeps;
+    // A sibling sharing the target's entityRef makes the ENTITY append fire —
+    // the coordinator derives siblings from this corpus.
+    const sibling = {
+      path: path.join(h.dir, OTHER),
+      frontmatter: { id: "mem-sibling", category: "fact", entityRef: "entity-billing-service" },
+      content: "Sibling fact sharing the billing entity.",
+    } as unknown as MemoryFile;
+    await runMergedTargetPostEffects(
+      deps,
+      h.storage,
+      { targetId: "fact-target", mergedContent: MERGED },
+      {
+        category: "fact",
+        incomingContent: INCOMING,
+        incomingConfidence: 0.9,
+        namespace: "default",
+        graphCaps: ALL_GRAPH_CAPS,
+        graphContext: { allMemsForGraph: [sibling], memoryPathById: new Map() },
+        threadIdForEdge: undefined,
+        threadEpisodeIdsForGraph: undefined,
+      },
+    );
+    const timeEdges = await readGraphFile(h.dir, "time");
+    assert.ok(
+      timeEdges.some((e) => e.from === OTHER && e.to === h.targetRelPath),
+      `the prior time edges must be restored after the real append failure (time.jsonl: ${JSON.stringify(timeEdges)})`,
+    );
+    assert.deepEqual(
+      await readGraphFile(h.dir, "entity"),
+      [unrelatedEntity],
+      "no entity edge may land when the append fails",
+    );
+  } finally {
+    await chmod(entityPath, 0o644);
+  }
+});
+
+// #2330 round N+10 (C): the failure P2-B models strikes at the FIRST
+// append. Here the ENTITY append SUCCEEDS and the TIME append fails, so the
+// failed build has already written rows for this node. The restore loop used
+// to only add the removed old rows back, leaving old + partial-new edges
+// that spreadingActivation double-counts. Failure must leave EXACTLY the
+// old edge set — the partial new rows are removed before the restore.
+test("runMergedTargetPostEffects: a failure after a successful entity append leaves exactly the old edge set (round N+10 C)", async () => {
+  if (process.getuid?.() === 0) {
+    // Root may append to a 0444 file, so the EACCES injection cannot fail.
+    return;
+  }
+  const h = await postEffectsHarness();
+  const OTHER = "facts/2026-08-19/other.md";
+  // The target's OWN prior entity edge: removal drops it (restoring later).
+  const priorEntity = { from: h.targetRelPath, to: OTHER, type: "entity", weight: 1, label: "entity-billing-service", ts: "2026-08-19T00:00:00.000Z" };
+  // A time edge this node did NOT generate: removal skips rewriting
+  // time.jsonl entirely, so the read-only mode survives until the append.
+  const unrelatedTime = { from: "facts/2026-08-18/earlier.md", to: "facts/2026-08-18/earliest.md", type: "time", weight: 1, label: "thread-0", ts: "2026-08-19T00:00:00.000Z" };
+  await seedGraphFile(h.dir, "entity", [priorEntity]);
+  await seedGraphFile(h.dir, "time", [unrelatedTime]);
+  const timePath = path.join(h.dir, "state", "graphs", "time.jsonl");
+  await chmod(timePath, 0o444);
+  try {
+    const graphConfig = parseConfig({ memoryDir: h.dir });
+    const graphIndex = new GraphIndex(h.dir, graphConfig);
+    const coordinator = new PersistenceIndexCoordinator({
+      config: graphConfig,
+      graphIndexFor: () => graphIndex,
+    } as unknown as ConstructorParameters<typeof PersistenceIndexCoordinator>[0]);
+    const deps = {
+      ...h.deps,
+      // The REAL chain: runMergedTargetPostEffects → coordinator.buildGraphEdge
+      // → GraphIndex.onMemoryWritten → appendEdge. No stubbed seam anywhere.
+      buildGraphEdge: coordinator.buildGraphEdge.bind(coordinator),
+    } as unknown as ExtractionPersistDeps;
+    // A sibling sharing the target's entityRef makes the ENTITY append fire
+    // and succeed; the thread episode list makes the TIME append fire next
+    // and hit the read-only file.
+    const sibling = {
+      path: path.join(h.dir, OTHER),
+      frontmatter: { id: "mem-sibling", category: "fact", entityRef: "entity-billing-service" },
+      content: "Sibling fact sharing the billing entity.",
+    } as unknown as MemoryFile;
+    await runMergedTargetPostEffects(
+      deps,
+      h.storage,
+      { targetId: "fact-target", mergedContent: MERGED },
+      {
+        category: "fact",
+        incomingContent: INCOMING,
+        incomingConfidence: 0.9,
+        namespace: "default",
+        graphCaps: ALL_GRAPH_CAPS,
+        graphContext: {
+          allMemsForGraph: [sibling],
+          memoryPathById: new Map([["mem-earlier", OTHER]]),
+        },
+        threadIdForEdge: "thread-1",
+        threadEpisodeIdsForGraph: ["mem-earlier", "fact-target"],
+      },
+    );
+    assert.deepEqual(
+      await readGraphFile(h.dir, "entity"),
+      [priorEntity],
+      "exactly the old entity edge set may remain — the partially appended new edge must be removed, not left beside the restored old rows",
+    );
+    assert.deepEqual(
+      await readGraphFile(h.dir, "time"),
+      [unrelatedTime],
+      "the unrelated time edge survives untouched",
+    );
+  } finally {
+    await chmod(timePath, 0o644);
+  }
+});
+
+test("runMergedTargetPostEffects: a re-merge records the target as the LATEST thread event (round N+7 F)", async () => {
+  const h = await postEffectsHarness();
+  // The target is already in the thread's episode list (it was created there
+  // before this merge): the merge must move it to the end, not leave it at
+  // its old position.
+  const episodes = ["fact-target", "mem-earlier"];
+  await runMergedTargetPostEffects(h.deps, h.storage, { targetId: "fact-target", mergedContent: MERGED }, {
+    category: "fact",
+    incomingContent: INCOMING,
+    incomingConfidence: 0.9,
+    namespace: "default",
+    graphCaps: ALL_GRAPH_CAPS,
+    graphContext: { allMemsForGraph: [], memoryPathById: new Map() },
+    threadIdForEdge: "thread-1",
+    threadEpisodeIdsForGraph: episodes,
+  });
+  assert.deepEqual(episodes, ["mem-earlier", "fact-target"]);
+});
+
+// ── Round N+12 (C): the remove-and-rebuild stays guarded against a later
+// writer committing a NEWER merge between the committed-body check and the
+// final edge install. Writer A must not clobber writer B's edges. ────────────
+
+test("runMergedTargetPostEffects: a writer committing mid-rebuild keeps its edges — the stale writer restores, not installs (round N+12 C)", async () => {
+  const h = await postEffectsHarness();
+  const OTHER = "facts/2026-08-19/other.md";
+  // B's committed state: B already rebuilt the target's entity edge with the
+  // NEWER body's label. A's rebuild derives from the OLDER body.
+  const newerEntity = { from: h.targetRelPath, to: OTHER, type: "entity", weight: 1, label: "entity-billing-service-v2", ts: "2026-08-22T00:00:00.000Z" };
+  await seedGraphFile(h.dir, "entity", [newerEntity]);
+  const NEWER_BODY = "Billing service deploys run on Tuesdays at 09:00 UTC with payments.";
+  // A passes its committed-body check against A's body, then B commits AFTER
+  // the check: every read from the build onward observes B's newer body.
+  let buildGraphEdgeCalls = 0;
+  const storage = {
+    dir: h.dir,
+    getMemoryByIdIncludingArchived: async (id: string) =>
+      id === "fact-target"
+        ? {
+            path: path.join(h.dir, h.targetRelPath),
+            frontmatter: { id, category: "fact", entityRef: "entity-billing-service" },
+            // The flip: the initial check sees A's body; anything after the
+            // rebuild began sees B's committed body.
+            content: buildGraphEdgeCalls > 0 ? NEWER_BODY : MERGED,
+          }
+        : null,
+  } as unknown as StorageManager;
+  const deps = {
+    ...h.deps,
+    buildGraphEdge: async () => {
+      buildGraphEdgeCalls++;
+    },
+  } as unknown as ExtractionPersistDeps;
+  const previousPersisted = { current: "facts/2026-08-18/prev.md" };
+  await runMergedTargetPostEffects(
+    deps,
+    storage,
+    { targetId: "fact-target", mergedContent: MERGED },
+    {
+      category: "fact",
+      incomingContent: INCOMING,
+      incomingConfidence: 0.9,
+      namespace: "default",
+      graphCaps: ALL_GRAPH_CAPS,
+      graphContext: { allMemsForGraph: [], memoryPathById: new Map(), previousPersistedRelPath: previousPersisted.current },
+      threadIdForEdge: undefined,
+      threadEpisodeIdsForGraph: undefined,
+    },
+  );
+  assert.deepEqual(
+    await readGraphFile(h.dir, "entity"),
+    [newerEntity],
+    "writer A must restore B's newer edges, never install edges derived from A's older body",
+  );
+  assert.equal(
+    previousPersisted.current,
+    "facts/2026-08-18/prev.md",
+    "a superseded rebuild must not advance the batch's adjacency chain",
+  );
+});
+
+// ── Round N+14: a NEWER writer completing its rebuild INSIDE the stale
+// writer's remove→check window. B's rows land after A's removal, so they are
+// NOT in A's restore snapshot; the rollback must remove only the rows A's
+// build appended and must not resurrect the pre-A snapshot over B's live
+// rows. ────────────────────────────────────────────────────────────────────
+
+test("runMergedTargetPostEffects: a stale writer's rollback preserves the newer writer's rebuilt edges (round N+14)", async () => {
+  const h = await postEffectsHarness();
+  const OTHER = "facts/2026-08-19/other.md";
+  // The pre-A edge set: exactly what A's removal sweeps into its snapshot.
+  const priorEntity: GraphEdge = { from: h.targetRelPath, to: OTHER, type: "entity", weight: 1, label: "entity-billing-service", ts: "2026-08-19T00:00:00.000Z" };
+  await seedGraphFile(h.dir, "entity", [priorEntity]);
+  // B's completed rebuild, from B's newer body: a different label and B's own
+  // timestamp, appended DURING A's window — never captured by A's snapshot.
+  const bEntity: GraphEdge = { from: h.targetRelPath, to: OTHER, type: "entity", weight: 1, label: "entity-billing-service-v2", ts: "2026-08-22T01:00:00.000Z" };
+  const NEWER_BODY = "Billing service deploys run on Tuesdays at 09:00 UTC with payments.";
+  let buildStarted = false;
+  const storage = {
+    dir: h.dir,
+    getMemoryByIdIncludingArchived: async (id: string) =>
+      id === "fact-target"
+        ? {
+            path: path.join(h.dir, h.targetRelPath),
+            frontmatter: {
+              id,
+              category: "fact",
+              entityRef: "entity-billing-service",
+              // B's commit flips both the body and the revision once A's
+              // rebuild has begun: the initial committed-body check sees A's
+              // state, everything from the build onward sees B's.
+              ...(buildStarted ? { updated: "2026-08-22T01:00:00.000Z" } : {}),
+            },
+            content: buildStarted ? NEWER_BODY : MERGED,
+          }
+        : null,
+  } as unknown as StorageManager;
+  const graphConfig = parseConfig({ memoryDir: h.dir });
+  const graphIndex = new GraphIndex(h.dir, graphConfig);
+  const coordinator = new PersistenceIndexCoordinator({
+    config: graphConfig,
+    graphIndexFor: () => graphIndex,
+  } as unknown as ConstructorParameters<typeof PersistenceIndexCoordinator>[0]);
+  const realBuild = coordinator.buildGraphEdge.bind(coordinator);
+  const sibling = {
+    path: path.join(h.dir, OTHER),
+    frontmatter: { id: "mem-sibling", category: "fact", entityRef: "entity-billing-service" },
+    content: "Sibling fact sharing the billing entity.",
+  } as unknown as MemoryFile;
+  const deps = {
+    ...h.deps,
+    // The REAL chain for A's appends (so A's rows are exactly tracked), with
+    // B's completed rebuild injected at the start of A's build — after A's
+    // removal, before A's revision check.
+    buildGraphEdge: async (...args: Parameters<typeof realBuild>) => {
+      buildStarted = true;
+      await appendEdge(h.dir, { ...bEntity });
+      return realBuild(...args);
+    },
+  } as unknown as ExtractionPersistDeps;
+  await runMergedTargetPostEffects(
+    deps,
+    storage,
+    { targetId: "fact-target", mergedContent: MERGED },
+    {
+      category: "fact",
+      incomingContent: INCOMING,
+      incomingConfidence: 0.9,
+      namespace: "default",
+      graphCaps: ALL_GRAPH_CAPS,
+      graphContext: { allMemsForGraph: [sibling], memoryPathById: new Map() },
+      threadIdForEdge: undefined,
+      threadEpisodeIdsForGraph: undefined,
+    },
+  );
+  const entityEdges = await readGraphFile(h.dir, "entity");
+  assert.deepEqual(
+    entityEdges,
+    [bEntity],
+    `the graph must hold exactly B's rebuilt edges after the stale writer's rollback — no pre-A rows, no A rows (entity.jsonl: ${JSON.stringify(entityEdges)})`,
+  );
+});
+
+// ── Round N+16 (A): the N+14 surgical rollback leaned on build()'s RETURN
+// value. A build that THROWS mid-append (the entity rows landed, a later
+// append failed) loses that return, and the rollback fell back to the
+// node-wide sweep — which also deleted a NEWER writer's rebuild that
+// completed inside this writer's remove→rollback window. The partial row
+// set must be tracked incrementally, BEFORE build returns, and a throw must
+// roll back exactly that partial set. ─────────────────────────────────────
+
+test("runMergedTargetPostEffects: a THROWING build's rollback preserves the newer writer's rebuilt edges (round N+16 A)", async () => {
+  if (process.getuid?.() === 0) {
+    // Root may append to a 0444 file, so the EACCES injection cannot fail.
+    return;
+  }
+  const h = await postEffectsHarness();
+  const OTHER = "facts/2026-08-19/other.md";
+  // A's pre-state: exactly what A's removal sweeps into its snapshot.
+  const priorEntity: GraphEdge = { from: h.targetRelPath, to: OTHER, type: "entity", weight: 1, label: "entity-billing-service", ts: "2026-08-19T00:00:00.000Z" };
+  await seedGraphFile(h.dir, "entity", [priorEntity]);
+  // An unrelated time edge keeps time.jsonl untouched by the removal, so its
+  // read-only mode survives until the append (same injection as round N+10 C).
+  const unrelatedTime = { from: "facts/2026-08-18/earlier.md", to: "facts/2026-08-18/earliest.md", type: "time", weight: 1, label: "thread-0", ts: "2026-08-19T00:00:00.000Z" };
+  await seedGraphFile(h.dir, "time", [unrelatedTime]);
+  // B's completed rebuild, from B's newer body — appended AFTER A's removal
+  // (never in A's restore snapshot), BEFORE A's failing append.
+  const bEntity: GraphEdge = { from: h.targetRelPath, to: OTHER, type: "entity", weight: 1, label: "entity-billing-service-v2", ts: "2026-08-22T01:00:00.000Z" };
+  const timePath = path.join(h.dir, "state", "graphs", "time.jsonl");
+  await chmod(timePath, 0o444);
+  try {
+    const graphConfig = parseConfig({ memoryDir: h.dir });
+    const graphIndex = new GraphIndex(h.dir, graphConfig);
+    const coordinator = new PersistenceIndexCoordinator({
+      config: graphConfig,
+      graphIndexFor: () => graphIndex,
+    } as unknown as ConstructorParameters<typeof PersistenceIndexCoordinator>[0]);
+    const realBuild = coordinator.buildGraphEdge.bind(coordinator);
+    const sibling = {
+      path: path.join(h.dir, OTHER),
+      frontmatter: { id: "mem-sibling", category: "fact", entityRef: "entity-billing-service" },
+      content: "Sibling fact sharing the billing entity.",
+    } as unknown as MemoryFile;
+    const deps = {
+      ...h.deps,
+      // The REAL chain for A's appends: B's completed rebuild lands first,
+      // then A's entity append SUCCEEDS and the time append THROWS (EACCES) —
+      // a build that wrote rows and still rejects.
+      buildGraphEdge: async (...args: Parameters<typeof realBuild>) => {
+        await appendEdge(h.dir, { ...bEntity });
+        return realBuild(...args);
+      },
+    } as unknown as ExtractionPersistDeps;
+    await runMergedTargetPostEffects(
+      deps,
+      h.storage,
+      { targetId: "fact-target", mergedContent: MERGED },
+      {
+        category: "fact",
+        incomingContent: INCOMING,
+        incomingConfidence: 0.9,
+        namespace: "default",
+        graphCaps: ALL_GRAPH_CAPS,
+        graphContext: {
+          allMemsForGraph: [sibling],
+          memoryPathById: new Map([["mem-earlier", OTHER]]),
+        },
+        threadIdForEdge: "thread-1",
+        threadEpisodeIdsForGraph: ["mem-earlier", "fact-target"],
+      },
+    );
+    const entityEdges = await readGraphFile(h.dir, "entity");
+    assert.deepEqual(
+      entityEdges,
+      [bEntity],
+      `the throwing build's rollback must remove only its own partial rows and never sweep the newer writer's rebuild (entity.jsonl: ${JSON.stringify(entityEdges)})`,
+    );
+    assert.deepEqual(
+      await readGraphFile(h.dir, "time"),
+      [unrelatedTime],
+      "the unrelated time edge survives the throwing build untouched",
+    );
+  } finally {
+    await chmod(timePath, 0o644);
+  }
+});
+
+test("persistMergedTargetThreadEpisode: a re-merge moves an existing earlier target to the durable thread tail (round N+12 D)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-merge-thread-"));
+  try {
+    const threading = new ThreadingManager(path.join(dir, "threads"), 90);
+    const threadId = "thread-1";
+    await threading.saveThread({
+      id: threadId,
+      title: "Billing deploys",
+      createdAt: "2026-08-20T00:00:00.000Z",
+      updatedAt: "2026-08-20T00:00:00.000Z",
+      episodeIds: ["fact-target", "mem-earlier"],
+      linkedThreadIds: [],
+    });
+    await persistMergedTargetThreadEpisode(threading, threadId, "fact-target");
+    // The next extraction reloads the thread from disk — the reloaded order
+    // is what resolveRecentThreadMemoryPaths(...).slice(-3) will see.
+    const reloaded = await threading.loadThread(threadId);
+    assert.deepEqual(
+      reloaded?.episodeIds,
+      ["mem-earlier", "fact-target"],
+      "a re-merged target must sit at the durable thread tail after reload",
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});