@remnic/core 9.63.6 → 9.63.8

package/src/recall-state.ts

@@ -12,6 +12,22 @@ import type {
   RecallPlanMode,
   RecallTierExplain,
 } from "./types.js";
+import {
+  coerceIncludedMemories,
+  type IncludedMemory,
+} from "./included-memories.js";
+
+export type { IncludedMemory } from "./included-memories.js";
+export { coerceIncludedMemories } from "./included-memories.js";
+
+// Session keys are caller-supplied (host session IDs) and land in indexed
+// assignments on plain-object state. A key matching one of these would
+// pollute Object.prototype (or read junk off it), so every read/write
+// through this module rejects them — same contract load() already enforced.
+function isUnsafeStateKey(key: string): boolean {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+
 
 export interface LastRecallBudgetSummary {
   requestedTopK?: number;
@@ -36,6 +52,7 @@ export interface LastRecallSnapshot {
   queryHash: string;
   queryLen: number;
   memoryIds: string[];
+  includedMemories?: IncludedMemory[];
   namespace?: string;
   recallNamespaces?: string[];
   traceId?: string;
@@ -172,6 +189,13 @@ type StateFileWriter = (filePath: string, content: string) => Promise<void>;
  * recordedAt are compared. Extracted so every annotation surface applies
  * identical guards (CLAUDE.md rule 22).
  */
+function cloneTierExplain(
+  tierExplain: RecallTierExplain | undefined,
+): RecallTierExplain | undefined {
+  if (!tierExplain) return undefined;
+  return structuredClone(tierExplain);
+}
+
 function snapshotMatchesExpectedIdentity(
   current: LastRecallSnapshot,
   expected?: { writeNonce?: string; traceId?: string; recordedAt?: string },
@@ -182,34 +206,42 @@ function snapshotMatchesExpectedIdentity(
   }
   const hasExpectedTraceId =
     typeof expected.traceId === "string" && expected.traceId.length > 0;
-  if (hasExpectedTraceId) {
-    return current.traceId === expected.traceId;
-  }
-  if (expected.recordedAt !== undefined) {
+  if (hasExpectedTraceId && current.traceId !== expected.traceId) return false;
+  if (typeof expected.recordedAt === "string" && expected.recordedAt.length > 0) {
     return current.recordedAt === expected.recordedAt;
   }
   return true;
 }
 
-function cloneTierExplain(
-  tierExplain: RecallTierExplain | undefined,
-): RecallTierExplain | undefined {
-  if (!tierExplain) return undefined;
-  return structuredClone(tierExplain);
+function hydrateLastRecallSnapshot(snapshot: LastRecallSnapshot): LastRecallSnapshot {
+  const includedMemories = coerceIncludedMemories(snapshot);
+  const budgets = snapshot.budgetsApplied
+    ? {
+        ...snapshot.budgetsApplied,
+        includedMemoryIds: includedMemories.map((memory) => memory.id),
+        includedMemoryPaths: includedMemories.map((memory) => memory.path),
+        includedMemoryNamespaces: includedMemories.map((memory) => memory.namespace),
+      }
+    : undefined;
+  return {
+    ...snapshot,
+    includedMemories,
+    memoryIds: includedMemories.map((memory) => memory.id),
+    resultPaths: includedMemories.map((memory) => memory.path),
+    resultNamespaces: includedMemories.map((memory) => memory.namespace),
+    ...(budgets ? { budgetsApplied: budgets } : {}),
+  };
 }
 
-/**
- * Deep-copy a LastRecallSnapshot so callers that receive it cannot
- * mutate the store's internal state through mutable array/object
- * fields.  Same structuredClone rationale as cloneTierExplain above.
- */
 function cloneLastRecallSnapshot(
   snapshot: LastRecallSnapshot | null,
 ): LastRecallSnapshot | null {
   if (!snapshot) return null;
-  return structuredClone(snapshot);
+  return structuredClone(hydrateLastRecallSnapshot(snapshot));
 }
 
+
+
 export interface TierMigrationCycleSummary {
   trigger: "extraction" | "maintenance" | "manual";
   scanned: number;
@@ -319,8 +351,22 @@ export class LastRecallStore {
   async load(): Promise<void> {
     try {
       const raw = await readFile(this.statePath, "utf-8");
-      const parsed = JSON.parse(raw) as LastRecallState;
-      if (parsed && typeof parsed === "object") this.state = parsed;
+      const parsed: unknown = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        this.state = {};
+        return;
+      }
+      const next: LastRecallState = {};
+      for (const [sessionKey, snapshot] of Object.entries(parsed)) {
+        if (sessionKey === "__proto__" || sessionKey === "constructor" || sessionKey === "prototype") {
+          continue;
+        }
+        if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) {
+          continue;
+        }
+        next[sessionKey] = hydrateLastRecallSnapshot(snapshot as LastRecallSnapshot);
+      }
+      this.state = next;
     } catch {
       this.state = {};
     }
@@ -329,6 +375,7 @@ export class LastRecallStore {
   get(sessionKey: string): LastRecallSnapshot | null {
     // Defensive copy: callers must not be able to mutate internal state
     // by reaching into array/object fields on the returned snapshot.
+    if (isUnsafeStateKey(sessionKey)) return null;
     return cloneLastRecallSnapshot(this.state[sessionKey] ?? null);
   }
 
@@ -352,7 +399,8 @@ export class LastRecallStore {
   async record(opts: {
     sessionKey: string;
     query: string;
-    memoryIds: string[];
+    memoryIds?: string[];
+    includedMemories?: IncludedMemory[];
     namespace?: string;
     recallNamespaces?: string[];
     traceId?: string;
@@ -386,6 +434,10 @@ export class LastRecallStore {
      */
     backendDegradations?: SearchDegradation[];
   }): Promise<void> {
+    if (isUnsafeStateKey(opts.sessionKey)) {
+      log.debug("last recall record skipped: unsafe session key");
+      return;
+    }
     const now = new Date().toISOString();
     const queryHash = createHash("sha256").update(opts.query).digest("hex");
 
@@ -393,13 +445,15 @@ export class LastRecallStore {
     // cloneLastRecallSnapshot so caller arrays/objects passed in
     // `opts` cannot retain a live reference to the persisted state and
     // tear it after `record()` returns.
+    const includedMemories = coerceIncludedMemories(opts);
     const liveSnapshot: LastRecallSnapshot = {
       sessionKey: opts.sessionKey,
       recordedAt: now,
       queryHash,
       writeNonce: randomUUID(),
       queryLen: opts.query.length,
-      memoryIds: opts.memoryIds,
+      includedMemories,
+      memoryIds: includedMemories.map((memory) => memory.id),
       namespace: opts.namespace,
       recallNamespaces: opts.recallNamespaces,
       traceId: opts.traceId,
@@ -410,8 +464,6 @@ export class LastRecallStore {
       sourcesUsed: opts.sourcesUsed,
       budgetsApplied: opts.budgetsApplied,
       latencyMs: opts.latencyMs,
-      resultPaths: opts.resultPaths,
-      resultNamespaces: opts.resultNamespaces,
       policyVersion: opts.policyVersion,
       identityInjectionMode: opts.identityInjection?.mode,
       identityInjectedChars: opts.identityInjection?.injectedChars,
@@ -810,6 +862,7 @@ export class LastRecallStore {
     tierExplain: RecallTierExplain,
     expected?: { writeNonce?: string; traceId?: string; recordedAt?: string },
   ): Promise<void> {
+    if (isUnsafeStateKey(sessionKey)) return;
     const current = this.state[sessionKey];
     if (!current) return;
     if (!snapshotMatchesExpectedIdentity(current, expected)) return;
@@ -952,7 +1005,15 @@ export class RecallHandleHistoryStore {
     try {
       const raw = await readFile(this.statePath, "utf-8");
       const parsed = JSON.parse(raw);
-      if (parsed && typeof parsed === "object") this.state = parsed as typeof this.state;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const next: Record<string, Array<{ at: string; ids: string[] }>> = {};
+        for (const [sessionKey, entries] of Object.entries(parsed)) {
+          if (isUnsafeStateKey(sessionKey)) continue;
+          if (!Array.isArray(entries)) continue;
+          next[sessionKey] = entries;
+        }
+        this.state = next;
+      }
     } catch {
       this.state = {};
     }
@@ -963,7 +1024,7 @@ export class RecallHandleHistoryStore {
    * The ring is capped at {@link maxDepth}; older entries drop off the tail.
    */
   async record(sessionKey: string, memoryIds: readonly string[]): Promise<void> {
-    if (!sessionKey) return;
+    if (!sessionKey || isUnsafeStateKey(sessionKey)) return;
     const ids = memoryIds.filter((id): id is string => typeof id === "string" && id.length > 0);
     const entry = { at: new Date().toISOString(), ids };
     const prior = this.state[sessionKey] ?? [];
@@ -982,6 +1043,7 @@ export class RecallHandleHistoryStore {
    * Empty array when the session has no recorded history.
    */
   recent(sessionKey: string, depth: number = this.maxDepth): Array<readonly string[]> {
+    if (isUnsafeStateKey(sessionKey)) return [];
     const entries = this.state[sessionKey];
     if (!entries || entries.length === 0) return [];
     const limit = Math.max(0, Math.min(depth, entries.length));

package/src/recall-token-budget.test.ts

@@ -46,6 +46,6 @@ test("recall reserves one memory chunk that fits both character and token budget
 
   const assembled = coordinator.assembleRecallSections(buckets);
 
-  assert.deepEqual(assembled.includedMemoryIds, ["latin"]);
+  assert.deepEqual(assembled.includedMemories, [{ id: "latin", path: "memories/latin.md" }]);
   assert.ok(estimateTokenCount(assembled.sections.join("\n\n---\n\n")) <= 50);
 });

package/src/reconcile/census-parity.test.ts

@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  OFFLINE_SYNC_MAX_MTIME_MS,
+  OFFLINE_SYNC_SNAPSHOT_FORMAT,
+  normalizeOfflineSyncSnapshot,
+} from "../offline-sync.js";
+import {
+  type ReconcilePlanEntry,
+  ReconcilePlanInputError,
+  compareReconcilePlanEntries,
+  planNamespaceReconciliation,
+  planReconciliation,
+  semanticAgreementKey,
+} from "./plan.js";
+
+/**
+ * Issue #2477: offline-sync and the reconcile planner validate the same peer
+ * census fields, and cursor/manifest order and key plan entries the same way.
+ * These tests fail the moment one surface drifts from the other, which was
+ * previously a silent convergence bug.
+ */
+
+const PATH = "facts/2026-03-01/a.md";
+const GOOD_SHA = "a".repeat(64);
+
+type CensusOutcome = { accepted: boolean; digest?: string };
+
+/** Validate one census file record through the offline-sync snapshot surface. */
+function offlineSyncOutcome(overrides: Record<string, unknown>): CensusOutcome {
+  try {
+    const snapshot = normalizeOfflineSyncSnapshot({
+      format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
+      schemaVersion: 1,
+      createdAt: "2026-08-17T00:00:00.000Z",
+      sourceId: "peer",
+      includeTranscripts: false,
+      files: [{ path: PATH, bytes: 1, mtimeMs: 0, sha256: GOOD_SHA, ...overrides }],
+    });
+    return { accepted: true, digest: snapshot.files[0]?.sha256 };
+  } catch {
+    return { accepted: false };
+  }
+}
+
+/** Validate the same record through the reconcile planner's census surface. */
+function reconcileOutcome(overrides: Record<string, unknown>): CensusOutcome {
+  try {
+    const entries = planNamespaceReconciliation({
+      namespace: "default",
+      local: [{ path: PATH, sha256: GOOD_SHA, mtimeMs: 0, ...overrides }],
+      peer: [],
+    });
+    return { accepted: true, digest: entries.find((e) => e.path === PATH)?.localSha256 };
+  } catch (err) {
+    assert.ok(err instanceof ReconcilePlanInputError, "plan census rejects must stay ReconcilePlanInputError");
+    return { accepted: false };
+  }
+}
+
+const SHA256_FIXTURES: unknown[] = [
+  "b".repeat(64), // accepted, already canonical
+  "B".repeat(64), // accepted, canonicalized to lowercase
+  "b".repeat(63), // too short
+  "b".repeat(65), // too long
+  "z".repeat(64), // not hex
+  "",
+  42,
+  null,
+  { length: 64 },
+];
+
+const MTIME_FIXTURES: unknown[] = [
+  0,
+  1.25, // fractional mtimes are valid
+  OFFLINE_SYNC_MAX_MTIME_MS,
+  OFFLINE_SYNC_MAX_MTIME_MS + 1,
+  -1,
+  Number.NaN,
+  Number.POSITIVE_INFINITY,
+  "100",
+  null,
+];
+
+test("sha256 census fixtures accept and canonicalize identically on both surfaces", () => {
+  const offline = SHA256_FIXTURES.map((sha256) => offlineSyncOutcome({ sha256 }));
+  const reconcile = SHA256_FIXTURES.map((sha256) => reconcileOutcome({ sha256 }));
+  assert.deepEqual(reconcile, offline);
+  assert.deepEqual(
+    offline.map((o) => o.accepted),
+    [true, true, false, false, false, false, false, false, false]
+  );
+  assert.equal(offline[1].digest, "b".repeat(64));
+});
+
+test("mtimeMs census fixtures accept and reject identically on both surfaces", () => {
+  const offline = MTIME_FIXTURES.map((mtimeMs) => offlineSyncOutcome({ mtimeMs }));
+  const reconcile = MTIME_FIXTURES.map((mtimeMs) => reconcileOutcome({ mtimeMs }));
+  assert.deepEqual(reconcile, offline);
+  assert.deepEqual(
+    offline.map((o) => o.accepted),
+    [true, true, true, false, false, false, false, false, false]
+  );
+});
+
+test("compareReconcilePlanEntries is the total order plan output itself uses", () => {
+  const entry = (namespace: string, path: string): ReconcilePlanEntry => ({
+    path,
+    namespace,
+    action: "identical",
+    reason: "same_content",
+  });
+  const a = entry("alpha", "facts/a.md");
+  const b = entry("beta", "facts/a.md");
+  const c = entry("beta", "facts/b.md");
+  const sorted = [c, { ...a }, b, a].sort(compareReconcilePlanEntries);
+  assert.deepEqual(
+    sorted.map((e) => [e.namespace, e.path]),
+    [
+      ["alpha", "facts/a.md"],
+      ["alpha", "facts/a.md"],
+      ["beta", "facts/a.md"],
+      ["beta", "facts/b.md"],
+    ]
+  );
+  assert.equal(compareReconcilePlanEntries(a, { ...a }), 0);
+
+  const plan = planReconciliation([
+    { namespace: "beta", local: [], peer: [] },
+    { namespace: "alpha", local: [{ path: "facts/z.md", sha256: GOOD_SHA }], peer: [] },
+  ]);
+  assert.ok(plan.entries.length > 0);
+  for (let i = 1; i < plan.entries.length; i += 1) {
+    assert.ok(compareReconcilePlanEntries(plan.entries[i - 1], plan.entries[i]) <= 0);
+  }
+});
+
+test("semanticAgreementKey pins the ordered path-pair identity shared by cursor and manifest", () => {
+  const localFirst = semanticAgreementKey({
+    local: { path: "facts/local.md", sha256: GOOD_SHA },
+    peer: { path: "facts/peer.md", sha256: GOOD_SHA },
+  });
+  assert.equal(localFirst, "facts/local.md\0facts/peer.md");
+  assert.notEqual(
+    localFirst,
+    semanticAgreementKey({
+      local: { path: "facts/peer.md", sha256: GOOD_SHA },
+      peer: { path: "facts/local.md", sha256: GOOD_SHA },
+    })
+  );
+});

package/src/reconcile/cursor.ts

@@ -1,7 +1,11 @@
 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";
+import {
+  type ReconcilePlanEntry,
+  type ReconcileSemanticAgreement,
+  semanticAgreementKey,
+} from "./plan.js";
 
 export type ConvergeRefreshTarget = "local" | "receiver";
 
@@ -76,10 +80,6 @@ function digestAfterReconcile(entry: ReconcilePlanEntry): string | 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,

package/src/reconcile/manifest.ts

@@ -12,6 +12,8 @@ import {
   type ReconcilePlanEntry,
   type ReconcileSemanticAgreement,
   type ReconcileSemanticChange,
+  compareReconcilePlanEntries,
+  semanticAgreementKey,
   summarizeReconcilePlan,
 } from "./plan.js";
 
@@ -218,15 +220,6 @@ function contentHashRows(
   return rows;
 }
 
-function comparePlanEntries(left: ReconcilePlanEntry, right: ReconcilePlanEntry): number {
-  if (left.namespace !== right.namespace) return left.namespace < right.namespace ? -1 : 1;
-  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
@@ -396,13 +389,13 @@ export function collapseActiveFactDuplicates(
     if (removed.size > 0 || replacements.length > 0) {
       entriesByNamespace.set(
         namespace,
-        [...entries.filter((entry) => !removed.has(entry)), ...replacements].sort(comparePlanEntries)
+        [...entries.filter((entry) => !removed.has(entry)), ...replacements].sort(compareReconcilePlanEntries)
       );
     }
   }
 
   if (!changed) return plan;
-  const entries = [...entriesByNamespace.values()].flat().sort(comparePlanEntries);
+  const entries = [...entriesByNamespace.values()].flat().sort(compareReconcilePlanEntries);
   return {
     entries,
     byNamespace: summarizeReconcilePlan(entries),

package/src/reconcile/plan.ts

@@ -1,5 +1,5 @@
+import { CENSUS_MAX_MTIME_MS, isCensusMtimeMs, isSha256Hex } from "../census-validation.js";
 import { normalizeNamespaceIdentity } from "../namespaces/identity.js";
-import { OFFLINE_SYNC_MAX_MTIME_MS } from "../offline-sync.js";
 import { validateArchiveRelativePath } from "../transfer/fs-utils.js";
 import type { OfflineSyncFileState } from "../offline-sync.js";
 import {
@@ -197,8 +197,7 @@ export class ReconcilePlanInputError extends Error {
   }
 }
 
-/** Matches `assertSha256` in offline-sync so both surfaces reject the same values (§40). */
-const SHA256_PATTERN = /^[a-f0-9]{64}$/i;
+/** Shared with offline-sync's census validation (issue #2477): one acceptance set. */
 
 /**
  * Validate a census record's identity fields.
@@ -247,14 +246,9 @@ function assertCensusRecord(
  * deliberately does not require an integer.
  */
 function assertMtimeMs(value: unknown, context: string): number {
-  if (
-    typeof value !== "number"
-    || !Number.isFinite(value)
-    || value < 0
-    || value > OFFLINE_SYNC_MAX_MTIME_MS
-  ) {
+  if (!isCensusMtimeMs(value)) {
     throw new ReconcilePlanInputError(
-      `reconcile: ${context} has an out-of-range mtimeMs; expected a finite value between 0 and ${OFFLINE_SYNC_MAX_MTIME_MS}`,
+      `reconcile: ${context} has an out-of-range mtimeMs; expected a finite value between 0 and ${CENSUS_MAX_MTIME_MS}`,
     );
   }
   return value;
@@ -267,7 +261,7 @@ function assertMtimeMs(value: unknown, context: string): number {
  * and tombstone lookups would silently miss.
  */
 function assertDigest(value: unknown, context: string): string {
-  if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
+  if (!isSha256Hex(value)) {
     throw new ReconcilePlanInputError(
       `reconcile: ${context} must carry a 64-character sha256 hex digest`,
     );
@@ -503,14 +497,23 @@ function assertConflictPolicy(value: ConvergeConflictPolicy | undefined): Conver
  * Total ordering for plan entries (§12): namespace, then path. Both are unique
  * per entry, so equal keys are impossible and the comparator never has to
  * return 0 for distinct rows — the output is byte-identical across runs, which
- * is what makes a convergence report diffable.
+ * is what makes a convergence report diffable. Cursor and manifest sort with
+ * this same export; a local copy on either side is how ordering drifts (§2477).
  */
-function compareEntries(a: ReconcilePlanEntry, b: ReconcilePlanEntry): number {
+export function compareReconcilePlanEntries(a: ReconcilePlanEntry, b: ReconcilePlanEntry): number {
   if (a.namespace !== b.namespace) return a.namespace < b.namespace ? -1 : 1;
   if (a.path !== b.path) return a.path < b.path ? -1 : 1;
   return 0;
 }
 
+/**
+ * Identity of a semantic-duplicate pair: the ordered (local, peer) path pair.
+ * Cursor derivation and manifest collapse must key prior agreements with this
+ * same export or a stored cursor stops matching the plan that wrote it.
+ */
+export function semanticAgreementKey(agreement: ReconcileSemanticAgreement): string {
+  return `${agreement.local.path}\0${agreement.peer.path}`;
+}
 
 function resolveConflict(
   policy: ConvergeConflictPolicy,
@@ -795,7 +798,7 @@ export function planNamespaceReconciliation(
     });
   }
 
-  return entries.sort(compareEntries);
+  return entries.sort(compareReconcilePlanEntries);
 }
 
 /** Aggregate entries into the per-namespace convergence report (#2150). */
@@ -852,7 +855,7 @@ export function planReconciliation(
     seenNamespaces.add(name);
     entries.push(...planNamespaceReconciliation(namespace, options));
   }
-  entries.sort(compareEntries);
+  entries.sort(compareReconcilePlanEntries);
   return {
     entries,
     byNamespace: summarizeReconcilePlan(entries),

package/dist/chunk-EFKZT6AY.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/reconcile/manifest.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { computeLegacyContentHash, normalizeLegacyContent } from \"../content-hash.js\";\nimport { inferMemoryStatus } from \"../memory-lifecycle-ledger-utils.js\";\nimport { ContentHashIndex, type ContentHashPathEntry } from \"../storage/content-hash-index.js\";\nimport { DEFAULT_CITATION_FORMAT, stripCitationForTemplate } from \"../source-attribution.js\";\nimport { storedContentIdentityCandidates } from \"../structured-attributes.js\";\nimport type { MemoryFrontmatter, MemoryStatus } from \"../types.js\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport {\n  type ReconcileFileState,\n  type ReconcilePlan,\n  type ReconcilePlanEntry,\n  type ReconcileSemanticAgreement,\n  type ReconcileSemanticChange,\n  summarizeReconcilePlan,\n} from \"./plan.js\";\n\nexport const RECONCILE_MANIFEST_FORMAT = \"remnic-reconcile-manifest\";\nexport const RECONCILE_MANIFEST_SCHEMA_VERSION = 1;\nconst CONTENT_HASH_NORMALIZER_VERSION = 4;\n/**\n * Version of the identity-resolution LOGIC (alias recovery, candidate\n * ordering), independent of the content normalizer: a cached manifest entry\n * written before an identity-resolution change carries an older value and is\n * reparsed even when its normalizerVersion still matches (issue #2367\n * review round 2). Bump when parsedMemoryIdentity's output shape or\n * semantics change.\n */\nconst IDENTITY_RESOLUTION_VERSION = 2;\n\nexport interface ReconcileMemoryIdentity {\n  id: string;\n  category: string;\n  contentHash: string;\n  /**\n   * Recovered current-normalizer identities for a record whose persisted hash\n   * is ambiguous under the legacy normalizer (issue #2367). The persisted\n   * hash stays primary; these participate in duplicate bucketing so a\n   * replica carrying the current form of the same fact still collapses.\n   */\n  contentHashAliases?: readonly string[];\n  /** See IDENTITY_RESOLUTION_VERSION; absent on pre-versioning cache entries. */\n  normalizerVersion?: number;\n  identityResolutionVersion?: number;\n  status: MemoryStatus;\n}\n\nexport interface ReconcileManifestFile extends ReconcileFileState {\n  memory?: ReconcileMemoryIdentity;\n}\n\ntype ActiveFactManifestFile = ReconcileManifestFile & { memory: ReconcileMemoryIdentity };\n\nexport interface ReconcileManifest {\n  format: typeof RECONCILE_MANIFEST_FORMAT;\n  schemaVersion: typeof RECONCILE_MANIFEST_SCHEMA_VERSION;\n  files: ReconcileManifestFile[];\n}\n\nexport type ReconcileMemoryParser = (\n  raw: string,\n) => { frontmatter: MemoryFrontmatter; content: string } | null;\n\nexport interface BuildReconcileManifestOptions {\n  files: Iterable<ReconcileFileState>;\n  readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>;\n  parseMemory: ReconcileMemoryParser;\n  cachedFiles?: Iterable<ReconcileManifestFile>;\n  citationTemplate?: string;\n}\n\nconst SHA256_PATTERN = /^[a-f0-9]{64}$/i;\nconst MEMORY_DIRS = new Set(RECALL_FALLBACK_DIRS);\n\nfunction isMemoryPath(filePath: string): boolean {\n  if (!filePath.endsWith(\".md\")) return false;\n  const segments = filePath.split(\"/\");\n  let index = 0;\n  if (segments[index] === \"cold\" || segments[index] === \"archive\") index += 1;\n  return MEMORY_DIRS.has(segments[index] ?? \"\");\n}\n\n\nfunction parsedMemoryIdentity(\n  filePath: string,\n  raw: Buffer | string,\n  parseMemory: ReconcileMemoryParser,\n  citationTemplate: string,\n): ReconcileMemoryIdentity | undefined {\n  if (!isMemoryPath(filePath)) return undefined;\n  const parsed = parseMemory(Buffer.isBuffer(raw) ? raw.toString(\"utf8\") : raw);\n  if (!parsed?.frontmatter.id) return undefined;\n\n  const storedHash =\n    parsed.frontmatter.contentHash &&\n    SHA256_PATTERN.test(parsed.frontmatter.contentHash)\n      ? parsed.frontmatter.contentHash.toLowerCase()\n      : undefined;\n  const candidates = storedContentIdentityCandidates(parsed.content, (content) =>\n    stripCitationForTemplate(content, citationTemplate)\n  );\n  const bodyHash = ContentHashIndex.computeHash(candidates[0] ?? \"\");\n  const currentMatch = candidates.find(\n    (content) => ContentHashIndex.computeHash(content) === storedHash\n  );\n  const legacyMatch = [...candidates].reverse().find(\n    (content) => computeLegacyContentHash(content) === storedHash\n  );\n  let contentHash: string;\n  let contentHashAliases: string[] | undefined;\n  if (currentMatch) {\n    contentHash = ContentHashIndex.computeHash(currentMatch);\n  } else if (legacyMatch && normalizeLegacyContent(legacyMatch).length > 0) {\n    // A non-empty legacy equality is ambiguous (issue #2367): the persisted\n    // hash may be an explicit contentHashSource identity that merely collides\n    // with the body's ASCII skeleton under the lossy legacy normalizer, and\n    // nothing in the record proves which it is. Keep the persisted hash as\n    // the primary identity and expose the recovered current identity as an\n    // alias so replicas carrying either form still collapse.\n    contentHash = storedHash ?? bodyHash;\n    const recovered = ContentHashIndex.computeHash(legacyMatch);\n    if (recovered !== contentHash) contentHashAliases = [recovered];\n  } else {\n    // An EMPTY legacy skeleton identifies nothing (every non-ASCII body maps\n    // to it), so preserving it would collapse unrelated records. Recovering\n    // the current identity here is repair, not replacement.\n    contentHash = legacyMatch ? ContentHashIndex.computeHash(legacyMatch) : storedHash ?? bodyHash;\n  }\n\n  return {\n    id: parsed.frontmatter.id,\n    category: parsed.frontmatter.category,\n    contentHash,\n    ...(contentHashAliases ? { contentHashAliases } : {}),\n    normalizerVersion: CONTENT_HASH_NORMALIZER_VERSION,\n    identityResolutionVersion: IDENTITY_RESOLUTION_VERSION,\n    status: inferMemoryStatus(parsed.frontmatter, filePath),\n  };\n}\n\nexport async function buildReconcileManifestFile(\n  file: ReconcileFileState,\n  readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>,\n  parseMemory: ReconcileMemoryParser,\n  citationTemplate = DEFAULT_CITATION_FORMAT,\n): Promise<ReconcileManifestFile> {\n  let raw: Buffer | string | null = null;\n  if (isMemoryPath(file.path)) {\n    try {\n      raw = await readFile(file);\n    } catch {\n      raw = null;\n    }\n  }\n  if (raw !== null && createHash(\"sha256\").update(raw).digest(\"hex\") !== file.sha256.toLowerCase()) {\n    raw = null;\n  }\n  const memory = raw === null ? undefined : parsedMemoryIdentity(file.path, raw, parseMemory, citationTemplate);\n  return { ...file, ...(memory ? { memory } : {}) };\n}\n\nexport async function buildReconcileManifest(options: BuildReconcileManifestOptions): Promise<ReconcileManifest> {\n  const cachedByPath = new Map<string, ReconcileManifestFile>();\n  for (const cached of options.cachedFiles ?? []) {\n    cachedByPath.set(cached.path, cached);\n  }\n\n  const files: ReconcileManifestFile[] = [];\n  for (const file of options.files) {\n    const cached = cachedByPath.get(file.path);\n    if (\n      cached?.sha256.toLowerCase() === file.sha256.toLowerCase() &&\n      (cached.memory === undefined ||\n        (cached.memory.normalizerVersion === CONTENT_HASH_NORMALIZER_VERSION &&\n          cached.memory.identityResolutionVersion === IDENTITY_RESOLUTION_VERSION))\n    ) {\n      files.push({ ...file, ...(cached.memory ? { memory: cached.memory } : {}) });\n      continue;\n    }\n\n    files.push(await buildReconcileManifestFile(\n      file,\n      options.readFile,\n      options.parseMemory,\n      options.citationTemplate,\n    ));\n  }\n  files.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));\n  return {\n    format: RECONCILE_MANIFEST_FORMAT,\n    schemaVersion: RECONCILE_MANIFEST_SCHEMA_VERSION,\n    files,\n  };\n}\n\nfunction activeFactByPath(manifest: ReconcileManifest | undefined): Map<string, ActiveFactManifestFile> {\n  const result = new Map<string, ActiveFactManifestFile>();\n  for (const file of manifest?.files ?? []) {\n    if (file.memory?.category === \"fact\" && file.memory.status === \"active\") {\n      result.set(file.path, file as ActiveFactManifestFile);\n    }\n  }\n  return result;\n}\n\nfunction memoryIdentityHashes(memory: ReconcileMemoryIdentity): string[] {\n  return [memory.contentHash, ...(memory.contentHashAliases ?? [])];\n}\n\nfunction contentHashRows(\n  files: Iterable<ActiveFactManifestFile>,\n  contentHash: string,\n): ContentHashPathEntry[] {\n  const rows: ContentHashPathEntry[] = [];\n  for (const file of files) {\n    rows.push({ path: file.path, contentHash });\n  }\n  return rows;\n}\n\nfunction comparePlanEntries(left: ReconcilePlanEntry, right: ReconcilePlanEntry): number {\n  if (left.namespace !== right.namespace) return left.namespace < right.namespace ? -1 : 1;\n  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;\n}\n\nfunction semanticAgreementKey(agreement: ReconcileSemanticAgreement): string {\n  return `${agreement.local.path}\\0${agreement.peer.path}`;\n}\n\nfunction classifySemanticChange(\n  current: ReconcileSemanticAgreement,\n  prior: ReconcileSemanticAgreement | undefined\n): ReconcileSemanticChange {\n  if (!prior) return \"unchanged\";\n  const localChanged = current.local.sha256 !== prior.local.sha256;\n  const peerChanged = current.peer.sha256 !== prior.peer.sha256;\n  if (localChanged && peerChanged) return \"both_modified\";\n  if (localChanged) return \"local_changed\";\n  if (peerChanged) return \"peer_changed\";\n  return \"unchanged\";\n}\n\nexport function collapseActiveFactDuplicates(\n  plan: ReconcilePlan,\n  localManifests: ReadonlyMap<string, ReconcileManifest>,\n  peerManifests: ReadonlyMap<string, ReconcileManifest>,\n  priorSemanticAgreements?: ReadonlyMap<string, readonly ReconcileSemanticAgreement[]>,\n): ReconcilePlan {\n  const entriesByNamespace = new Map<string, ReconcilePlanEntry[]>();\n  for (const entry of plan.entries) {\n    const entries = entriesByNamespace.get(entry.namespace) ?? [];\n    entries.push({ ...entry });\n    entriesByNamespace.set(entry.namespace, entries);\n  }\n\n  let changed = false;\n  for (const namespace of new Set([...localManifests.keys(), ...peerManifests.keys()])) {\n    const entries = entriesByNamespace.get(namespace) ?? [];\n    const localManifest = localManifests.get(namespace);\n    const peerManifest = peerManifests.get(namespace);\n    const localByPath = activeFactByPath(localManifest);\n    const peerByPath = activeFactByPath(peerManifest);\n    const localFilesByPath = new Map((localManifest?.files ?? []).map((file) => [file.path, file]));\n    const peerFilesByPath = new Map((peerManifest?.files ?? []).map((file) => [file.path, file]));\n    const priorSemanticByPathPair = new Map(\n      (priorSemanticAgreements?.get(namespace) ?? []).map((agreement) => [\n        semanticAgreementKey(agreement),\n        agreement,\n      ])\n    );\n    const localByHash = new Map<string, ActiveFactManifestFile[]>();\n    const peerByHash = new Map<string, ActiveFactManifestFile[]>();\n\n    for (const file of localByPath.values()) {\n      for (const hash of memoryIdentityHashes(file.memory)) {\n        const bucket = localByHash.get(hash) ?? [];\n        bucket.push(file);\n        localByHash.set(hash, bucket);\n      }\n    }\n    for (const file of peerByPath.values()) {\n      for (const hash of memoryIdentityHashes(file.memory)) {\n        const bucket = peerByHash.get(hash) ?? [];\n        bucket.push(file);\n        peerByHash.set(hash, bucket);\n      }\n    }\n\n    const removed = new Set<ReconcilePlanEntry>();\n    const replacements: ReconcilePlanEntry[] = [];\n    const processedPathPairs = new Set<string>();\n    for (const hash of new Set([...localByHash.keys(), ...peerByHash.keys()])) {\n      const localCandidates = (localByHash.get(hash) ?? []).filter((file) => {\n        const opposite = peerFilesByPath.get(file.path);\n        const activeOpposite = peerByPath.get(file.path);\n        return opposite === undefined || (\n          activeOpposite !== undefined &&\n          memoryIdentityHashes(activeOpposite.memory).includes(hash)\n        );\n      });\n      const peerCandidates = (peerByHash.get(hash) ?? []).filter((file) => {\n        const opposite = localFilesByPath.get(file.path);\n        const activeOpposite = localByPath.get(file.path);\n        return opposite === undefined || (\n          activeOpposite !== undefined &&\n          memoryIdentityHashes(activeOpposite.memory).includes(hash)\n        );\n      });\n      const localPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(localCandidates, hash));\n      const peerPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(peerCandidates, hash));\n\n      if (localPath && peerPath && localPath !== peerPath) {\n        const pathPair = `${localPath}\\0${peerPath}`;\n        if (processedPathPairs.has(pathPair)) continue;\n        processedPathPairs.add(pathPair);\n        const localFile = localByPath.get(localPath);\n        const peerFile = peerByPath.get(peerPath);\n        if (!localFile || !peerFile) continue;\n        const duplicatePaths = new Set([\n          ...localCandidates.map((file) => file.path),\n          ...peerCandidates.map((file) => file.path),\n        ]);\n        const authoritativeSamePathEntries = new Set(entries.filter(\n          (entry) =>\n            duplicatePaths.has(entry.path)\n            && localFilesByPath.has(entry.path)\n            && peerFilesByPath.has(entry.path)\n            && entry.action !== \"identical\"\n        ));\n        if (authoritativeSamePathEntries.size > 0) {\n          for (const entry of entries) {\n            if (\n              duplicatePaths.has(entry.path)\n              && !authoritativeSamePathEntries.has(entry)\n              && (entry.action === \"pull\" || entry.action === \"push\" || entry.action === \"identical\")\n            ) {\n              removed.add(entry);\n              changed = true;\n            }\n          }\n          continue;\n        }\n        const unsafeEntry = entries.some(\n          (entry) => duplicatePaths.has(entry.path) && (entry.action === \"suppress\" || entry.action === \"conflict\")\n        );\n        if (unsafeEntry) continue;\n        for (const entry of entries) {\n          if (\n            duplicatePaths.has(entry.path) &&\n            (entry.action === \"pull\" || entry.action === \"push\" || entry.action === \"identical\")\n          ) {\n            removed.add(entry);\n          }\n        }\n        const semanticAgreement: ReconcileSemanticAgreement = {\n          local: { path: localPath, sha256: localFile.sha256 },\n          peer: { path: peerPath, sha256: peerFile.sha256 },\n        };\n        replacements.push({\n          path: localPath < peerPath ? localPath : peerPath,\n          namespace,\n          action: \"identical\",\n          reason: \"semantic_duplicate\",\n          semanticAgreement,\n          semanticChange: classifySemanticChange(\n            semanticAgreement,\n            priorSemanticByPathPair.get(semanticAgreementKey(semanticAgreement))\n          ),\n        });\n        changed = true;\n        continue;\n      }\n\n      const sameSideEntries = entries.filter((entry) => {\n        if (localPath && entry.reason === \"local_only\") {\n          return localCandidates.some((file) => file.path === entry.path);\n        }\n        if (peerPath && entry.reason === \"peer_only\") {\n          return peerCandidates.some((file) => file.path === entry.path);\n        }\n        return false;\n      });\n      const canonicalPath = localPath ?? peerPath;\n      const hasSharedCanonical = localPath !== undefined && localPath === peerPath;\n      if (!canonicalPath || sameSideEntries.length === 0 || (!hasSharedCanonical && sameSideEntries.length < 2)) {\n        continue;\n      }\n      for (const entry of sameSideEntries) {\n        if (entry.path !== canonicalPath) {\n          removed.add(entry);\n          changed = true;\n        }\n      }\n    }\n\n    if (removed.size > 0 || replacements.length > 0) {\n      entriesByNamespace.set(\n        namespace,\n        [...entries.filter((entry) => !removed.has(entry)), ...replacements].sort(comparePlanEntries)\n      );\n    }\n  }\n\n  if (!changed) return plan;\n  const entries = [...entriesByNamespace.values()].flat().sort(comparePlanEntries);\n  return {\n    entries,\n    byNamespace: summarizeReconcilePlan(entries),\n    converged: entries.every((entry) => entry.action === \"identical\"),\n  };\n}\n"],"mappings":"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","names":["entries"]}