@remnic/core 9.45.0 → 9.45.2

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export { aS as AccessTrackingEntry, a1 as ActiveRecallChatType, a5 as ActiveRecallModelFallbackPolicy, a3 as ActiveRecallPromptStyle, a2 as ActiveRecallQueryMode, a4 as ActiveRecallThinking, t as AgentAccessAuthToken, co as AgentAccessHttpConfig, cp as AgentDefaultsConfig, cq as AgentPersona, A as AgentPersonaModelConfig, cr as BehaviorLoopAdjustment, r as BehaviorLoopPolicyState, cs as BehaviorSignalDirection, a6 as BehaviorSignalEvent, ct as BehaviorSignalType, bb as BootstrapOptions, bc as BootstrapResult, g as BriefingActiveThread, cu as BriefingCalendarSourceError, bw as BriefingConfig, e as BriefingFocus, d as BriefingFollowup, bx as BriefingOpenCommitment, i as BriefingRecentEntity, h as BriefingResult, B as BriefingSections, by as BriefingWindow, cv as BufferEntryState, aO as BufferState, a7 as BufferSurpriseEvent, j as BufferTurn, f as CalendarEvent, C as CalendarSource, w as CaptureMode, cw as ChatConfig, m as Checkpoint, cx as CodexCliReasoningEffort, cy as CodexCompactionFlushMode, bB as CodexCompatConfig, cz as CodexConnectorConfig, b8 as CodingContext, cA as CodingGraphLspConfig, bk as CodingKnowledgeConfig, be as CodingModeConfig, cB as CompressionGuidelineActivationState, ad as CompressionGuidelineOptimizerActionSummary, ac as CompressionGuidelineOptimizerEventCounts, ae as CompressionGuidelineOptimizerRuleUpdate, cC as CompressionGuidelineOptimizerSourceWindow, ah as CompressionGuidelineOptimizerState, cD as ConfidenceTier, cE as ConsolidationAction, cF as ConsolidationItem, bd as ConsolidationObservation, K as ConsolidationResult, cG as ContradictionScanConfig, V as ConversationThread, cH as CronConversationRecallMode, cI as CronRecallMode, bC as DEFAULT_RECALL_DISCLOSURE, N as DaySummaryResult, cJ as DreamingConfig, cK as DreamingNarrativePromptStyle, cL as DreamsDeepSleepConfig, cM as DreamsLightSleepConfig, D as DreamsPhase, cN as DreamsPhaseStatus, cO as DreamsPhasesConfig, cP as DreamsRemConfig, a as DreamsRunResult, b9 as DreamsStatusResult, cQ as EngramTraceEvent, aR as EntityActivityEntry, E as EntityFile, ai as EntityMention, aQ as EntityRelationship, aj as EntitySchemaDefinition, ak as EntitySchemaSectionDefinition, al as EntityStructuredSection, aM as EntityTimelineEntry, bE as ExtractedFact, cR as ExtractedProcedureStep, cS as ExtractedQuestion, cT as ExtractedReasoningTrace, cU as ExtractedReasoningTraceStep, cV as ExtractedRelationship, $ as ExtractionFailureClass, cW as ExtractionPassSource, J as ExtractionResult, F as FaithfulnessFrontmatter, aP as FileHygieneConfig, G as GatewayConfig, cX as GitHubLiveConnectorConfig, cY as GmailLiveConnectorConfig, cZ as GoogleDriveLiveConnectorConfig, c_ as HeartbeatConfig, c$ as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, a0 as ImportanceLevel, an as ImportanceScore, W as LifecycleState, L as LiveConnectorsConfig, d0 as LlmTraceCallback, d1 as LlmTraceEvent, ap as MemoryActionEligibilityContext, bN as MemoryActionEligibilitySource, ag as MemoryActionEvent, d2 as MemoryActionOutcome, d3 as MemoryActionPolicyDecision, aq as MemoryActionPolicyResult, d4 as MemoryActionStatus, af as MemoryActionType, v as MemoryCategory, M as MemoryFile, l as MemoryFrontmatter, ao as MemoryIntent, z as MemoryLifecycleEvent, ar as MemoryLifecycleEventType, as as MemoryLifecycleStateSummary, aN as MemoryLink, d5 as MemoryLinkType, bO as MemoryObservation, d6 as MemoryOsPresetName, y as MemoryProjectionCurrentState, bP as MemoryScope, x as MemoryStatus, aT as MemorySummary, aw as MetaState, d7 as ModelApi, d8 as ModelDefinitionConfig, d9 as ModelProviderAuthMode, at as ModelProviderConfig, da as NamespacePolicy, au as NativeKnowledgeConfig, db as NativeKnowledgeFolderRuleConfig, dc as NativeKnowledgeObsidianVaultConfig, dd as NativeKnowledgeOpenClawWorkspaceConfig, de as NotionLiveConnectorConfig, P as PluginConfig, Y as PolicyClass, df as PrincipalFromSessionKeyMode, dg as PrincipalRule, dh as ProceduralConfig, am as ProvenanceConfig, O as ProvenanceSource, aB as QmdSearchExplain, Q as QmdSearchResult, di as QuestionEntry, bQ as RECALL_DISCLOSURE_LEVELS, dj as ReasoningEffort, b as RecallDisclosure, dk as RecallPipelineConfig, R as RecallPlanMode, ba as RecallSectionConfig, c as RecallTierExplain, dl as RecallTraceEvent, dm as RelevanceFeedback, ay as RetrievalTier, dn as SPECULATIVE_TTL_DAYS, dp as ScopeProfileAutoPromoteConfig, o as ScopeProfileConfig, p as ScopeProfileLayerId, q as ScopeProfilePromotionTarget, dq as ScopeProfileTeamProjectConfig, dr as ScopeTeamConfig, ds as ScoredEntity, s as SecretRef, dt as SemanticChunkingConfigShape, S as SessionObserverBandConfig, du as SignalLevel, az as SignalScanResult, dv as SlotBehaviorConfig, dw as SlotMismatchMode, n as SourceConnectorProvenance, aA as TopicScore, T as TranscriptEntry, dx as TriggerMode, U as TrustWeights, X as VerificationState, dy as confidenceTier, bY as isRecallDisclosure } from './types-CqWwMPr_.js';
+export { aU as AccessTrackingEntry, a1 as ActiveRecallChatType, a5 as ActiveRecallModelFallbackPolicy, a3 as ActiveRecallPromptStyle, a2 as ActiveRecallQueryMode, a4 as ActiveRecallThinking, t as AgentAccessAuthToken, cq as AgentAccessHttpConfig, cr as AgentDefaultsConfig, cs as AgentPersona, A as AgentPersonaModelConfig, ct as BehaviorLoopAdjustment, r as BehaviorLoopPolicyState, cu as BehaviorSignalDirection, a6 as BehaviorSignalEvent, cv as BehaviorSignalType, bd as BootstrapOptions, be as BootstrapResult, g as BriefingActiveThread, cw as BriefingCalendarSourceError, by as BriefingConfig, e as BriefingFocus, d as BriefingFollowup, bz as BriefingOpenCommitment, i as BriefingRecentEntity, h as BriefingResult, B as BriefingSections, bA as BriefingWindow, cx as BufferEntryState, aQ as BufferState, a7 as BufferSurpriseEvent, j as BufferTurn, f as CalendarEvent, C as CalendarSource, w as CaptureMode, cy as ChatConfig, m as Checkpoint, cz as CodexCliReasoningEffort, cA as CodexCompactionFlushMode, bD as CodexCompatConfig, cB as CodexConnectorConfig, ba as CodingContext, cC as CodingGraphLspConfig, bm as CodingKnowledgeConfig, bg as CodingModeConfig, cD as CompressionGuidelineActivationState, ad as CompressionGuidelineOptimizerActionSummary, ac as CompressionGuidelineOptimizerEventCounts, ae as CompressionGuidelineOptimizerRuleUpdate, cE as CompressionGuidelineOptimizerSourceWindow, ah as CompressionGuidelineOptimizerState, cF as ConfidenceTier, cG as ConsolidationAction, cH as ConsolidationItem, bf as ConsolidationObservation, K as ConsolidationResult, cI as ContradictionScanConfig, aj as ConvergeConfig, ai as ConvergeConflictPolicy, V as ConversationThread, cJ as CronConversationRecallMode, cK as CronRecallMode, bE as DEFAULT_RECALL_DISCLOSURE, N as DaySummaryResult, cL as DreamingConfig, cM as DreamingNarrativePromptStyle, cN as DreamsDeepSleepConfig, cO as DreamsLightSleepConfig, D as DreamsPhase, cP as DreamsPhaseStatus, cQ as DreamsPhasesConfig, cR as DreamsRemConfig, a as DreamsRunResult, bb as DreamsStatusResult, cS as EngramTraceEvent, aT as EntityActivityEntry, E as EntityFile, ak as EntityMention, aS as EntityRelationship, al as EntitySchemaDefinition, am as EntitySchemaSectionDefinition, an as EntityStructuredSection, aO as EntityTimelineEntry, bG as ExtractedFact, cT as ExtractedProcedureStep, cU as ExtractedQuestion, cV as ExtractedReasoningTrace, cW as ExtractedReasoningTraceStep, cX as ExtractedRelationship, $ as ExtractionFailureClass, cY as ExtractionPassSource, J as ExtractionResult, F as FaithfulnessFrontmatter, aR as FileHygieneConfig, G as GatewayConfig, cZ as GitHubLiveConnectorConfig, c_ as GmailLiveConnectorConfig, c$ as GoogleDriveLiveConnectorConfig, d0 as HeartbeatConfig, d1 as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, a0 as ImportanceLevel, ap as ImportanceScore, W as LifecycleState, L as LiveConnectorsConfig, d2 as LlmTraceCallback, d3 as LlmTraceEvent, ar as MemoryActionEligibilityContext, bP as MemoryActionEligibilitySource, ag as MemoryActionEvent, d4 as MemoryActionOutcome, d5 as MemoryActionPolicyDecision, as as MemoryActionPolicyResult, d6 as MemoryActionStatus, af as MemoryActionType, v as MemoryCategory, M as MemoryFile, l as MemoryFrontmatter, aq as MemoryIntent, z as MemoryLifecycleEvent, at as MemoryLifecycleEventType, au as MemoryLifecycleStateSummary, aP as MemoryLink, d7 as MemoryLinkType, bQ as MemoryObservation, d8 as MemoryOsPresetName, y as MemoryProjectionCurrentState, bR as MemoryScope, x as MemoryStatus, aV as MemorySummary, ay as MetaState, d9 as ModelApi, da as ModelDefinitionConfig, db as ModelProviderAuthMode, av as ModelProviderConfig, dc as NamespacePolicy, aw as NativeKnowledgeConfig, dd as NativeKnowledgeFolderRuleConfig, de as NativeKnowledgeObsidianVaultConfig, df as NativeKnowledgeOpenClawWorkspaceConfig, dg as NotionLiveConnectorConfig, P as PluginConfig, Y as PolicyClass, dh as PrincipalFromSessionKeyMode, di as PrincipalRule, dj as ProceduralConfig, ao as ProvenanceConfig, O as ProvenanceSource, aD as QmdSearchExplain, Q as QmdSearchResult, dk as QuestionEntry, bS as RECALL_DISCLOSURE_LEVELS, dl as ReasoningEffort, b as RecallDisclosure, dm as RecallPipelineConfig, R as RecallPlanMode, bc as RecallSectionConfig, c as RecallTierExplain, dn as RecallTraceEvent, dp as RelevanceFeedback, aA as RetrievalTier, dq as SPECULATIVE_TTL_DAYS, dr as ScopeProfileAutoPromoteConfig, o as ScopeProfileConfig, p as ScopeProfileLayerId, q as ScopeProfilePromotionTarget, ds as ScopeProfileTeamProjectConfig, dt as ScopeTeamConfig, du as ScoredEntity, s as SecretRef, dv as SemanticChunkingConfigShape, S as SessionObserverBandConfig, dw as SignalLevel, aB as SignalScanResult, dx as SlotBehaviorConfig, dy as SlotMismatchMode, n as SourceConnectorProvenance, aC as TopicScore, T as TranscriptEntry, dz as TriggerMode, U as TrustWeights, X as VerificationState, dA as confidenceTier, b_ as isRecallDisclosure } from './types-rEwubvim.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 export { ContinuityImprovementLoop, ContinuityIncidentCloseInput, ContinuityIncidentOpenInput, ContinuityIncidentRecord, ContinuityIncidentState, ContinuityLoopCadence, ContinuityLoopReviewInput, ContinuityLoopStatus, ContinuityLoopUpsertInput } from './types-continuity.js';

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-GSL47NPM.js";
+} from "./chunk-J7VGGECD.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,

package/dist/utility-runtime.d.ts

@@ -1,5 +1,5 @@
 import { TierRoutingPolicy } from './tier-routing.js';
-import './types-CqWwMPr_.js';
+import './types-rEwubvim.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/verified-recall.js

@@ -1,24 +1,26 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-FVGQ5LIS.js";
+} from "./chunk-OQ5PRDDS.js";
 import "./chunk-B7RWBZXW.js";
 import "./chunk-ZBJMUXZH.js";
-import "./chunk-3HKQOFOV.js";
-import "./chunk-ENTCVTQR.js";
+import "./chunk-E6PNLPGJ.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-ENTCVTQR.js";
 import "./chunk-WIPEXG6R.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-GSL47NPM.js";
+import "./chunk-J7VGGECD.js";
 import "./chunk-WUNIWKY4.js";
 import "./chunk-EGGE52UU.js";
 import "./chunk-ZA53AZND.js";
+import "./chunk-SCU65EZI.js";
 import "./chunk-WRJVB3C2.js";
 import "./chunk-GCASGYIO.js";
 import "./chunk-7RJUVTVF.js";
-import "./chunk-SCU65EZI.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
+import "./chunk-JYIJNNN3.js";
+import "./chunk-AAD2ZS6P.js";
 import "./chunk-RVLJEII5.js";
 import "./chunk-S5SLVSVY.js";
 import "./chunk-CGASUJVP.js";
@@ -26,8 +28,6 @@ import "./chunk-R3DJVOSM.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-3CSX3ETE.js";
 import "./chunk-RL6NEVXT.js";
-import "./chunk-JYIJNNN3.js";
-import "./chunk-AAD2ZS6P.js";
 import "./chunk-YXZG5TVN.js";
 import "./chunk-W5H6ZRPT.js";
 import "./chunk-G7D6GZ5J.js";
@@ -47,8 +47,8 @@ import "./chunk-45GF7Y3V.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-N7RWREIQ.js";
 import "./chunk-5I4M26Q7.js";
-import "./chunk-5GKPFL3S.js";
 import "./chunk-ZIKENA2C.js";
+import "./chunk-5GKPFL3S.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { v as MemoryCategory } from './types-CqWwMPr_.js';
+import { v as MemoryCategory } from './types-rEwubvim.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.45.0",
+  "version": "9.45.2",
   "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.0"
+    "@remnic/coding-graph": "^9.45.2"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/config.test.ts

@@ -2416,3 +2416,27 @@ test("parseConfig forwards bridgeMode as a raw passthrough (validation is in res
 test("parseConfig leaves the OpenClaw delegate timeout to the plugin parser", () => {
   assert.equal("bridgeHealthTimeoutMs" in parseConfig({ bridgeHealthTimeoutMs: 7_500 }), false);
 });
+
+test("parseConfig validates converge conflict policy and defaults to newest-wins", () => {
+  assert.deepEqual(parseConfig({}).converge, { conflictPolicy: "newest-wins" });
+
+  for (const conflictPolicy of ["newest-wins", "manual"] as const) {
+    assert.equal(parseConfig({ converge: { conflictPolicy } }).converge.conflictPolicy, conflictPolicy);
+  }
+
+  for (const conflictPolicy of ["keep-both", "", "unknown", 0, false, null]) {
+    assert.throws(
+      () => parseConfig({ converge: { conflictPolicy } }),
+      /converge\.conflictPolicy.*newest-wins.*manual/,
+    );
+  }
+
+  for (const converge of [0, null, [], new Date(), new Map()]) {
+    assert.throws(() => parseConfig({ converge }), /converge must be a plain object/);
+  }
+
+  assert.throws(
+    () => parseConfig({ converge: { conflictPolciy: "manual" } }),
+    /converge contains unknown key "conflictPolciy"/,
+  );
+});

package/src/config.ts

@@ -26,6 +26,7 @@ import type {
   TriggerMode,
   TrustWeights,
 } from "./types.js";
+import { parseConvergeConfig } from "./converge-config.js";
 import { log } from "./logger.js";
 import { cloneDefaultSessionObserverBands } from "./session-observer-bands.js";
 import { readEnvVar, resolveHomeDir } from "./runtime/env.js";
@@ -80,6 +81,7 @@ const DEFAULT_WORKSPACE_DIR = path.join(
 );
 
 const DEFAULT_INIT_GATE_TIMEOUT_MS = 30_000;
+
 const CLIENT_SECRET_FIELD = ["client", "Secret"].join("") as "clientSecret";
 const REFRESH_TOKEN_FIELD = ["refresh", "Token"].join("") as "refreshToken";
 const LEGACY_ACTIVE_RECALL_CUSTOM_FIELD = [
@@ -2332,6 +2334,7 @@ export function parseConfig(
     procedural,
     extractionLiveness: parseExtractionLivenessConfig(cfg),
     replicaPeers: parseReplicaPeersConfig(cfg),
+    converge: parseConvergeConfig(cfg.converge),
     wearables,
     meetings,
     activity,

package/src/converge-config.ts

@@ -0,0 +1,39 @@
+import type { ConvergeConfig, ConvergeConflictPolicy } from "./types.js";
+
+export const CONVERGE_CONFLICT_POLICIES = [
+  "newest-wins",
+  "manual",
+] as const satisfies readonly ConvergeConflictPolicy[];
+
+export const DEFAULT_CONVERGE_CONFLICT_POLICY: ConvergeConflictPolicy = "newest-wins";
+
+export function parseConvergeConfig(block: unknown): ConvergeConfig {
+  if (block === undefined) {
+    return { conflictPolicy: DEFAULT_CONVERGE_CONFLICT_POLICY };
+  }
+  if (block === null || typeof block !== "object" || Array.isArray(block)) {
+    throw new Error("converge must be a plain object");
+  }
+  const prototype = Object.getPrototypeOf(block);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new Error("converge must be a plain object");
+  }
+  const { conflictPolicy, ...unknown } = block as Record<string, unknown>;
+  const unknownKey = Object.keys(unknown)[0];
+  if (unknownKey !== undefined) {
+    throw new Error(`converge contains unknown key ${JSON.stringify(unknownKey)}`);
+  }
+  if (conflictPolicy === undefined) {
+    return { conflictPolicy: DEFAULT_CONVERGE_CONFLICT_POLICY };
+  }
+  if (
+    typeof conflictPolicy === "string" &&
+    CONVERGE_CONFLICT_POLICIES.includes(conflictPolicy as ConvergeConflictPolicy)
+  ) {
+    return { conflictPolicy: conflictPolicy as ConvergeConflictPolicy };
+  }
+
+  throw new Error(
+    `converge.conflictPolicy must be one of ${CONVERGE_CONFLICT_POLICIES.join(", ")}; got ${JSON.stringify(conflictPolicy)}`
+  );
+}

package/src/index.ts

@@ -1394,8 +1394,7 @@ export type {
   CalendarSource,
   RecallDisclosure,
 } from "./types.js";
-
-// Recall disclosure depth (issue #677).
+export { CONVERGE_CONFLICT_POLICIES, DEFAULT_CONVERGE_CONFLICT_POLICY } from "./converge-config.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,
   RECALL_DISCLOSURE_LEVELS,

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) };

package/src/reconcile/manifest.ts

@@ -7,6 +7,8 @@ import {
   type ReconcileFileState,
   type ReconcilePlan,
   type ReconcilePlanEntry,
+  type ReconcileSemanticAgreement,
+  type ReconcileSemanticChange,
   summarizeReconcilePlan,
 } from "./plan.js";
 
@@ -153,10 +155,28 @@ function comparePlanEntries(left: ReconcilePlanEntry, right: ReconcilePlanEntry)
   return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
 }
 
+function semanticAgreementKey(agreement: ReconcileSemanticAgreement): string {
+  return `${agreement.local.path}\0${agreement.peer.path}`;
+}
+
+function classifySemanticChange(
+  current: ReconcileSemanticAgreement,
+  prior: ReconcileSemanticAgreement | undefined
+): ReconcileSemanticChange {
+  if (!prior) return "unchanged";
+  const localChanged = current.local.sha256 !== prior.local.sha256;
+  const peerChanged = current.peer.sha256 !== prior.peer.sha256;
+  if (localChanged && peerChanged) return "both_modified";
+  if (localChanged) return "local_changed";
+  if (peerChanged) return "peer_changed";
+  return "unchanged";
+}
+
 export function collapseActiveFactDuplicates(
   plan: ReconcilePlan,
   localManifests: ReadonlyMap<string, ReconcileManifest>,
-  peerManifests: ReadonlyMap<string, ReconcileManifest>
+  peerManifests: ReadonlyMap<string, ReconcileManifest>,
+  priorSemanticAgreements?: ReadonlyMap<string, readonly ReconcileSemanticAgreement[]>,
 ): ReconcilePlan {
   const entriesByNamespace = new Map<string, ReconcilePlanEntry[]>();
   for (const entry of plan.entries) {
@@ -174,6 +194,12 @@ export function collapseActiveFactDuplicates(
     const peerByPath = activeFactByPath(peerManifest);
     const localFilesByPath = new Map((localManifest?.files ?? []).map((file) => [file.path, file]));
     const peerFilesByPath = new Map((peerManifest?.files ?? []).map((file) => [file.path, file]));
+    const priorSemanticByPathPair = new Map(
+      (priorSemanticAgreements?.get(namespace) ?? []).map((agreement) => [
+        semanticAgreementKey(agreement),
+        agreement,
+      ])
+    );
     const localByHash = new Map<string, ActiveFactManifestFile[]>();
     const peerByHash = new Map<string, ActiveFactManifestFile[]>();
 
@@ -214,6 +240,26 @@ export function collapseActiveFactDuplicates(
           ...localCandidates.map((file) => file.path),
           ...peerCandidates.map((file) => file.path),
         ]);
+        const authoritativeSamePathEntries = new Set(entries.filter(
+          (entry) =>
+            duplicatePaths.has(entry.path)
+            && localFilesByPath.has(entry.path)
+            && peerFilesByPath.has(entry.path)
+            && entry.action !== "identical"
+        ));
+        if (authoritativeSamePathEntries.size > 0) {
+          for (const entry of entries) {
+            if (
+              duplicatePaths.has(entry.path)
+              && !authoritativeSamePathEntries.has(entry)
+              && (entry.action === "pull" || entry.action === "push" || entry.action === "identical")
+            ) {
+              removed.add(entry);
+              changed = true;
+            }
+          }
+          continue;
+        }
         const unsafeEntry = entries.some(
           (entry) => duplicatePaths.has(entry.path) && (entry.action === "suppress" || entry.action === "conflict")
         );
@@ -226,13 +272,20 @@ export function collapseActiveFactDuplicates(
             removed.add(entry);
           }
         }
+        const semanticAgreement: ReconcileSemanticAgreement = {
+          local: { path: localPath, sha256: localFile.sha256 },
+          peer: { path: peerPath, sha256: peerFile.sha256 },
+        };
         replacements.push({
           path: localPath < peerPath ? localPath : peerPath,
           namespace,
           action: "identical",
           reason: "semantic_duplicate",
-          localSha256: localFile.sha256,
-          peerSha256: peerFile.sha256,
+          semanticAgreement,
+          semanticChange: classifySemanticChange(
+            semanticAgreement,
+            priorSemanticByPathPair.get(semanticAgreementKey(semanticAgreement))
+          ),
         });
         changed = true;
         continue;