@remnic/core 9.35.1 → 9.35.3

package/src/transfer/capsule-import.ts

@@ -1,8 +1,16 @@
-import { lstat, mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, realpath, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { gunzipSync } from "node:zlib";
 import { bumpMemoryCorpusVersionForDir } from "../memory-corpus-version.js";
+import {
+  HistoricalEntityCanonicalIdCache,
+  readEntityRefFromFrontmatter,
+  canonicalizeEntityRefFrontmatter,
+  classifyEntityRefWritePath,
+  repairContentAfterJournalMove,
+  requestEntityCanonicalIdReconcile,
+} from "../storage/entity-canonical-id-references.js";
 import {
   createVersion,
   type VersioningConfig,
@@ -381,6 +389,26 @@ export async function importCapsule(
   // atomic (mkdir + writeFile pair).
   const imported: ImportCapsuleImportedRecord[] = [];
   const skipped: ImportCapsuleSkippedRecord[] = [];
+  // The target's completed migration journal is a write boundary here too
+  // (issue #2213): a capsule can carry pre-migration memories whose entityRef
+  // the target already renamed, and no recurring reconciliation pass exists
+  // to absorb a stale ref after the fact. Read through the identity-keyed
+  // cache PER RECORD so a peer migration completing mid-import is picked up
+  // for every record written after it (one lstat per record).
+  const journalStateDir = path.join(rootReal, "state");
+  const historicalIdCache = new HistoricalEntityCanonicalIdCache();
+  // Entity pages in THIS capsule can re-establish collisions the target's
+  // journal already resolved (Codex P1): once the next migration parks the
+  // mapping, a memory canonicalized onto the canonical claimant is
+  // permanently misattributed. Memories whose ref targets a capsule-supplied
+  // entity id import byte-faithful behind the reconcile marker instead; the
+  // migration settles the collision and rewrites references per its verdict.
+  const capsuleEntityIds = new Set(
+    bundle.records
+      .map((record) => computeTargetPath(record.path, mode, capsule.id))
+      .filter((rel) => classifyEntityRefWritePath(rootReal, path.join(rootReal, fromPosixRelPath(rel))) === "entity")
+      .map((rel) => path.basename(rel, ".md")),
+  );
 
   // Sort by source path so the imported/skipped lists are deterministic
   // regardless of bundle order. (`exportCapsule` already sorts; we re-sort
@@ -389,6 +417,11 @@ export async function importCapsule(
     a.path.localeCompare(b.path),
   );
 
+  // The reconcile marker is published ONCE, after every record landed
+  // (Codex P1, round 21): a per-record marker could be consumed by a peer
+  // between a legacy-preserving memory write and its colliding entity page,
+  // canonicalizing the memory onto the wrong claimant irreversibly.
+  let reconcileNeeded = false;
   for (const rec of sortedRecords) {
     const targetRel = computeTargetPath(rec.path, mode, capsule.id);
     // Use rootReal (realpath-resolved) to stay consistent with phase 1's
@@ -431,13 +464,62 @@ export async function importCapsule(
     let contentToWrite = rec.content;
     let rewroteId = false;
     if (mode === "fork") {
-      const forked = rewriteFrontmatterIdForFork(rec.content, capsule.id, opts.now);
+      const forked = rewriteFrontmatterIdForFork(contentToWrite, capsule.id, opts.now);
       contentToWrite = forked.content;
       rewroteId = forked.rewrote;
     }
 
     await mkdir(path.dirname(targetAbs), { recursive: true });
-    await writeFile(targetAbs, contentToWrite, "utf-8");
+    // Resolve at the write itself (mirrors capsule-merge): a peer migration
+    // can complete during the snapshot/mkdir awaits, and capsule writes bump
+    // only the corpus version, which the migration fingerprint ignores. The
+    // post-write REPAIR re-canonicalizes and rewrites when the journal moved
+    // across the write itself (a parked mapping cannot be fixed after the
+    // fact by the reconcile pass). Only memory-tier records canonicalize;
+    // entities/ pages carry relationship TARGETS only
+    // rewriteRelationshipTargets understands, so they import byte-faithful
+    // with a reconcile marker; everything else imports losslessly.
+    const targetKind = classifyEntityRefWritePath(rootReal, targetAbs);
+    const rawRef = targetKind === "memory" ? readEntityRefFromFrontmatter(contentToWrite) : null;
+    if (targetKind === "memory" && rawRef !== null && capsuleEntityIds.has(rawRef)) {
+      // Ref targets a capsule-supplied entity page (potential collision
+      // claimant): keep the legacy bytes; the DEFERRED marker below lets the
+      // migration settle the collision and rewrite per its verdict (Codex P1).
+      await writeFile(targetAbs, contentToWrite, "utf-8");
+      reconcileNeeded = true;
+    } else if (targetKind === "memory") {
+      const idsAtWrite = historicalIdCache.get(journalStateDir);
+      const rawRecord = contentToWrite;
+      contentToWrite = canonicalizeEntityRefFrontmatter(rawRecord, idsAtWrite);
+      // Snapshot the pre-write bytes: a repair failure after the write must
+      // restore them (or remove a newly created target), or the import
+      // reports failure while an overwrite already destroyed the prior state
+      // and the skipped corpus bump leaves warm caches stale (AGENTS.md §14).
+      const originalBytes = await readFile(targetAbs, "utf-8").catch(() => null);
+      await writeFile(targetAbs, contentToWrite, "utf-8");
+      try {
+        await repairContentAfterJournalMove({
+          stateDir: journalStateDir,
+          cache: historicalIdCache,
+          idsAtWrite,
+          rawContent: rawRecord,
+          lastWritten: contentToWrite,
+          rewrite: (content) => writeFile(targetAbs, content, "utf-8"),
+        });
+      } catch (err) {
+        if (originalBytes === null) {
+          await unlink(targetAbs).catch(() => undefined);
+        } else {
+          await writeFile(targetAbs, originalBytes, "utf-8").catch(() => undefined);
+        }
+        throw err;
+      }
+    } else {
+      await writeFile(targetAbs, contentToWrite, "utf-8");
+      if (targetKind === "entity") {
+        reconcileNeeded = true;
+      }
+    }
     // Bump the corpus sentinel per write (Cursor Medium, #1902): a concurrent
     // readAllMemories during the import must rescan and see records already on
     // disk, never the pre-import corpus, mid-batch.
@@ -450,6 +532,12 @@ export async function importCapsule(
     });
   }
 
+  // Every record — including every collision claimant entity page — is on
+  // disk; NOW the reconcile pass can settle collisions safely.
+  if (reconcileNeeded) {
+    await requestEntityCanonicalIdReconcile(journalStateDir);
+  }
+
   // Sort skipped for stable output (see comment above).
   skipped.sort((a, b) => a.path.localeCompare(b.path));
 

package/src/transfer/capsule-merge.ts

@@ -1,7 +1,15 @@
-import { lstat, mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, realpath, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { gunzipSync } from "node:zlib";
 import { bumpMemoryCorpusVersionForDir } from "../memory-corpus-version.js";
+import {
+  HistoricalEntityCanonicalIdCache,
+  canonicalizeEntityRefFrontmatter,
+  readEntityRefFromFrontmatter,
+  classifyEntityRefWritePath,
+  repairContentAfterJournalMove,
+  requestEntityCanonicalIdReconcile,
+} from "../storage/entity-canonical-id-references.js";
 import {
   createVersion,
   type VersioningConfig,
@@ -349,6 +357,83 @@ export async function mergeCapsule(
   const merged: MergeCapsuleWrittenRecord[] = [];
   const skipped: MergeCapsuleSkippedRecord[] = [];
   const conflicts: MergeCapsuleConflictRecord[] = [];
+  // Same write-boundary rule as capsule-import (issue #2213): records land
+  // with their entityRef resolved through the target's migration journal,
+  // read through the identity-keyed cache PER RECORD so a peer migration
+  // completing mid-merge is picked up for every record written after it.
+  const journalStateDir = path.join(rootReal, "state");
+  const historicalIdCache = new HistoricalEntityCanonicalIdCache();
+  // Entity pages in THIS capsule can re-establish collisions the target's
+  // journal already resolved (Codex P1): once the next migration parks the
+  // mapping, a memory canonicalized onto the canonical claimant is
+  // permanently misattributed. Memories whose ref targets a capsule-supplied
+  // entity id merge byte-faithful behind the reconcile marker instead.
+  const capsuleEntityIds = new Set(
+    bundle.records
+      .filter((record) =>
+        classifyEntityRefWritePath(rootReal, path.join(rootReal, fromPosixRelPath(record.path))) === "entity")
+      .map((record) => path.basename(record.path, ".md")),
+  );
+  // Write a record with its entityRef resolved AT the write, then repair if
+  // the journal moved across the write itself — a parked mapping cannot be
+  // fixed after the fact by the reconcile pass (issue #2213). Only memory-tier
+  // records canonicalize; entities/ pages carry relationship TARGETS only
+  // rewriteRelationshipTargets understands, so they merge byte-faithful with
+  // a reconcile marker; everything else merges losslessly. The corpus bump
+  // lands AFTER the repair so a warm cache rescan never captures pre-repair
+  // bytes.
+  // The reconcile marker is published ONCE, after every record landed
+  // (Codex P1, round 21): a per-record marker could be consumed by a peer
+  // between a legacy-preserving memory write and its colliding entity page,
+  // canonicalizing the memory onto the wrong claimant irreversibly.
+  let reconcileNeeded = false;
+  const writeCanonicalRecord = async (targetAbs: string, rawContent: string): Promise<void> => {
+    const kind = classifyEntityRefWritePath(rootReal, targetAbs);
+    const rawRef = kind === "memory" ? readEntityRefFromFrontmatter(rawContent) : null;
+    if (kind === "memory" && rawRef !== null && capsuleEntityIds.has(rawRef)) {
+      // Ref targets a capsule-supplied entity page (potential collision
+      // claimant): keep the legacy bytes; the deferred marker lets the
+      // migration settle the collision and rewrite per its verdict (Codex P1).
+      await writeFile(targetAbs, rawContent, "utf-8");
+      reconcileNeeded = true;
+      bumpMemoryCorpusVersionForDir(rootReal); // per-write bump (Cursor Medium, #1902)
+      return;
+    }
+    if (kind !== "memory") {
+      await writeFile(targetAbs, rawContent, "utf-8");
+      if (kind === "entity") {
+        reconcileNeeded = true;
+      }
+      bumpMemoryCorpusVersionForDir(rootReal); // per-write bump (Cursor Medium, #1902)
+      return;
+    }
+    const idsAtWrite = historicalIdCache.get(journalStateDir);
+    const written = canonicalizeEntityRefFrontmatter(rawContent, idsAtWrite);
+    // Snapshot the pre-write bytes: a repair failure after the write must
+    // restore them (or remove a newly created target) before propagating —
+    // the merge reports failure, so disk must return to its pre-write state
+    // and warm caches stay consistent (AGENTS.md §14).
+    const originalBytes = await readLocalFile(targetAbs);
+    await writeFile(targetAbs, written, "utf-8");
+    try {
+      await repairContentAfterJournalMove({
+        stateDir: journalStateDir,
+        cache: historicalIdCache,
+        idsAtWrite,
+        rawContent,
+        lastWritten: written,
+        rewrite: (content) => writeFile(targetAbs, content, "utf-8"),
+      });
+    } catch (err) {
+      if (originalBytes === null) {
+        await unlink(targetAbs).catch(() => undefined);
+      } else {
+        await writeFile(targetAbs, originalBytes, "utf-8").catch(() => undefined);
+      }
+      throw err;
+    }
+    bumpMemoryCorpusVersionForDir(rootReal); // per-write bump (Cursor Medium, #1902)
+  };
 
   // Sort by source path for deterministic output (mirrors capsule-import.ts).
   const sortedRecords = [...bundle.records].sort((a, b) =>
@@ -362,22 +447,48 @@ export async function mergeCapsule(
     const localContent = await readLocalFile(targetAbs);
 
     if (localContent === null) {
-      // No local copy — always write regardless of mode.
+      // No local copy — always write regardless of mode. Resolve at the write
+      // itself and verify the journal afterwards: a peer migration completing
+      // during any of these awaits (or the write) would otherwise strand the
+      // reference — capsule writes bump only the corpus version, which the
+      // migration fingerprint deliberately ignores.
       await mkdir(path.dirname(targetAbs), { recursive: true });
-      await writeFile(targetAbs, rec.content, "utf-8");
-      bumpMemoryCorpusVersionForDir(rootReal); // per-write bump (Cursor Medium, #1902)
+      await writeCanonicalRecord(targetAbs, rec.content);
       merged.push({ sourcePath: rec.path, targetPath: rec.path, snapshotted: false });
       continue;
     }
 
-    // Local file exists. Check if it is byte-identical to the archive entry.
+    // Local file exists. A local copy already holding the CANONICALIZED form
+    // (computed AFTER the local read, so a journal published during that
+    // await is reflected) is done. A local copy matching the RAW archive
+    // bytes while a mapping applies is UPGRADED in place — skipping would
+    // leave the legacy entityRef on disk forever, since corpus bumps no
+    // longer trigger migration rewrites (issue #2213).
+    const idsAtCompare = historicalIdCache.get(journalStateDir);
+    const compareRef = readEntityRefFromFrontmatter(rec.content);
+    const canonicalContent =
+      classifyEntityRefWritePath(rootReal, targetAbs) === "memory"
+      && !(compareRef !== null && capsuleEntityIds.has(compareRef))
+        ? canonicalizeEntityRefFrontmatter(rec.content, idsAtCompare)
+        : rec.content;
     const { sha256: localSha256 } = sha256String(localContent);
-
-    if (localSha256 === entry.sha256) {
-      // Byte-identical — no write needed.
+    const canonicalSha256 =
+      canonicalContent === rec.content ? entry.sha256 : sha256String(canonicalContent).sha256;
+
+    // The identical verdict is only valid for the snapshot it was computed
+    // under (Codex P1): a mapping parked/removed mid-compare can make the
+    // local copy's formerly-canonical ref stale with nothing left to repair
+    // it. A moved journal falls through to the write path, which resolves at
+    // the write and repairs after it.
+    if (localSha256 === canonicalSha256 && historicalIdCache.get(journalStateDir) === idsAtCompare) {
       skipped.push({ path: rec.path, reason: "identical" });
       continue;
     }
+    if (localSha256 === canonicalSha256 || localSha256 === entry.sha256) {
+      await writeCanonicalRecord(targetAbs, rec.content);
+      merged.push({ sourcePath: rec.path, targetPath: rec.path, snapshotted: false });
+      continue;
+    }
 
     // Content differs → conflict.
     const { sha256: archiveSha256 } = sha256String(rec.content);
@@ -409,11 +520,18 @@ export async function mergeCapsule(
       snapshotted = true;
     }
 
-    await writeFile(targetAbs, rec.content, "utf-8");
-    bumpMemoryCorpusVersionForDir(rootReal); // per-write bump (Cursor Medium, #1902)
+    // Same write-time re-resolve + post-write repair as above — the
+    // snapshot/read awaits give a peer migration a real window.
+    await writeCanonicalRecord(targetAbs, rec.content);
     merged.push({ sourcePath: rec.path, targetPath: rec.path, snapshotted });
   }
 
+  // Every record — including every collision claimant entity page — is on
+  // disk; NOW the reconcile pass can settle collisions safely.
+  if (reconcileNeeded) {
+    await requestEntityCanonicalIdReconcile(journalStateDir);
+  }
+
   // Sort output lists for determinism.
   merged.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath));
   skipped.sort((a, b) => a.path.localeCompare(b.path));

package/dist/capsule-merge-2H2IUTBT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/transfer/capsule-merge.ts"],"sourcesContent":["import { lstat, mkdir, readFile, realpath, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { gunzipSync } from \"node:zlib\";\nimport { bumpMemoryCorpusVersionForDir } from \"../memory-corpus-version.js\";\nimport {\n  createVersion,\n  type VersioningConfig,\n  type VersioningLogger,\n} from \"../page-versioning.js\";\nimport {\n  assertIsDirectoryNotSymlink,\n  assertRealpathInsideRoot,\n  fromPosixRelPath,\n  isPathInsideRoot,\n  sha256String,\n} from \"./fs-utils.js\";\nimport {\n  parseExportBundle,\n  type CapsuleBlock,\n  type ExportManifestV2,\n  type ExportMemoryRecordV1,\n} from \"./types.js\";\n\n/**\n * Three-way conflict-resolution mode for {@link mergeCapsule}.\n *\n * A \"conflict\" is defined as: the same memory-file path exists in both the\n * source archive and the target directory AND the content hash of the local\n * file differs from the archive's manifest entry for that path.\n *\n * Files that exist only in the archive (no local counterpart) are always\n * written regardless of mode — there is no conflict to resolve.\n *\n * Files that are byte-identical (same content hash in both locations) are\n * recorded as {@link MergeCapsuleResult.skipped} with reason `\"identical\"` and\n * are never re-written regardless of mode; this is a no-op optimisation rather\n * than a conflict.\n *\n *  - `\"skip-conflicts\"` (default) — log the conflict, skip the conflicting\n *    archive entries, but continue importing non-conflicting entries. The\n *    resulting merge is the union of:\n *      - all non-conflicting archive files (written to target)\n *      - all pre-existing local files (left unchanged)\n *\n *  - `\"prefer-source\"` — for conflicting files, snapshot the local content via\n *    page-versioning (gotcha #54: snapshot before overwrite) then overwrite\n *    with the archive content.\n *\n *  - `\"prefer-local\"` — for conflicting files, keep the local content; the\n *    archive entry is skipped.\n */\nexport type MergeCapsuleConflictMode =\n  | \"skip-conflicts\"\n  | \"prefer-source\"\n  | \"prefer-local\";\n\n/**\n * Options accepted by {@link mergeCapsule}.\n *\n * `sourceArchive` — absolute or cwd-relative path to a `.capsule.json.gz`\n * archive produced by `exportCapsule`. Must be a V2 bundle.\n *\n * `targetRoot` — absolute or cwd-relative path to the memory directory that\n * receives the merged records. Must be an existing, non-symlink directory.\n *\n * `conflictMode` — see {@link MergeCapsuleConflictMode}. Defaults to\n * `\"skip-conflicts\"`.\n *\n * `versioning` — optional page-versioning config forwarded to\n * {@link createVersion} in `\"prefer-source\"` mode. When omitted or disabled,\n * overwrites proceed without snapshotting (not recommended for production).\n *\n * `log` — optional logger forwarded to {@link createVersion}.\n */\nexport interface MergeCapsuleOptions {\n  sourceArchive: string;\n  targetRoot: string;\n  conflictMode?: MergeCapsuleConflictMode;\n  versioning?: VersioningConfig;\n  log?: VersioningLogger;\n}\n\nexport interface MergeCapsuleWrittenRecord {\n  /** Capsule-relative posix path. */\n  sourcePath: string;\n  /** Memory-dir-relative posix path written on disk. */\n  targetPath: string;\n  /** Whether a page-versioning snapshot was taken before overwriting. */\n  snapshotted: boolean;\n}\n\nexport interface MergeCapsuleSkippedRecord {\n  /** Capsule-relative posix path. */\n  path: string;\n  /**\n   * Why the archive entry was not written.\n   *\n   * `\"conflict\"` — the entry existed locally with different content and the\n   * active mode did not resolve the conflict with a write (`\"skip-conflicts\"` /\n   * `\"prefer-local\"`).\n   *\n   * `\"identical\"` — the entry's content hash matches what is already on disk;\n   * no write is needed.\n   */\n  reason: \"conflict\" | \"identical\";\n}\n\nexport interface MergeCapsuleConflictRecord {\n  /** Capsule-relative posix path of the conflicting entry. */\n  path: string;\n  /** SHA-256 of the archive's copy. */\n  archiveSha256: string;\n  /** SHA-256 of the local copy. */\n  localSha256: string;\n}\n\nexport interface MergeCapsuleResult {\n  /** Records that were written to the target directory. */\n  merged: MergeCapsuleWrittenRecord[];\n  /**\n   * Records that were NOT written (conflict skipped, or byte-identical).\n   * Includes conflicts that were resolved by `\"prefer-local\"`.\n   */\n  skipped: MergeCapsuleSkippedRecord[];\n  /**\n   * Metadata about every detected conflict, regardless of which mode resolved\n   * it. Callers can use this to report \"N conflicts encountered; M overwritten\".\n   */\n  conflicts: MergeCapsuleConflictRecord[];\n  /** The manifest decoded from the archive. */\n  manifest: ExportManifestV2;\n}\n\n// ---------------------------------------------------------------------------\n// Main entry point\n// ---------------------------------------------------------------------------\n\n/**\n * Merge a V2 capsule archive into an existing memory directory using\n * three-way conflict semantics.\n *\n * Sequence:\n *   1. Read + gunzip + JSON.parse the archive.\n *   2. Validate through `parseExportBundle` (V1 rejected).\n *   3. Verify every record's content sha256 against the manifest.\n *      Any mismatch aborts BEFORE any file is written (gotcha #25).\n *   4. Classify each record as: new (no local copy), identical (same hash),\n *      or conflicting (different hash).\n *   5. Apply the selected {@link MergeCapsuleConflictMode} to conflicting\n *      entries; always write new entries; always skip identical entries.\n *\n * Determinism: `merged`, `skipped`, and `conflicts` are all returned sorted\n * by `path`/`sourcePath` so callers get stable output regardless of bundle\n * order.\n */\nexport async function mergeCapsule(\n  opts: MergeCapsuleOptions,\n): Promise<MergeCapsuleResult> {\n  const archiveAbs = path.resolve(opts.sourceArchive);\n  const rootAbs = path.resolve(opts.targetRoot);\n\n  await assertIsDirectoryNotSymlink(rootAbs, \"mergeCapsule\", \"targetRoot\");\n\n  const conflictMode: MergeCapsuleConflictMode =\n    opts.conflictMode ?? \"skip-conflicts\";\n\n  // Rule 51: reject invalid conflictMode values up-front before any I/O.\n  if (\n    conflictMode !== \"skip-conflicts\" &&\n    conflictMode !== \"prefer-source\" &&\n    conflictMode !== \"prefer-local\"\n  ) {\n    throw new Error(\n      `mergeCapsule: unknown conflictMode ${JSON.stringify(conflictMode)}; ` +\n        `expected \"skip-conflicts\", \"prefer-source\", or \"prefer-local\"`,\n    );\n  }\n\n  // ---------------------------------------------------------------------------\n  // Parse + validate archive\n  // ---------------------------------------------------------------------------\n\n  const raw = await readFile(archiveAbs);\n  let json: string;\n  try {\n    json = gunzipSync(raw).toString(\"utf-8\");\n  } catch (cause) {\n    throw new Error(\n      `mergeCapsule: archive is not a valid gzip file: ${archiveAbs}`,\n      { cause: cause as Error },\n    );\n  }\n\n  let parsedJson: unknown;\n  try {\n    parsedJson = JSON.parse(json);\n  } catch (cause) {\n    throw new Error(\n      `mergeCapsule: archive is not valid JSON after gunzip: ${archiveAbs}`,\n      { cause: cause as Error },\n    );\n  }\n\n  const parsed = parseExportBundle(parsedJson);\n  if (parsed.capsuleVersion !== 2) {\n    throw new Error(\n      \"mergeCapsule: archive is V1; only V2 capsule archives are supported\",\n    );\n  }\n\n  const bundle = parsed.bundle as {\n    manifest: ExportManifestV2;\n    records: ExportMemoryRecordV1[];\n  };\n  const manifest = bundle.manifest;\n  const capsule = manifest.capsule;\n\n  // Build path → manifest entry index for O(1) checksum lookup.\n  const manifestIndex = new Map<string, ExportManifestV2[\"files\"][number]>();\n  for (const f of manifest.files) {\n    manifestIndex.set(f.path, f);\n  }\n  if (manifestIndex.size !== manifest.files.length) {\n    throw new Error(\"mergeCapsule: manifest contains duplicate file paths\");\n  }\n\n  const recordPaths = new Set<string>();\n  for (const rec of bundle.records) {\n    if (recordPaths.has(rec.path)) {\n      throw new Error(\n        `mergeCapsule: bundle contains duplicate record path: ${rec.path}`,\n      );\n    }\n    recordPaths.add(rec.path);\n  }\n\n  // ---------------------------------------------------------------------------\n  // Phase 1: verify checksums + validate paths before ANY filesystem mutation.\n  // (gotcha #25: don't destroy old state before confirming new state succeeds)\n  // ---------------------------------------------------------------------------\n\n  const rootReal = await realpath(rootAbs).catch(() => rootAbs);\n\n  // Tracks normalized, case-folded target paths seen so far in phase 1.  Maps\n  // targetAbs.toLowerCase() → first source path so the collision error can name\n  // both offending entries.  Two manifest entries whose computed target paths\n  // normalise to the same absolute path (e.g. `subdir/file.md` and\n  // `subdir/./file.md`, or differing case on case-insensitive filesystems such\n  // as macOS and Windows) would both refer to the same inode.  In\n  // `skip-conflicts`/`prefer-local` modes one entry would be misclassified as a\n  // local conflict against the OTHER entry's just-written content; in\n  // `prefer-source` the second entry would silently overwrite the first.  We\n  // reject the import up-front before any write (Codex P2 thread on PR #748,\n  // mirroring `capsule-import.ts`).\n  const seenTargetPaths = new Map<string, string>();\n\n  for (const rec of bundle.records) {\n    // Checksum validation.\n    const entry = manifestIndex.get(rec.path);\n    if (!entry) {\n      throw new Error(\n        `mergeCapsule: archive checksum mismatch (record without manifest entry: ${rec.path})`,\n      );\n    }\n    const { sha256, bytes } = sha256String(rec.content);\n    if (sha256 !== entry.sha256 || bytes !== entry.bytes) {\n      throw new Error(\n        `mergeCapsule: archive checksum mismatch for ${rec.path}: ` +\n          `expected sha256=${entry.sha256} bytes=${entry.bytes}, ` +\n          `got sha256=${sha256} bytes=${bytes}`,\n      );\n    }\n\n    // Path-traversal validation (mirrors capsule-import.ts).\n    if (rec.path.includes(\"\\\\\")) {\n      throw new Error(\n        `mergeCapsule: record path contains backslash separators (Windows-style paths are not allowed): ${rec.path}`,\n      );\n    }\n    const posixNormalized = path.posix.normalize(rec.path);\n    if (\n      rec.path.startsWith(\"/\") ||\n      rec.path.split(\"/\").some((seg) => seg === \"..\") ||\n      posixNormalized.startsWith(\"..\") ||\n      posixNormalized.startsWith(\"/\")\n    ) {\n      throw new Error(\n        `mergeCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Lexical root containment check.\n    const targetAbs = path.join(rootReal, fromPosixRelPath(rec.path));\n    if (!isPathInsideRoot(rootReal, targetAbs)) {\n      throw new Error(\n        `mergeCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Symlink-aware containment check (shared helper from fs-utils).\n    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, \"mergeCapsule\");\n\n    // Target-file symlink guard: if the target already exists as a symlink,\n    // reject — writes through symlinks can redirect to unexpected locations.\n    const targetLstat = await lstat(targetAbs).catch(() => null);\n    if (targetLstat !== null && targetLstat.isSymbolicLink()) {\n      throw new Error(\n        `mergeCapsule: record target is a symlink and cannot be written to safely: ${rec.path}`,\n      );\n    }\n\n    // Duplicate normalized target path detection (Codex P2 #748, mirrors\n    // capsule-import.ts).  `path.join` already normalises `.` segments\n    // (e.g. `subdir/./file.md` → `subdir/file.md`).  On case-insensitive\n    // filesystems (macOS default, Windows), two paths that differ only in case\n    // would resolve to the same inode.  We fold the dedup key to lowercase so\n    // that `subdir/File.md` and `subdir/file.md` are detected as duplicates\n    // before any write occurs.  This is intentionally unconditional: the cost\n    // of an extra `.toLowerCase()` on case-sensitive filesystems is negligible,\n    // and a defensive lowercase is far simpler than probing filesystem\n    // case-sensitivity at runtime.  Without this guard, prefer-source mode\n    // would silently overwrite one entry with the other, and skip-conflicts /\n    // prefer-local would misclassify the second entry as a local conflict\n    // against the first entry's freshly written content.\n    const dedupKey = targetAbs.toLowerCase();\n    const firstSourcePath = seenTargetPaths.get(dedupKey);\n    if (firstSourcePath !== undefined) {\n      throw new Error(\n        `mergeCapsule: manifest contains two entries that resolve to the same target path: ` +\n          `\"${firstSourcePath}\" and \"${rec.path}\" both map to \"${rec.path}\"`,\n      );\n    }\n    seenTargetPaths.set(dedupKey, rec.path);\n  }\n\n  // Detect manifest-only entries (missing record). Treat as corruption.\n  for (const f of manifest.files) {\n    if (!recordPaths.has(f.path)) {\n      throw new Error(\n        `mergeCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`,\n      );\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Phase 2: classify records and apply conflict mode.\n  // ---------------------------------------------------------------------------\n\n  const merged: MergeCapsuleWrittenRecord[] = [];\n  const skipped: MergeCapsuleSkippedRecord[] = [];\n  const conflicts: MergeCapsuleConflictRecord[] = [];\n\n  // Sort by source path for deterministic output (mirrors capsule-import.ts).\n  const sortedRecords = [...bundle.records].sort((a, b) =>\n    a.path.localeCompare(b.path),\n  );\n\n  for (const rec of sortedRecords) {\n    const targetAbs = path.join(rootReal, fromPosixRelPath(rec.path));\n    const entry = manifestIndex.get(rec.path)!; // validated above\n\n    const localContent = await readLocalFile(targetAbs);\n\n    if (localContent === null) {\n      // No local copy — always write regardless of mode.\n      await mkdir(path.dirname(targetAbs), { recursive: true });\n      await writeFile(targetAbs, rec.content, \"utf-8\");\n      bumpMemoryCorpusVersionForDir(rootReal); // per-write bump (Cursor Medium, #1902)\n      merged.push({ sourcePath: rec.path, targetPath: rec.path, snapshotted: false });\n      continue;\n    }\n\n    // Local file exists. Check if it is byte-identical to the archive entry.\n    const { sha256: localSha256 } = sha256String(localContent);\n\n    if (localSha256 === entry.sha256) {\n      // Byte-identical — no write needed.\n      skipped.push({ path: rec.path, reason: \"identical\" });\n      continue;\n    }\n\n    // Content differs → conflict.\n    const { sha256: archiveSha256 } = sha256String(rec.content);\n    conflicts.push({\n      path: rec.path,\n      archiveSha256,\n      localSha256,\n    });\n\n    if (conflictMode === \"skip-conflicts\" || conflictMode === \"prefer-local\") {\n      // Keep local copy, skip archive entry.\n      skipped.push({ path: rec.path, reason: \"conflict\" });\n      continue;\n    }\n\n    // conflictMode === \"prefer-source\": snapshot local then overwrite.\n    let snapshotted = false;\n    if (opts.versioning && opts.versioning.enabled) {\n      // Gotcha #54: snapshot BEFORE overwriting.\n      await createVersion(\n        targetAbs,\n        localContent,\n        \"manual\",\n        opts.versioning,\n        opts.log,\n        `capsule-merge: ${capsule.id}`,\n        rootReal,\n      );\n      snapshotted = true;\n    }\n\n    await writeFile(targetAbs, rec.content, \"utf-8\");\n    bumpMemoryCorpusVersionForDir(rootReal); // per-write bump (Cursor Medium, #1902)\n    merged.push({ sourcePath: rec.path, targetPath: rec.path, snapshotted });\n  }\n\n  // Sort output lists for determinism.\n  merged.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath));\n  skipped.sort((a, b) => a.path.localeCompare(b.path));\n  conflicts.sort((a, b) => a.path.localeCompare(b.path));\n\n  // Per-write corpus bumps happen inside the loop above (Cursor Medium, #1902):\n  // a concurrent readAllMemories during the merge rescans and never serves the\n  // pre-merge corpus mid-batch.\n\n  return { merged, skipped, conflicts, manifest };\n}\n\n// ---------------------------------------------------------------------------\n// Private helpers\n// ---------------------------------------------------------------------------\n\nasync function readLocalFile(absPath: string): Promise<string | null> {\n  const st = await stat(absPath).catch(() => null);\n  if (!st || !st.isFile()) return null;\n  return readFile(absPath, \"utf-8\");\n}\n\n// Re-export CapsuleBlock so callers don't need a deep import from types.ts.\nexport type { CapsuleBlock };\n"],"mappings":"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","names":[]}

package/dist/chunk-4RNZMRAV.js

@@ -1,60 +0,0 @@
-// src/local-llm-helpers.ts
-function isAbortError(err) {
-  if (!err || typeof err !== "object") return false;
-  const maybe = err;
-  return maybe.name === "AbortError" || maybe.message === "This operation was aborted" || maybe.message === "The operation was aborted";
-}
-function waitForRetryBackoff(backoffMs, signal) {
-  return new Promise((resolve) => {
-    let settled = false;
-    let timer;
-    const onAbort = () => {
-      if (settled) return;
-      settled = true;
-      if (timer) clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-      resolve(false);
-    };
-    const onTimer = () => {
-      if (settled) return;
-      settled = true;
-      signal?.removeEventListener("abort", onAbort);
-      resolve(true);
-    };
-    timer = setTimeout(onTimer, backoffMs);
-    if (signal) {
-      if (signal.aborted) onAbort();
-      else signal.addEventListener("abort", onAbort, { once: true });
-    }
-  });
-}
-function normalizeBackendTripReason(reason) {
-  const cleaned = reason.replace(/\s+/g, " ").replace(/^[-:–—\s]+/, "").trim();
-  if (!cleaned) return "unknown local backend failure";
-  return cleaned.length > 160 ? `${cleaned.slice(0, 157)}...` : cleaned;
-}
-function extractNonRecoverableBackendReason(reason) {
-  const match = reason.match(
-    /Failed to load model|Library not loaded|different Team IDs|code signature|llm_engine_mlx_amphibian/i
-  );
-  return match?.[0] ?? null;
-}
-function extractNonRecoverableBackendReasonFromErrorText(errorText) {
-  const directReason = extractNonRecoverableBackendReason(errorText);
-  if (directReason) return directReason;
-  try {
-    const parsed = JSON.parse(errorText);
-    return extractNonRecoverableBackendReason(parsed?.error?.message ?? "");
-  } catch {
-    return null;
-  }
-}
-
-export {
-  isAbortError,
-  waitForRetryBackoff,
-  normalizeBackendTripReason,
-  extractNonRecoverableBackendReason,
-  extractNonRecoverableBackendReasonFromErrorText
-};
-//# sourceMappingURL=chunk-4RNZMRAV.js.map

package/dist/chunk-4RNZMRAV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/local-llm-helpers.ts"],"sourcesContent":["export function isAbortError(err: unknown): boolean {\n  if (!err || typeof err !== \"object\") return false;\n  const maybe = err as { name?: string; message?: string };\n  return (\n    maybe.name === \"AbortError\" ||\n    maybe.message === \"This operation was aborted\" ||\n    maybe.message === \"The operation was aborted\"\n  );\n}\n\nexport function waitForRetryBackoff(backoffMs: number, signal?: AbortSignal): Promise<boolean> {\n  return new Promise((resolve) => {\n    let settled = false;\n    let timer: NodeJS.Timeout | undefined;\n    const onAbort = (): void => {\n      if (settled) return;\n      settled = true;\n      if (timer) clearTimeout(timer);\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve(false);\n    };\n    const onTimer = (): void => {\n      if (settled) return;\n      settled = true;\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve(true);\n    };\n    timer = setTimeout(onTimer, backoffMs);\n    if (signal) {\n      if (signal.aborted) onAbort();\n      else signal.addEventListener(\"abort\", onAbort, { once: true });\n    }\n  });\n}\n\nexport function normalizeBackendTripReason(reason: string): string {\n  const cleaned = reason.replace(/\\s+/g, \" \").replace(/^[-:–—\\s]+/, \"\").trim();\n  if (!cleaned) return \"unknown local backend failure\";\n  return cleaned.length > 160 ? `${cleaned.slice(0, 157)}...` : cleaned;\n}\n\nexport function extractNonRecoverableBackendReason(reason: string): string | null {\n  const match = reason.match(\n    /Failed to load model|Library not loaded|different Team IDs|code signature|llm_engine_mlx_amphibian/i,\n  );\n  return match?.[0] ?? null;\n}\n\nexport function extractNonRecoverableBackendReasonFromErrorText(errorText: string): string | null {\n  const directReason = extractNonRecoverableBackendReason(errorText);\n  if (directReason) return directReason;\n  try {\n    const parsed = JSON.parse(errorText) as { error?: { message?: string } };\n    return extractNonRecoverableBackendReason(parsed?.error?.message ?? \"\");\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";AAAO,SAAS,aAAa,KAAuB;AAClD,MAAI,CAAC,OAAO,OAAO,QAAQ,SAAU,QAAO;AAC5C,QAAM,QAAQ;AACd,SACE,MAAM,SAAS,gBACf,MAAM,YAAY,gCAClB,MAAM,YAAY;AAEtB;AAEO,SAAS,oBAAoB,WAAmB,QAAwC;AAC7F,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,QAAI,UAAU;AACd,QAAI;AACJ,UAAM,UAAU,MAAY;AAC1B,UAAI,QAAS;AACb,gBAAU;AACV,UAAI,MAAO,cAAa,KAAK;AAC7B,cAAQ,oBAAoB,SAAS,OAAO;AAC5C,cAAQ,KAAK;AAAA,IACf;AACA,UAAM,UAAU,MAAY;AAC1B,UAAI,QAAS;AACb,gBAAU;AACV,cAAQ,oBAAoB,SAAS,OAAO;AAC5C,cAAQ,IAAI;AAAA,IACd;AACA,YAAQ,WAAW,SAAS,SAAS;AACrC,QAAI,QAAQ;AACV,UAAI,OAAO,QAAS,SAAQ;AAAA,UACvB,QAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,IAC/D;AAAA,EACF,CAAC;AACH;AAEO,SAAS,2BAA2B,QAAwB;AACjE,QAAM,UAAU,OAAO,QAAQ,QAAQ,GAAG,EAAE,QAAQ,cAAc,EAAE,EAAE,KAAK;AAC3E,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,SAAS,MAAM,GAAG,QAAQ,MAAM,GAAG,GAAG,CAAC,QAAQ;AAChE;AAEO,SAAS,mCAAmC,QAA+B;AAChF,QAAM,QAAQ,OAAO;AAAA,IACnB;AAAA,EACF;AACA,SAAO,QAAQ,CAAC,KAAK;AACvB;AAEO,SAAS,gDAAgD,WAAkC;AAChG,QAAM,eAAe,mCAAmC,SAAS;AACjE,MAAI,aAAc,QAAO;AACzB,MAAI;AACF,UAAM,SAAS,KAAK,MAAM,SAAS;AACnC,WAAO,mCAAmC,QAAQ,OAAO,WAAW,EAAE;AAAA,EACxE,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}