@remnic/core 9.45.1 → 9.45.3

package/dist/schemas.d.ts

@@ -290,12 +290,12 @@ declare const EntityMentionSchema: z.ZodObject<{
         title: z.ZodString;
         facts: z.ZodArray<z.ZodString, "many">;
     }, "strip", z.ZodTypeAny, {
-        title: string;
         key: string;
+        title: string;
         facts: string[];
     }, {
-        title: string;
         key: string;
+        title: string;
         facts: string[];
     }>, "many">>>;
 }, "strip", z.ZodTypeAny, {
@@ -303,8 +303,8 @@ declare const EntityMentionSchema: z.ZodObject<{
     name: string;
     facts: string[];
     structuredSections?: {
-        title: string;
         key: string;
+        title: string;
         facts: string[];
     }[] | null | undefined;
     promptedByQuestion?: string | null | undefined;
@@ -313,8 +313,8 @@ declare const EntityMentionSchema: z.ZodObject<{
     name: string;
     facts: string[];
     structuredSections?: {
-        title: string;
         key: string;
+        title: string;
         facts: string[];
     }[] | null | undefined;
     promptedByQuestion?: string | null | undefined;
@@ -614,12 +614,12 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
             title: z.ZodString;
             facts: z.ZodArray<z.ZodString, "many">;
         }, "strip", z.ZodTypeAny, {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }, {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }>, "many">>>;
     }, "strip", z.ZodTypeAny, {
@@ -627,8 +627,8 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -637,8 +637,8 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -698,8 +698,8 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -750,8 +750,8 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1003,12 +1003,12 @@ declare const ExtractionResultSchema: z.ZodObject<{
             title: z.ZodString;
             facts: z.ZodArray<z.ZodString, "many">;
         }, "strip", z.ZodTypeAny, {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }, {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }>, "many">>>;
     }, "strip", z.ZodTypeAny, {
@@ -1016,8 +1016,8 @@ declare const ExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1026,8 +1026,8 @@ declare const ExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1106,8 +1106,8 @@ declare const ExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1164,8 +1164,8 @@ declare const ExtractionResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1229,12 +1229,12 @@ declare const ConsolidationResultSchema: z.ZodObject<{
             title: z.ZodString;
             facts: z.ZodArray<z.ZodString, "many">;
         }, "strip", z.ZodTypeAny, {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }, {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }>, "many">>>;
     }, "strip", z.ZodTypeAny, {
@@ -1242,8 +1242,8 @@ declare const ConsolidationResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1252,8 +1252,8 @@ declare const ConsolidationResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1272,8 +1272,8 @@ declare const ConsolidationResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;
@@ -1292,8 +1292,8 @@ declare const ConsolidationResultSchema: z.ZodObject<{
         name: string;
         facts: string[];
         structuredSections?: {
-            title: string;
             key: string;
+            title: string;
             facts: string[];
         }[] | null | undefined;
         promptedByQuestion?: string | null | undefined;

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     version: string;
     description: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     version: string;
     description: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -815,13 +815,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -854,13 +854,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.45.1",
+  "version": "9.45.3",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3106,7 +3106,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.45.1"
+    "@remnic/coding-graph": "^9.45.3"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/converge-conflict-policy-type.test.ts

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { ReconcileConflictPolicy } from "./reconcile/plan.js";
+import type { ConvergeConflictPolicy } from "./types.js";
+
+type Equal<Left, Right> = (<Value>() => Value extends Left ? 1 : 2) extends <Value>() => Value extends Right ? 1 : 2
+  ? true
+  : false;
+
+const conflictPolicyNamesAreEquivalent: Equal<ReconcileConflictPolicy, ConvergeConflictPolicy> = true;
+
+test("ReconcileConflictPolicy remains a type alias for ConvergeConflictPolicy", () => {
+  assert.equal(conflictPolicyNamesAreEquivalent, true);
+});

package/src/reconcile/cursor.test.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { test } from "node:test";
 import {
   defaultConvergeCursorPath,
+  deriveConvergeCursorBase,
   hashPeerNamespace,
   normalizeConvergeCursor,
   readConvergeCursor,
@@ -13,6 +14,7 @@ import {
 } from "./cursor.js";
 
 const shaA = "a".repeat(64);
+const shaB = "b".repeat(64);
 
 test("hashPeerNamespace: deterministic key normalization", () => {
   const k1 = hashPeerNamespace("http://peer.example.com/", "default");
@@ -46,6 +48,18 @@ test("defaultConvergeCursorPath: constructs path under memoryDir state", () => {
   assert.ok(p.endsWith(".json"));
 });
 
+test("deriveConvergeCursorBase retains a deferred semantic agreement", () => {
+  const semanticAgreement = {
+    local: { path: "facts/local.md", sha256: shaA },
+    peer: { path: "facts/peer.md", sha256: shaB },
+  };
+
+  assert.deepEqual(
+    deriveConvergeCursorBase([], "default", [semanticAgreement]).semanticAgreements,
+    [semanticAgreement]
+  );
+});
+
 test("normalizeConvergeCursor: validates envelope shape", () => {
   assert.throws(() => normalizeConvergeCursor(null), /must be an object/);
   assert.throws(() => normalizeConvergeCursor({ version: 2 }), /version must be 1/);
@@ -63,11 +77,19 @@ test("normalizeConvergeCursor: validates envelope shape", () => {
     peerUrl: "http://peer",
     namespace: "default",
     baseFiles: [{ path: "a.md", sha256: shaA }],
+    semanticAgreements: [{
+      local: { path: "facts/local.md", sha256: shaA },
+      peer: { path: "facts/peer.md", sha256: shaB },
+    }],
   });
   assert.equal(valid.peerUrl, "http://peer");
   assert.equal(valid.namespace, "default");
   assert.equal(valid.baseFiles.length, 1);
   assert.equal(valid.baseFiles[0]?.path, "a.md");
+  assert.deepEqual(valid.semanticAgreements, [{
+    local: { path: "facts/local.md", sha256: shaA },
+    peer: { path: "facts/peer.md", sha256: shaB },
+  }]);
 });
 
 test("readConvergeCursor: returns null when file is missing or invalid", async () => {
@@ -96,6 +118,10 @@ test("writeConvergeCursor & readConvergeCursor: atomic write roundtrip", async (
       lastConvergedAt: new Date().toISOString(),
       baseFiles: [{ path: "facts/a.md", sha256: shaA, bytes: 120, mtimeMs: 1000 }],
       completedPaths: ["facts/a.md"],
+      semanticAgreements: [{
+        local: { path: "facts/local.md", sha256: shaA },
+        peer: { path: "facts/peer.md", sha256: shaB },
+      }],
     };
 
     await writeConvergeCursor(cursorPath, cursor);
@@ -106,6 +132,10 @@ test("writeConvergeCursor & readConvergeCursor: atomic write roundtrip", async (
     assert.equal(read.baseFiles.length, 1);
     assert.equal(read.baseFiles[0]?.sha256, shaA);
     assert.deepEqual(read.completedPaths, ["facts/a.md"]);
+    assert.deepEqual(read.semanticAgreements, [{
+      local: { path: "facts/local.md", sha256: shaA },
+      peer: { path: "facts/peer.md", sha256: shaB },
+    }]);
 
     // Update existing cursor atomically
     const updated: ConvergeCursorState = {

package/src/reconcile/cursor.ts

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import type { ReconcilePlanEntry, ReconcileSemanticAgreement } from "./plan.js";
 
 export interface ConvergeCursorFileState {
   path: string;
@@ -15,6 +16,7 @@ export interface ConvergeCursorState {
   namespace: string;
   lastConvergedAt?: string;
   baseFiles: ConvergeCursorFileState[];
+  semanticAgreements?: ReconcileSemanticAgreement[];
   completedPaths?: string[];
 }
 
@@ -48,6 +50,56 @@ export function defaultConvergeCursorPath(
   return path.join(path.resolve(memoryDir), ".remnic", "state", "converge-cursors", `${key}.json`);
 }
 
+function normalizeSemanticFileState(input: unknown): { path: string; sha256: string } | undefined {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return undefined;
+  const file = input as Record<string, unknown>;
+  if (typeof file.path !== "string" || typeof file.sha256 !== "string") return undefined;
+  return { path: file.path, sha256: file.sha256 };
+}
+
+function digestAfterReconcile(entry: ReconcilePlanEntry): string | undefined {
+  if (entry.action === "push") return entry.localSha256;
+  if (entry.action === "pull") return entry.peerSha256;
+  if (entry.action === "conflict") {
+    if (entry.resolution === "local-wins") return entry.localSha256;
+    if (entry.resolution === "peer-wins") return entry.peerSha256;
+    return undefined;
+  }
+  if (entry.action !== "identical") return undefined;
+  if (entry.localSha256 && entry.peerSha256 && entry.localSha256 !== entry.peerSha256) return undefined;
+  return entry.localSha256 ?? entry.peerSha256;
+}
+
+function semanticAgreementKey(agreement: ReconcileSemanticAgreement): string {
+  return `${agreement.local.path}\0${agreement.peer.path}`;
+}
+
+export function deriveConvergeCursorBase(
+  entries: readonly ReconcilePlanEntry[],
+  namespace: string,
+  priorSemanticAgreements: readonly ReconcileSemanticAgreement[] = [],
+): Pick<ConvergeCursorState, "baseFiles" | "semanticAgreements"> {
+  const baseFiles: ConvergeCursorFileState[] = [];
+  const semanticAgreementsByPathPair = new Map(
+    priorSemanticAgreements.map((agreement) => [semanticAgreementKey(agreement), agreement])
+  );
+  for (const entry of entries) {
+    if (entry.namespace !== namespace) continue;
+    if (entry.semanticAgreement) {
+      semanticAgreementsByPathPair.set(semanticAgreementKey(entry.semanticAgreement), entry.semanticAgreement);
+      continue;
+    }
+    const sha256 = digestAfterReconcile(entry);
+    if (sha256) baseFiles.push({ path: entry.path, sha256 });
+  }
+  baseFiles.sort((left, right) => left.path.localeCompare(right.path));
+  const semanticAgreements = [...semanticAgreementsByPathPair.values()];
+  semanticAgreements.sort((left, right) =>
+    left.local.path.localeCompare(right.local.path) || left.peer.path.localeCompare(right.peer.path)
+  );
+  return { baseFiles, semanticAgreements };
+}
+
 export function normalizeConvergeCursor(input: unknown): ConvergeCursorState {
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     throw new Error("converge cursor must be an object");
@@ -78,6 +130,16 @@ export function normalizeConvergeCursor(input: unknown): ConvergeCursorState {
       }
     }
   }
+  const semanticAgreements: ReconcileSemanticAgreement[] = [];
+  if (Array.isArray(obj.semanticAgreements)) {
+    for (const item of obj.semanticAgreements) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+      const agreement = item as Record<string, unknown>;
+      const local = normalizeSemanticFileState(agreement.local);
+      const peer = normalizeSemanticFileState(agreement.peer);
+      if (local && peer) semanticAgreements.push({ local, peer });
+    }
+  }
   const completedPaths: string[] = [];
   if (Array.isArray(obj.completedPaths)) {
     for (const item of obj.completedPaths) {
@@ -92,6 +154,7 @@ export function normalizeConvergeCursor(input: unknown): ConvergeCursorState {
     namespace: obj.namespace.trim(),
     lastConvergedAt: typeof obj.lastConvergedAt === "string" ? obj.lastConvergedAt : undefined,
     baseFiles,
+    semanticAgreements,
     completedPaths,
   };
 }

package/src/reconcile/manifest.test.ts

@@ -132,8 +132,11 @@ test("semantic collapse prevents different active fact paths from transferring b
       namespace: "default",
       action: "identical",
       reason: "semantic_duplicate",
-      localSha256: localFile.sha256,
-      peerSha256: peerFile.sha256,
+      semanticAgreement: {
+        local: localFile,
+        peer: peerFile,
+      },
+      semanticChange: "unchanged",
     },
   ]);
   assert.equal(collapsed.byNamespace[0]?.identical, 1);
@@ -141,6 +144,51 @@ test("semantic collapse prevents different active fact paths from transferring b
   assert.equal(collapsed.byNamespace[0]?.push, 0);
 });
 
+test("semantic collapse classifies a later one-sided metadata edit from its per-side base", () => {
+  const semanticHash = ContentHashIndex.computeHash("same active fact");
+  const priorLocal = { path: "facts/local-id.md", sha256: "a".repeat(64) };
+  const currentLocal = { ...priorLocal, sha256: "c".repeat(64) };
+  const peerFile = { path: "facts/peer-id.md", sha256: "b".repeat(64) };
+  const manifest = (file: typeof currentLocal): ReconcileManifest => ({
+    format: "remnic-reconcile-manifest",
+    schemaVersion: 1,
+    files: [{
+      ...file,
+      memory: {
+        id: file.path,
+        category: "fact",
+        contentHash: semanticHash,
+        status: "active",
+      },
+    }],
+  });
+  const plan = planReconciliation([{
+    namespace: "default",
+    local: [currentLocal],
+    peer: [peerFile],
+  }]);
+
+  const collapsed = collapseActiveFactDuplicates(
+    plan,
+    new Map([["default", manifest(currentLocal)]]),
+    new Map([["default", manifest(peerFile)]]),
+    new Map([["default", [{ local: priorLocal, peer: peerFile }]]])
+  );
+
+  assert.deepEqual(collapsed.entries, [{
+    path: currentLocal.path,
+    namespace: "default",
+    action: "identical",
+    reason: "semantic_duplicate",
+    semanticAgreement: {
+      local: currentLocal,
+      peer: peerFile,
+    },
+    semanticChange: "local_changed",
+  }]);
+  assert.equal(collapsed.converged, true);
+});
+
 test("semantic collapse does not fold non-active facts or unrelated path conflicts", () => {
   const semanticHash = ContentHashIndex.computeHash("same inactive fact");
   const localFile = { path: "facts/local.md", sha256: "a".repeat(64) };
@@ -215,6 +263,49 @@ test("semantic collapse preserves same-path metadata updates", () => {
   assert.equal(collapsed.entries[0]?.action, "push");
 });
 
+test("semantic collapse preserves a shared-path metadata update when peer canonical path differs", () => {
+  const semanticHash = ContentHashIndex.computeHash("same raw fact");
+  const sharedLocal = { path: "facts/b.md", sha256: "a".repeat(64) };
+  const sharedPeer = { path: "facts/b.md", sha256: "b".repeat(64) };
+  const peerDuplicate = { path: "facts/a.md", sha256: "c".repeat(64) };
+  const plan = planReconciliation([{
+    namespace: "default",
+    local: [sharedLocal],
+    peer: [peerDuplicate, sharedPeer],
+    base: [{ path: sharedPeer.path, sha256: sharedPeer.sha256 }],
+  }]);
+  const manifest = (files: Array<{ path: string; sha256: string }>): ReconcileManifest => ({
+    format: "remnic-reconcile-manifest",
+    schemaVersion: 1,
+    files: files.map((file) => ({
+      ...file,
+      memory: {
+        id: file.path,
+        category: "fact",
+        contentHash: semanticHash,
+        status: "active",
+      },
+    })),
+  });
+
+  const collapsed = collapseActiveFactDuplicates(
+    plan,
+    new Map([["default", manifest([sharedLocal])]]),
+    new Map([["default", manifest([peerDuplicate, sharedPeer])]])
+  );
+
+  assert.deepEqual(collapsed.entries, [{
+    path: sharedLocal.path,
+    namespace: "default",
+    action: "push",
+    reason: "local_changed",
+    localSha256: sharedLocal.sha256,
+    peerSha256: sharedPeer.sha256,
+    baseSha256: sharedPeer.sha256,
+  }]);
+  assert.equal(collapsed.converged, false);
+});
+
 test("semantic collapse remains converged after transferring the canonical one-sided duplicate", () => {
   const semanticHash = ContentHashIndex.computeHash("same one-sided fact");
   const canonical = { path: "facts/a.md", sha256: "a".repeat(64) };