@remnic/core 9.45.3 → 9.45.4

package/dist/chunk-7CITSYSH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/external-wiki-search.ts"],"sourcesContent":["import path from \"node:path\";\nimport type { CitationEntry } from \"./citations.js\";\nimport {\n  type ExternalWikiCatalogEntry,\n  type ExternalWikiRoot,\n  loadExternalWikiCatalog,\n  readExternalWikiPage,\n} from \"./external-wiki.js\";\n\nexport type { ExternalWikiRoot } from \"./external-wiki.js\";\n\nconst DEFAULT_LIMIT = 6;\nconst MAX_LIMIT = 20;\nconst DEFAULT_MAX_CHARS_PER_HIT = 1_000;\nconst MAX_CHARS_PER_HIT = 8_000;\nconst DEFAULT_MAX_CANDIDATE_FILES = 100;\nconst MAX_CANDIDATE_FILES = 100;\n\nexport interface ExternalWikiSearchInput {\n  readonly query: string;\n  readonly limit?: number;\n  readonly wikiId?: string;\n  readonly maxCharsPerHit?: number;\n}\n\ninterface ExternalWikiSnippet {\n  readonly text: string;\n  readonly lineStart: number;\n  readonly lineEnd: number;\n}\n\nexport interface ExternalWikiSearchHit {\n  readonly wikiId: string;\n  readonly title: string;\n  readonly path: string;\n  readonly snippet: string;\n  readonly score: number;\n  readonly rank: number;\n  readonly citations: readonly CitationEntry[];\n  readonly indexBlurb?: string;\n}\n\nexport interface ExternalWikiSearchResult {\n  readonly query: string;\n  readonly hits: readonly ExternalWikiSearchHit[];\n  readonly count: number;\n  readonly degradedWikiIds: readonly string[];\n}\n\nexport interface ExternalWikiCandidate {\n  readonly path: string;\n  readonly score?: number;\n}\n\nexport interface ExternalWikiCandidateProvider {\n  search(root: ExternalWikiRoot, query: string, limit: number): Promise<readonly ExternalWikiCandidate[]>;\n}\n\nexport interface ExternalWikiSearchOptions {\n  readonly candidateProvider?: ExternalWikiCandidateProvider;\n  readonly maxCandidateFiles?: number;\n}\n\nexport class ExternalWikiSearchError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ExternalWikiSearchError\";\n  }\n}\n\ninterface RankedCatalogEntry {\n  readonly entry: ExternalWikiCatalogEntry;\n  readonly catalogScore: number;\n  readonly providerScore: number;\n  readonly providerRank?: number;\n}\n\ninterface UnrankedHit extends Omit<ExternalWikiSearchHit, \"rank\"> {}\n\nexport async function searchExternalWikis(\n  roots: readonly ExternalWikiRoot[],\n  input: ExternalWikiSearchInput,\n  options: ExternalWikiSearchOptions = {}\n): Promise<ExternalWikiSearchResult> {\n  const query = requireQuery(input.query);\n  const limit = boundedInteger(input.limit, DEFAULT_LIMIT, 1, MAX_LIMIT, \"limit\");\n  const maxCharsPerHit = boundedInteger(\n    input.maxCharsPerHit,\n    DEFAULT_MAX_CHARS_PER_HIT,\n    1,\n    MAX_CHARS_PER_HIT,\n    \"maxCharsPerHit\"\n  );\n  const maxCandidateFiles = boundedInteger(\n    options.maxCandidateFiles,\n    DEFAULT_MAX_CANDIDATE_FILES,\n    1,\n    MAX_CANDIDATE_FILES,\n    \"maxCandidateFiles\"\n  );\n  const selectedRoots = selectRoots(roots, input.wikiId);\n  const queryTokens = tokenize(query);\n  const degradedWikiIds = new Set<string>();\n  const perRootHits = await Promise.all(\n    selectedRoots.map(async (root) => {\n      try {\n        const catalog = await loadExternalWikiCatalog(root, { maxEntries: maxCandidateFiles });\n        if (!catalog.indexPresent) degradedWikiIds.add(root.id);\n        const candidates = await rankCandidates(\n          root,\n          catalog.entries,\n          query,\n          queryTokens,\n          maxCandidateFiles,\n          options.candidateProvider\n        );\n        return await readCandidateHits(root, candidates, query, queryTokens, maxCharsPerHit);\n      } catch {\n        degradedWikiIds.add(root.id);\n        return [];\n      }\n    })\n  );\n\n  const hits = perRootHits\n    .flat()\n    .sort(compareHits)\n    .slice(0, limit)\n    .map((hit, index): ExternalWikiSearchHit => ({ ...hit, rank: index + 1 }));\n\n  return {\n    query,\n    hits,\n    count: hits.length,\n    degradedWikiIds: [...degradedWikiIds].sort(),\n  };\n}\n\nfunction requireQuery(value: string): string {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new ExternalWikiSearchError(\"external wiki search query is required\");\n  }\n  return value.trim();\n}\n\nfunction boundedInteger(\n  value: number | undefined,\n  fallback: number,\n  minimum: number,\n  maximum: number,\n  field: string\n): number {\n  const resolved = value ?? fallback;\n  if (!Number.isInteger(resolved) || resolved < minimum || resolved > maximum) {\n    throw new ExternalWikiSearchError(`${field} must be an integer from ${minimum} to ${maximum}`);\n  }\n  return resolved;\n}\n\nfunction selectRoots(roots: readonly ExternalWikiRoot[], wikiId: string | undefined): ExternalWikiRoot[] {\n  const enabled = roots.filter((root) => root.enabled);\n  if (enabled.length === 0) {\n    throw new ExternalWikiSearchError(\"no enabled external wiki roots are configured\");\n  }\n  if (wikiId === undefined) return enabled;\n  const normalizedWikiId = wikiId.trim();\n  const selected = enabled.find((root) => root.id === normalizedWikiId);\n  if (!selected) {\n    throw new ExternalWikiSearchError(`unknown external wiki: ${normalizedWikiId || \"(empty)\"}`);\n  }\n  return [selected];\n}\n\nasync function rankCandidates(\n  root: ExternalWikiRoot,\n  entries: readonly ExternalWikiCatalogEntry[],\n  query: string,\n  queryTokens: readonly string[],\n  maxCandidateFiles: number,\n  provider: ExternalWikiCandidateProvider | undefined\n): Promise<RankedCatalogEntry[]> {\n  let provided: readonly ExternalWikiCandidate[] = [];\n  if (provider) {\n    try {\n      provided = await provider.search(root, query, maxCandidateFiles);\n    } catch {\n      provided = [];\n    }\n  }\n\n  const providerByPath = new Map<string, { score: number; rank: number }>();\n  for (const [index, candidate] of provided.slice(0, maxCandidateFiles).entries()) {\n    if (!providerByPath.has(candidate.path)) {\n      providerByPath.set(candidate.path, { score: finiteScore(candidate.score), rank: index });\n    }\n  }\n\n  return entries\n    .map((entry): RankedCatalogEntry => {\n      const providerCandidate = providerByPath.get(entry.path);\n      return {\n        entry,\n        catalogScore: scoreCatalogEntry(entry, query, queryTokens),\n        providerScore: providerCandidate?.score ?? 0,\n        ...(providerCandidate ? { providerRank: providerCandidate.rank } : {}),\n      };\n    })\n    .sort((left, right) => {\n      const leftProvided = left.providerRank !== undefined;\n      const rightProvided = right.providerRank !== undefined;\n      if (leftProvided !== rightProvided) return leftProvided ? -1 : 1;\n      if (left.providerRank !== right.providerRank) {\n        return (left.providerRank ?? Number.MAX_SAFE_INTEGER) - (right.providerRank ?? Number.MAX_SAFE_INTEGER);\n      }\n      if (right.catalogScore !== left.catalogScore) return right.catalogScore - left.catalogScore;\n      return left.entry.path.localeCompare(right.entry.path);\n    })\n    .slice(0, maxCandidateFiles);\n}\n\nasync function readCandidateHits(\n  root: ExternalWikiRoot,\n  candidates: readonly RankedCatalogEntry[],\n  query: string,\n  queryTokens: readonly string[],\n  maxCharsPerHit: number\n): Promise<UnrankedHit[]> {\n  const results = await Promise.all(\n    candidates.map(async (candidate): Promise<UnrankedHit | undefined> => {\n      try {\n        const page = await readExternalWikiPage(root, candidate.entry.path);\n        const pageScore = scorePage(page.title, page.content, query, queryTokens);\n        const score = candidate.catalogScore + candidate.providerScore + pageScore;\n        if (score <= 0) return undefined;\n        const snippet = extractSnippet(page.content, queryTokens, maxCharsPerHit);\n        const rootRelativePath = path.posix.join(root.pagesDir.replaceAll(\"\\\\\", \"/\"), page.path);\n        const citation: CitationEntry = {\n          path: rootRelativePath,\n          lineStart: snippet.lineStart,\n          lineEnd: snippet.lineEnd,\n          note: page.title,\n        };\n        return {\n          wikiId: root.id,\n          title: page.title,\n          path: rootRelativePath,\n          snippet: snippet.text,\n          score: roundScore(score),\n          citations: [citation],\n          ...(candidate.entry.indexBlurb === undefined ? {} : { indexBlurb: candidate.entry.indexBlurb }),\n        };\n      } catch {\n        return undefined;\n      }\n    })\n  );\n  return results.filter((result): result is UnrankedHit => result !== undefined);\n}\n\nfunction scoreCatalogEntry(entry: ExternalWikiCatalogEntry, query: string, queryTokens: readonly string[]): number {\n  return (\n    scoreText(entry.title, query, queryTokens, 16, 20) +\n    scoreText(entry.path, query, queryTokens, 8, 8) +\n    scoreText(entry.indexBlurb ?? \"\", query, queryTokens, 4, 6)\n  );\n}\n\nfunction scorePage(title: string, content: string, query: string, queryTokens: readonly string[]): number {\n  const titleScore = scoreText(title, query, queryTokens, 12, 16);\n  const lines = content.split(/\\r?\\n/u);\n  let bestLineScore = 0;\n  const matchedTokens = new Set<string>();\n  for (const line of lines) {\n    const normalizedLine = line.toLocaleLowerCase();\n    let lineScore = 0;\n    for (const token of queryTokens) {\n      if (!normalizedLine.includes(token)) continue;\n      matchedTokens.add(token);\n      lineScore += line.startsWith(\"#\") ? 6 : 3;\n    }\n    if (normalizedLine.includes(query.toLocaleLowerCase())) lineScore += 10;\n    bestLineScore = Math.max(bestLineScore, lineScore);\n  }\n  return titleScore + bestLineScore + matchedTokens.size * 2;\n}\n\nfunction scoreText(\n  value: string,\n  query: string,\n  queryTokens: readonly string[],\n  tokenWeight: number,\n  phraseWeight: number\n): number {\n  const normalized = value.toLocaleLowerCase();\n  let score = normalized.includes(query.toLocaleLowerCase()) ? phraseWeight : 0;\n  for (const token of queryTokens) {\n    if (normalized.includes(token)) score += tokenWeight;\n  }\n  return score;\n}\n\nfunction tokenize(value: string): string[] {\n  const tokens = value.toLocaleLowerCase().match(/[\\p{L}\\p{N}]+/gu) ?? [];\n  return [...new Set(tokens)];\n}\n\nfunction extractSnippet(content: string, queryTokens: readonly string[], maxChars: number): ExternalWikiSnippet {\n  const lines = content.split(/\\r?\\n/u);\n  if (lines.length === 0) return { text: \"\", lineStart: 1, lineEnd: 1 };\n  let bestIndex = 0;\n  let bestScore = -1;\n  for (const [index, line] of lines.entries()) {\n    const normalized = line.toLocaleLowerCase();\n    const matchCount = queryTokens.reduce((sum, token) => sum + (normalized.includes(token) ? 1 : 0), 0);\n    const score = matchCount * 2 + (matchCount > 0 && !/^#{1,6}\\s/u.test(line) ? 1 : 0);\n    if (score > bestScore) {\n      bestScore = score;\n      bestIndex = index;\n    }\n  }\n\n  let headingIndex = bestIndex;\n  while (headingIndex > 0 && !/^#{1,6}\\s/u.test(lines[headingIndex] ?? \"\")) headingIndex -= 1;\n  const bodyStart = Math.max(0, bestIndex - 1);\n  const endExclusive = Math.min(lines.length, bestIndex + 3);\n  const start = headingIndex < bodyStart ? headingIndex : bodyStart;\n  const selected =\n    headingIndex < bodyStart\n      ? [lines[headingIndex] ?? \"\", ...lines.slice(bodyStart, endExclusive)]\n      : lines.slice(start, endExclusive);\n  const snippet = selected.join(\"\\n\").trim();\n  if (snippet.length <= maxChars) {\n    return { text: snippet, lineStart: start + 1, lineEnd: endExclusive };\n  }\n\n  const normalizedSnippet = snippet.toLocaleLowerCase();\n  const firstMatch =\n    queryTokens\n      .map((token) => normalizedSnippet.indexOf(token))\n      .filter((index) => index >= 0)\n      .sort((left, right) => left - right)[0] ?? 0;\n  const windowStart = Math.max(0, Math.min(firstMatch - Math.floor(maxChars / 3), snippet.length - maxChars));\n  return {\n    text: snippet.slice(windowStart, windowStart + maxChars).trim(),\n    lineStart: start + 1,\n    lineEnd: endExclusive,\n  };\n}\n\nfunction finiteScore(score: number | undefined): number {\n  return typeof score === \"number\" && Number.isFinite(score) ? Math.max(0, score) : 0;\n}\n\nfunction roundScore(score: number): number {\n  return Math.round(score * 1_000) / 1_000;\n}\n\nfunction compareHits(left: UnrankedHit, right: UnrankedHit): number {\n  if (right.score !== left.score) return right.score - left.score;\n  const wikiComparison = left.wikiId.localeCompare(right.wikiId);\n  return wikiComparison !== 0 ? wikiComparison : left.path.localeCompare(right.path);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-227UFSEQ.js → chunk-7RZJWZ46.js}

@@ -1,3 +1,7 @@
+import {
+  searchConversationIndex,
+  searchConversationIndexFaissFailOpen
+} from "./chunk-A7Q43EUZ.js";
 import {
   failOpenFaissHealth
 } from "./chunk-ET356KSB.js";
@@ -5,10 +9,6 @@ import {
   rebuildConversationChunksFailOpen,
   upsertConversationChunksFailOpen
 } from "./chunk-72A4L5JJ.js";
-import {
-  searchConversationIndex,
-  searchConversationIndexFaissFailOpen
-} from "./chunk-A7Q43EUZ.js";
 
 // src/conversation-index/backend.ts
 function createConversationIndexBackend(options) {
@@ -235,4 +235,4 @@ function createFaissBackend(getFaiss) {
 export {
   createConversationIndexBackend
 };
-//# sourceMappingURL=chunk-227UFSEQ.js.map
+//# sourceMappingURL=chunk-7RZJWZ46.js.map

package/dist/{chunk-E5UK4VPE.js → chunk-7SHJHPTY.js}

@@ -1,10 +1,10 @@
-import {
-  getConfiguredNamespaces
-} from "./chunk-ULARSG5Z.js";
 import {
   resolveDefaultNamespaceRoot,
   resolveNamespaceStorageRoot
-} from "./chunk-LZ4LDKHZ.js";
+} from "./chunk-CLB32OHM.js";
+import {
+  getConfiguredNamespaces
+} from "./chunk-YN6ASZUG.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken,
@@ -2204,4 +2204,4 @@ export {
   runNamespaceMaintenancePlan,
   runNamespaceMaintenanceBatchPlan
 };
-//# sourceMappingURL=chunk-E5UK4VPE.js.map
+//# sourceMappingURL=chunk-7SHJHPTY.js.map

package/dist/{chunk-UVIKWC7M.js → chunk-7YERSTN7.js}

@@ -3,7 +3,7 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-E5UK4VPE.js";
+} from "./chunk-7SHJHPTY.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-CMTINOFS.js";
 import {
   summarizeCorpusAndReplica
-} from "./chunk-VUPTKTDV.js";
+} from "./chunk-2MRHJNWL.js";
 import {
   readJudgeVerdictStats
 } from "./chunk-OZKOPQCM.js";
@@ -25,49 +25,45 @@ import {
   runEvalBenchmarkCiGate,
   validateEvalBenchmarkPack
 } from "./chunk-3PY7VHV7.js";
+import {
+  runConsolidationProvenanceCheck
+} from "./chunk-HAYSYUAB.js";
 import {
   resolveCuratedIncludeFilesStatePath,
   resolveNativeKnowledgeStatePath,
   resolveOpenClawWorkspaceStatePath
 } from "./chunk-2DQ2XREU.js";
-import {
-  runConsolidationProvenanceCheck
-} from "./chunk-TSH56VPU.js";
 import {
   reportBufferSurpriseDistribution
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-CUM2BBPN.js";
+} from "./chunk-AUMWZSE7.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-D3J5SLQK.js";
+} from "./chunk-EJHEWCGQ.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-PDLBLTOK.js";
+} from "./chunk-EITZHSX6.js";
 import {
   listNamespaces
-} from "./chunk-E53DSZEN.js";
+} from "./chunk-C26TE27X.js";
 import {
   analyzeGraphHealth
 } from "./chunk-L2DPF4DF.js";
 import {
   StorageManager
-} from "./chunk-E6PNLPGJ.js";
+} from "./chunk-FZP32336.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
-import {
-  probeProjectionHealth
-} from "./chunk-3CSX3ETE.js";
 import {
   summarizeExtractionLiveness
 } from "./chunk-3SG4FGDV.js";
 import {
-  readEnvVar,
-  resolveHomeDir
-} from "./chunk-JUC24CTX.js";
+  probeProjectionHealth
+} from "./chunk-3CSX3ETE.js";
 import {
   resolveAccessSetupCapabilities,
   resolveCapabilities,
@@ -79,6 +75,10 @@ import {
   resolvePresentationCapabilities,
   resolveQmdCapabilities
 } from "./chunk-2XRE6FLM.js";
+import {
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-JUC24CTX.js";
 
 // src/operator-toolkit.ts
 import path from "path";
@@ -1683,4 +1683,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-UVIKWC7M.js.map
+//# sourceMappingURL=chunk-7YERSTN7.js.map

package/dist/{chunk-DLVPUX7U.js → chunk-7YKVM5H3.js}

@@ -3,8 +3,9 @@ import {
 } from "./chunk-IJ7HK452.js";
 import {
   pathMayCarryEntityRefs,
-  requestEntityCanonicalIdReconcile
-} from "./chunk-4J7G5SY4.js";
+  requestEntityCanonicalIdReconcile,
+  withRawEntityPageMutation
+} from "./chunk-NZBZ7IS2.js";
 import {
   ALL_CATEGORY_DIRS,
   RECALL_FALLBACK_DIRS
@@ -170,10 +171,11 @@ async function revertToVersion(pagePath, versionId, config, log = NOOP_LOGGER, m
     `reverted to version ${versionId}`,
     resolvedMemoryDir
   );
-  await writeFile(pagePath, targetContent, "utf-8");
+  await withRawEntityPageMutation(resolvedMemoryDir, pagePath, async () => {
+    await writeFile(pagePath, targetContent, "utf-8");
+  });
   const revertedTop = relPath(pagePath, resolvedMemoryDir).split(path.sep)[0];
-  const inRecallTier = RECALL_FALLBACK_DIRS.includes(revertedTop);
-  if (inRecallTier) {
+  if (RECALL_FALLBACK_DIRS.includes(revertedTop)) {
     bumpMemoryCorpusVersionForDir(resolvedMemoryDir);
   }
   if (pathMayCarryEntityRefs(resolvedMemoryDir, pagePath)) {
@@ -279,4 +281,4 @@ export {
   revertToVersion,
   diffVersions
 };
-//# sourceMappingURL=chunk-DLVPUX7U.js.map
+//# sourceMappingURL=chunk-7YKVM5H3.js.map

package/dist/chunk-7YKVM5H3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/page-versioning.ts"],"sourcesContent":["/**\n * Page-level versioning with history and revert (issue #371).\n *\n * Provides snapshot-based versioning for memory files using a sidecar\n * directory layout.  Each memory page gets a `.versions/<pageName>/`\n * subdirectory containing numbered snapshots and a `manifest.json` that\n * records the version history.\n *\n * Storage layout:\n *   memoryDir/\n *     facts/preferences.md              <- current file\n *     .versions/\n *       facts__preferences/\n *         manifest.json                  <- VersionHistory\n *         1.md                           <- version 1 snapshot\n *         2.md                           <- version 2 snapshot\n */\n\nimport { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport {\n  access,\n  mkdir,\n  readFile,\n  writeFile,\n  unlink,\n} from \"node:fs/promises\";\nimport { ALL_CATEGORY_DIRS, RECALL_FALLBACK_DIRS } from \"./utils/category-dir.js\";\nimport { bumpMemoryCorpusVersionForDir } from \"./memory-corpus-version.js\";\nimport {\n  pathMayCarryEntityRefs,\n  requestEntityCanonicalIdReconcile,\n} from \"./storage/entity-canonical-id-references.js\";\nimport { withRawEntityPageMutation } from \"./storage/entity-canonical-id-lock.js\";\n\n// ---------------------------------------------------------------------------\n// Public interfaces\n// ---------------------------------------------------------------------------\n\nexport interface PageVersion {\n  versionId: string;\n  timestamp: string;\n  contentHash: string;\n  sizeBytes: number;\n  trigger: VersionTrigger;\n  note?: string;\n}\n\nexport type VersionTrigger = \"write\" | \"consolidation\" | \"revert\" | \"manual\";\n\nexport interface VersionHistory {\n  pagePath: string;\n  versions: PageVersion[];\n  currentVersion: string;\n}\n\nexport interface VersioningConfig {\n  enabled: boolean;\n  maxVersionsPerPage: number;\n  sidecarDir: string;\n}\n\n// ---------------------------------------------------------------------------\n// Logger interface (minimal, avoids coupling to the host logger)\n// ---------------------------------------------------------------------------\n\nexport interface VersioningLogger {\n  debug(msg: string): void;\n  warn(msg: string): void;\n}\n\nconst NOOP_LOGGER: VersioningLogger = {\n  debug: () => {},\n  warn: () => {},\n};\n\n// ---------------------------------------------------------------------------\n// Per-page write lock (promise-chain pattern, see gotcha #40)\n// ---------------------------------------------------------------------------\n\nconst writeLocks = new Map<string, Promise<void>>();\n\nfunction withPageLock<T>(pageKey: string, fn: () => Promise<T>): Promise<T> {\n  const prev = writeLocks.get(pageKey) ?? Promise.resolve();\n  const next = prev.then(fn, fn); // run fn after previous completes, even if previous failed\n  writeLocks.set(pageKey, next.then(() => {}, () => {})); // recover chain per gotcha #40\n  return next;\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction contentHash(content: string): string {\n  return createHash(\"sha256\").update(content, \"utf-8\").digest(\"hex\");\n}\n\n/**\n * Derive a filesystem-safe sidecar key from a page path relative to memoryDir.\n *\n * `facts/2026-01-15/pref-001.md` -> `facts__2026-01-15__pref-001`\n *\n * Exported so the `remnic doctor` consolidation-provenance check (issue\n * #561 PR 4) resolves snapshot locations using the canonical algorithm\n * without re-implementing it — preventing silent drift if the key\n * format ever changes.\n */\nexport function sidecarKey(pagePath: string): string {\n  const withoutExt = pagePath.replace(/\\.md$/i, \"\");\n  return withoutExt.replace(/[\\\\/]/g, \"__\");\n}\n\nfunction sidecarDir(memoryDir: string, sidecar: string, pagePath: string): string {\n  return path.join(memoryDir, sidecar, sidecarKey(pagePath));\n}\n\nfunction manifestPath(memoryDir: string, sidecar: string, pagePath: string): string {\n  return path.join(sidecarDir(memoryDir, sidecar, pagePath), \"manifest.json\");\n}\n\nasync function fileExists(p: string): Promise<boolean> {\n  try {\n    await access(p);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function readManifest(\n  memoryDir: string,\n  sidecar: string,\n  pagePath: string,\n): Promise<VersionHistory> {\n  const mp = manifestPath(memoryDir, sidecar, pagePath);\n  if (!(await fileExists(mp))) {\n    return { pagePath, versions: [], currentVersion: \"0\" };\n  }\n  try {\n    const raw = await readFile(mp, \"utf-8\");\n    const parsed: unknown = JSON.parse(raw);\n    if (typeof parsed !== \"object\" || parsed === null) {\n      throw new Error(\"manifest root must be an object\");\n    }\n    const obj = parsed as Record<string, unknown>;\n    if (!Array.isArray(obj.versions)) {\n      throw new Error(\"manifest versions must be an array\");\n    }\n    const versions = obj.versions.map((entry, index) => {\n      if (!entry || typeof entry !== \"object\" || Array.isArray(entry)) {\n        throw new Error(`manifest version ${index} must be an object`);\n      }\n      const version = entry as Record<string, unknown>;\n      if (\n        typeof version.versionId !== \"string\" ||\n        !/^\\d+$/.test(version.versionId) ||\n        typeof version.timestamp !== \"string\" ||\n        typeof version.contentHash !== \"string\" ||\n        typeof version.sizeBytes !== \"number\" ||\n        !Number.isFinite(version.sizeBytes) ||\n        ![\"write\", \"consolidation\", \"revert\", \"manual\"].includes(String(version.trigger))\n      ) {\n        throw new Error(`manifest version ${index} has invalid shape`);\n      }\n      return version as unknown as PageVersion;\n    });\n    if (typeof obj.currentVersion !== \"string\" || !/^\\d+$/.test(obj.currentVersion)) {\n      throw new Error(\"manifest currentVersion must be a numeric string\");\n    }\n    const currentVersion = obj.currentVersion;\n    return { pagePath: typeof obj.pagePath === \"string\" ? obj.pagePath : pagePath, versions, currentVersion };\n  } catch (error) {\n    throw new Error(`page-versioning: invalid manifest ${mp}: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\nasync function writeManifest(\n  memoryDir: string,\n  sidecar: string,\n  pagePath: string,\n  history: VersionHistory,\n): Promise<void> {\n  const dir = sidecarDir(memoryDir, sidecar, pagePath);\n  await mkdir(dir, { recursive: true });\n  const mp = manifestPath(memoryDir, sidecar, pagePath);\n  await writeFile(mp, JSON.stringify(history, null, 2) + \"\\n\", \"utf-8\");\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Create a new version snapshot for a page.\n *\n * Call this BEFORE overwriting the current file so the previous content is\n * preserved. If the file does not exist yet (first write), the provided\n * `content` is snapshotted as version 1.\n *\n * Pruning: when the number of versions exceeds `config.maxVersionsPerPage`,\n * the oldest snapshots (and their files) are removed.\n */\nexport async function createVersion(\n  pagePath: string,\n  content: string,\n  trigger: VersionTrigger,\n  config: VersioningConfig,\n  log: VersioningLogger = NOOP_LOGGER,\n  note?: string,\n  memoryDir?: string,\n): Promise<PageVersion> {\n  const { sidecarDir: sidecar, maxVersionsPerPage } = config;\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const mPath = manifestPath(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));\n\n  return withPageLock(mPath, async () => {\n    const history = await readManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));\n    const nextId = String(history.versions.length > 0\n      ? Math.max(...history.versions.map((v) => Number(v.versionId))) + 1\n      : 1);\n\n    const hash = contentHash(content);\n    const version: PageVersion = {\n      versionId: nextId,\n      timestamp: new Date().toISOString(),\n      contentHash: hash,\n      sizeBytes: Buffer.byteLength(content, \"utf-8\"),\n      trigger,\n      ...(note !== undefined ? { note } : {}),\n    };\n\n    // Write snapshot file\n    const dir = sidecarDir(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));\n    await mkdir(dir, { recursive: true });\n    const ext = path.extname(pagePath) || \".md\";\n    const snapshotPath = path.join(dir, `${nextId}${ext}`);\n    await writeFile(snapshotPath, content, \"utf-8\");\n\n    history.versions.push(version);\n    history.currentVersion = nextId;\n\n    // Prune old versions if exceeding max\n    if (maxVersionsPerPage > 0 && history.versions.length > maxVersionsPerPage) {\n      const toRemove = history.versions.splice(0, history.versions.length - maxVersionsPerPage);\n      for (const old of toRemove) {\n        const oldPath = path.join(dir, `${old.versionId}${ext}`);\n        try {\n          await unlink(oldPath);\n        } catch {\n          log.debug(`page-versioning: could not remove old snapshot ${oldPath}`);\n        }\n      }\n    }\n\n    await writeManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir), history);\n    log.debug(`page-versioning: created version ${nextId} for ${pagePath} (trigger=${trigger})`);\n\n    return version;\n  });\n}\n\n/**\n * List all versions for a page.\n */\nexport async function listVersions(\n  pagePath: string,\n  config: VersioningConfig,\n  memoryDir?: string,\n): Promise<VersionHistory> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const rel = relPath(pagePath, resolvedMemoryDir);\n  const history = await readManifest(resolvedMemoryDir, config.sidecarDir, rel);\n  // Sort ascending by versionId (numeric)\n  history.versions.sort((a, b) => Number(a.versionId) - Number(b.versionId));\n  return history;\n}\n\n/**\n * Read the content of a specific version.\n */\nexport async function getVersion(\n  pagePath: string,\n  versionId: string,\n  config: VersioningConfig,\n  memoryDir?: string,\n): Promise<string> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const rel = relPath(pagePath, resolvedMemoryDir);\n  const ext = path.extname(pagePath) || \".md\";\n  const dir = sidecarDir(resolvedMemoryDir, config.sidecarDir, rel);\n  const snapshotPath = path.join(dir, `${versionId}${ext}`);\n\n  if (!(await fileExists(snapshotPath))) {\n    throw new Error(`Version ${versionId} not found for ${pagePath}`);\n  }\n\n  return readFile(snapshotPath, \"utf-8\");\n}\n\n/**\n * Revert a page to a previous version.\n *\n * 1. Reads the target version's content.\n * 2. Snapshots the CURRENT content as a new version (trigger: \"revert\").\n * 3. Writes the reverted content to the page file.\n *\n * Returns the newly created version entry for the revert snapshot.\n */\nexport async function revertToVersion(\n  pagePath: string,\n  versionId: string,\n  config: VersioningConfig,\n  log: VersioningLogger = NOOP_LOGGER,\n  memoryDir?: string,\n): Promise<PageVersion> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n\n  // Read target version content\n  const targetContent = await getVersion(pagePath, versionId, config, resolvedMemoryDir);\n\n  // Snapshot current content before overwriting\n  let currentContent = \"\";\n  try {\n    currentContent = await readFile(pagePath, \"utf-8\");\n  } catch {\n    // File may not exist; that's okay\n  }\n\n  const version = await createVersion(\n    pagePath,\n    currentContent,\n    \"revert\",\n    config,\n    log,\n    `reverted to version ${versionId}`,\n    resolvedMemoryDir,\n  );\n\n  await withRawEntityPageMutation(resolvedMemoryDir, pagePath, async () => {\n    await writeFile(pagePath, targetContent, \"utf-8\");\n  });\n  const revertedTop = relPath(pagePath, resolvedMemoryDir).split(path.sep)[0];\n  if ((RECALL_FALLBACK_DIRS as readonly string[]).includes(revertedTop)) {\n    bumpMemoryCorpusVersionForDir(resolvedMemoryDir);\n  }\n  if (pathMayCarryEntityRefs(resolvedMemoryDir, pagePath)) {\n    await requestEntityCanonicalIdReconcile(path.join(resolvedMemoryDir, \"state\"));\n  }\n  log.debug(`page-versioning: reverted ${pagePath} to version ${versionId}`);\n\n  return version;\n}\n\n/**\n * Simple line-based diff between two versions.\n *\n * Returns a unified-style diff string showing added (+) and removed (-) lines.\n */\nexport async function diffVersions(\n  pagePath: string,\n  v1: string,\n  v2: string,\n  config: VersioningConfig,\n  memoryDir?: string,\n): Promise<string> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const content1 = await getVersion(pagePath, v1, config, resolvedMemoryDir);\n  const content2 = await getVersion(pagePath, v2, config, resolvedMemoryDir);\n\n  const lines1 = content1.split(\"\\n\");\n  const lines2 = content2.split(\"\\n\");\n\n  const result: string[] = [];\n  result.push(`--- version ${v1}`);\n  result.push(`+++ version ${v2}`);\n\n  // Simple LCS-based diff\n  const lcs = computeLCS(lines1, lines2);\n  let i = 0;\n  let j = 0;\n  let k = 0;\n\n  while (k < lcs.length) {\n    // Emit removed lines before the next common line\n    while (i < lines1.length && lines1[i] !== lcs[k]) {\n      result.push(`-${lines1[i]}`);\n      i++;\n    }\n    // Emit added lines before the next common line\n    while (j < lines2.length && lines2[j] !== lcs[k]) {\n      result.push(`+${lines2[j]}`);\n      j++;\n    }\n    // Common line\n    result.push(` ${lcs[k]}`);\n    i++;\n    j++;\n    k++;\n  }\n  // Remaining removed lines\n  while (i < lines1.length) {\n    result.push(`-${lines1[i]}`);\n    i++;\n  }\n  // Remaining added lines\n  while (j < lines2.length) {\n    result.push(`+${lines2[j]}`);\n    j++;\n  }\n\n  return result.join(\"\\n\");\n}\n\n// ---------------------------------------------------------------------------\n// LCS helper for diffVersions\n// ---------------------------------------------------------------------------\n\nfunction computeLCS(a: string[], b: string[]): string[] {\n  const m = a.length;\n  const n = b.length;\n  // Build DP table\n  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(n + 1).fill(0));\n  for (let i = 1; i <= m; i++) {\n    for (let j = 1; j <= n; j++) {\n      if (a[i - 1] === b[j - 1]) {\n        dp[i][j] = dp[i - 1][j - 1] + 1;\n      } else {\n        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);\n      }\n    }\n  }\n  // Backtrack to build LCS\n  const result: string[] = [];\n  let i = m;\n  let j = n;\n  while (i > 0 && j > 0) {\n    if (a[i - 1] === b[j - 1]) {\n      result.unshift(a[i - 1]);\n      i--;\n      j--;\n    } else if (dp[i - 1][j] > dp[i][j - 1]) {\n      i--;\n    } else {\n      j--;\n    }\n  }\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Path helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Legacy fallback: given an absolute page path, heuristically resolve the\n * memory directory by walking up past known subdirectory names.\n *\n * Callers should always pass an explicit `memoryDir` instead of relying on\n * this heuristic.  It is retained only for backward compatibility when the\n * optional `memoryDir` parameter is omitted.\n */\nfunction resolveMemoryDir(pagePath: string): string {\n  // Derive the recall category dirs from ALL_CATEGORY_DIRS (single source of\n  // truth) so newly-routed categories (decisions/, preferences/, ...) are\n  // recognized when walking up to the memory root (#1546); the non-category\n  // subdirs are listed explicitly.\n  const knownSubdirs = new Set<string>([\n    ...ALL_CATEGORY_DIRS,\n    \"entities\",\n    \"state\",\n    \"artifacts\",\n    \"profiles\",\n  ]);\n\n  let dir = path.dirname(pagePath);\n  // Walk up past date directories (YYYY-MM-DD) and known subdirs\n  for (let depth = 0; depth < 5; depth++) {\n    const base = path.basename(dir);\n    if (knownSubdirs.has(base) || /^\\d{4}-\\d{2}-\\d{2}$/.test(base)) {\n      dir = path.dirname(dir);\n    } else {\n      break;\n    }\n  }\n  return dir;\n}\n\n/**\n * Compute relative path of a page within its memory directory.\n */\nfunction relPath(pagePath: string, memoryDir: string): string {\n  return path.relative(memoryDir, pagePath);\n}\n"],"mappings":"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","names":["i","j"]}

package/dist/{chunk-3CE77VAP.js → chunk-A4JMGKCD.js}

@@ -1,6 +1,6 @@
 import {
   createVersion
-} from "./chunk-DLVPUX7U.js";
+} from "./chunk-7YKVM5H3.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-IJ7HK452.js";
@@ -10,8 +10,9 @@ import {
   classifyEntityRefWritePath,
   readEntityRefFromFrontmatter,
   repairContentAfterJournalMove,
-  requestEntityCanonicalIdReconcile
-} from "./chunk-4J7G5SY4.js";
+  requestEntityCanonicalIdReconcile,
+  withRawEntityPageMutation
+} from "./chunk-NZBZ7IS2.js";
 import {
   parseExportBundle
 } from "./chunk-WEHSQBFR.js";
@@ -160,82 +161,94 @@ async function importCapsule(opts) {
     (a, b) => a.path.localeCompare(b.path)
   );
   let reconcileNeeded = false;
-  for (const rec of sortedRecords) {
-    const targetRel = computeTargetPath(rec.path, mode, capsule.id);
-    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
-    const exists = await fileExistsAt(targetAbs);
-    if ((mode === "skip" || mode === "fork") && exists) {
-      skipped.push({ path: rec.path, reason: "exists" });
-      continue;
-    }
-    let snapshotted = false;
-    if (mode === "overwrite" && exists) {
-      if (opts.versioning && opts.versioning.enabled) {
-        const prior = await readFile(targetAbs, "utf-8").catch(() => "");
-        await createVersion(
-          targetAbs,
-          prior,
-          "manual",
-          opts.versioning,
-          opts.log,
-          `capsule-import: ${capsule.id}`,
-          rootReal
-        );
-        snapshotted = true;
+  const applyRecords = async () => {
+    for (const rec of sortedRecords) {
+      const targetRel = computeTargetPath(rec.path, mode, capsule.id);
+      const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
+      const exists = await fileExistsAt(targetAbs);
+      if ((mode === "skip" || mode === "fork") && exists) {
+        skipped.push({ path: rec.path, reason: "exists" });
+        continue;
       }
-    }
-    let contentToWrite = rec.content;
-    let rewroteId = false;
-    if (mode === "fork") {
-      const forked = rewriteFrontmatterIdForFork(contentToWrite, capsule.id, opts.now);
-      contentToWrite = forked.content;
-      rewroteId = forked.rewrote;
-    }
-    await mkdir(path.dirname(targetAbs), { recursive: true });
-    const targetKind = classifyEntityRefWritePath(rootReal, targetAbs);
-    const rawRef = targetKind === "memory" ? readEntityRefFromFrontmatter(contentToWrite) : null;
-    if (targetKind === "memory" && rawRef !== null && capsuleEntityIds.has(rawRef)) {
-      await writeFile(targetAbs, contentToWrite, "utf-8");
-      reconcileNeeded = true;
-    } else if (targetKind === "memory") {
-      const idsAtWrite = historicalIdCache.get(journalStateDir);
-      const rawRecord = contentToWrite;
-      contentToWrite = canonicalizeEntityRefFrontmatter(rawRecord, idsAtWrite);
-      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(() => void 0);
-        } else {
-          await writeFile(targetAbs, originalBytes, "utf-8").catch(() => void 0);
+      let snapshotted = false;
+      if (mode === "overwrite" && exists) {
+        if (opts.versioning && opts.versioning.enabled) {
+          const prior = await readFile(targetAbs, "utf-8").catch(() => "");
+          await createVersion(
+            targetAbs,
+            prior,
+            "manual",
+            opts.versioning,
+            opts.log,
+            `capsule-import: ${capsule.id}`,
+            rootReal
+          );
+          snapshotted = true;
         }
-        throw err;
       }
-    } else {
-      await writeFile(targetAbs, contentToWrite, "utf-8");
-      if (targetKind === "entity") {
+      let contentToWrite = rec.content;
+      let rewroteId = false;
+      if (mode === "fork") {
+        const forked = rewriteFrontmatterIdForFork(contentToWrite, capsule.id, opts.now);
+        contentToWrite = forked.content;
+        rewroteId = forked.rewrote;
+      }
+      await mkdir(path.dirname(targetAbs), { recursive: true });
+      const targetKind = classifyEntityRefWritePath(rootReal, targetAbs);
+      const rawRef = targetKind === "memory" ? readEntityRefFromFrontmatter(contentToWrite) : null;
+      if (targetKind === "memory" && rawRef !== null && capsuleEntityIds.has(rawRef)) {
+        await writeFile(targetAbs, contentToWrite, "utf-8");
         reconcileNeeded = true;
+      } else if (targetKind === "memory") {
+        const idsAtWrite = historicalIdCache.get(journalStateDir);
+        const rawRecord = contentToWrite;
+        contentToWrite = canonicalizeEntityRefFrontmatter(rawRecord, idsAtWrite);
+        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(() => void 0);
+          } else {
+            await writeFile(targetAbs, originalBytes, "utf-8").catch(() => void 0);
+          }
+          throw err;
+        }
+      } else {
+        await writeFile(targetAbs, contentToWrite, "utf-8");
+        if (targetKind === "entity") {
+          reconcileNeeded = true;
+        }
       }
+      bumpMemoryCorpusVersionForDir(rootReal);
+      imported.push({
+        sourcePath: rec.path,
+        targetPath: targetRel,
+        snapshotted,
+        rewroteId
+      });
     }
-    bumpMemoryCorpusVersionForDir(rootReal);
-    imported.push({
-      sourcePath: rec.path,
-      targetPath: targetRel,
-      snapshotted,
-      rewroteId
-    });
-  }
-  if (reconcileNeeded) {
-    await requestEntityCanonicalIdReconcile(journalStateDir);
+    if (reconcileNeeded) {
+      await requestEntityCanonicalIdReconcile(journalStateDir);
+    }
+  };
+  const firstEntityId = capsuleEntityIds.values().next().value;
+  if (firstEntityId === void 0) {
+    await applyRecords();
+  } else {
+    await withRawEntityPageMutation(
+      rootReal,
+      path.join(rootReal, "entities", `${firstEntityId}.md`),
+      applyRecords
+    );
   }
   skipped.sort((a, b) => a.path.localeCompare(b.path));
   return { imported, skipped, manifest };
@@ -281,4 +294,4 @@ function mintForkId(capsuleId, originalId, now) {
 export {
   importCapsule
 };
-//# sourceMappingURL=chunk-3CE77VAP.js.map
+//# sourceMappingURL=chunk-A4JMGKCD.js.map

package/dist/chunk-A4JMGKCD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/capsule-import.ts"],"sourcesContent":["import { lstat, mkdir, readFile, realpath, stat, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { gunzipSync } from \"node:zlib\";\nimport { bumpMemoryCorpusVersionForDir } from \"../memory-corpus-version.js\";\nimport {\n  HistoricalEntityCanonicalIdCache,\n  readEntityRefFromFrontmatter,\n  canonicalizeEntityRefFrontmatter,\n  classifyEntityRefWritePath,\n  repairContentAfterJournalMove,\n  requestEntityCanonicalIdReconcile,\n} from \"../storage/entity-canonical-id-references.js\";\nimport { withRawEntityPageMutation } from \"../storage/entity-canonical-id-lock.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\";\nimport { isEncryptedCapsuleFile, decryptCapsuleFileInMemory } from \"./capsule-crypto.js\";\n\n/**\n * Conflict-resolution mode for {@link importCapsule}. Inverse of the\n * `mode` selector in PR 4/6's CLI surface.\n *\n *  - `\"skip\"` (default) — when a target file already exists at the same\n *    relative path, leave it untouched. The corresponding record is reported\n *    via {@link ImportCapsuleResult.skipped}.\n *  - `\"overwrite\"` — when a target file exists, snapshot the prior content\n *    via {@link createVersion} (gotcha #54: write-before-delete; gotcha #25:\n *    don't destroy old state until new state is confirmed), then write the\n *    incoming content. The snapshot's `note` includes the source capsule id.\n *  - `\"fork\"` — never overwrite. Every record is rebased under\n *    `forks/<capsule-id>/<original-path>` and any YAML-frontmatter `id:`\n *    field is rewritten to a new fork-scoped value. The original tree is\n *    not touched.\n *\n * The mode is selected once per call and applied uniformly to every record\n * in the bundle. Mixed-mode imports are not supported by design — that\n * would let a single corrupted manifest silently land partial state.\n */\nexport type ImportCapsuleMode = \"skip\" | \"overwrite\" | \"fork\";\n\n/**\n * Options accepted by {@link importCapsule}.\n *\n * `archivePath` — absolute or cwd-relative path to a `.capsule.json.gz`\n * archive produced by `exportCapsule`. The archive must contain a V2\n * bundle (`schemaVersion: 2`); V1 archives are rejected.\n *\n * `root` — absolute or cwd-relative path to the memory directory that\n * will receive the records. Must be an existing directory.\n *\n * `mode` — see {@link ImportCapsuleMode}. Defaults to `\"skip\"`.\n *\n * `versioning` — optional page-versioning config used by `mode: \"overwrite\"`\n * to snapshot prior content before replacing it. Snapshots are skipped when\n * not provided or when `enabled === false`. Tests pass an enabled config\n * to assert snapshot creation; production callers thread the\n * orchestrator's resolved versioning config.\n *\n * `log` — optional logger forwarded to {@link createVersion}.\n *\n * `now` — optional clock override (ms epoch) used to derive deterministic\n * fork ids in tests. Production callers omit this.\n */\nexport interface ImportCapsuleOptions {\n  archivePath: string;\n  root: string;\n  mode?: ImportCapsuleMode;\n  versioning?: VersioningConfig;\n  log?: VersioningLogger;\n  now?: number;\n  /**\n   * Memory directory whose secure-store keyring is used when the archive is\n   * encrypted. Required when `archivePath` ends with `.enc` or when the file\n   * starts with the REMNIC-ENC magic header. If `memoryDir` is omitted and the\n   * archive turns out to be encrypted, `importCapsule` throws a clear error\n   * rather than silently failing.\n   *\n   * When provided and the archive is NOT encrypted, the value is ignored.\n   */\n  memoryDir?: string;\n  /**\n   * Original secure-store passphrase for encrypted format-v2 archives. When\n   * supplied, the importer derives the archive key from the embedded KDF\n   * header, enabling restore without the source machine's unlocked keyring.\n   */\n  passphrase?: string;\n}\n\nexport interface ImportCapsuleSkippedRecord {\n  /** Original record path (capsule-relative, posix). */\n  path: string;\n  /**\n   * Why this record was not written.\n   *\n   * `\"exists\"` — the target path already existed and the mode was `\"skip\"`,\n   * OR the computed fork path already existed in fork mode.\n   *\n   * `\"checksum_mismatch\"` is intentionally absent: a checksum failure aborts\n   * the import entirely (fail-closed) rather than skipping the offending\n   * record, so no `ImportCapsuleSkippedRecord` is ever produced for it.\n   */\n  reason: \"exists\";\n}\n\nexport interface ImportCapsuleImportedRecord {\n  /** Capsule-relative posix path the record carried. */\n  sourcePath: string;\n  /** Memory-dir-relative posix path the file was written to. */\n  targetPath: string;\n  /** Whether a prior version snapshot was taken (overwrite-mode only). */\n  snapshotted: boolean;\n  /** Whether the frontmatter `id:` field was rewritten (fork-mode only). */\n  rewroteId: boolean;\n}\n\nexport interface ImportCapsuleResult {\n  /** Records that landed on disk. */\n  imported: ImportCapsuleImportedRecord[];\n  /** Records that were not written. */\n  skipped: ImportCapsuleSkippedRecord[];\n  /** The manifest decoded from the archive. */\n  manifest: ExportManifestV2;\n}\n\n/**\n * Pure async function that imports a capsule archive into a memory\n * directory. Inverse of {@link import(\"./capsule-export.js\").exportCapsule}.\n *\n * Sequence:\n *   1. Read + gunzip + JSON.parse the archive.\n *   2. Validate the bundle through `parseExportBundle` (V1 rejected).\n *   3. Verify each record's content sha256 against the manifest entry.\n *      Any mismatch aborts the import BEFORE any file is written —\n *      partial-write recovery would require a full rollback we cannot\n *      offer cheaply, so we fail closed (gotcha #25).\n *   4. Apply the selected {@link ImportCapsuleMode} to every record.\n *\n * Determinism guarantees:\n *  - Imported records are returned sorted by `sourcePath`.\n *  - Skipped records are returned sorted by `path`.\n *  - Fork-mode rebases under a stable `forks/<capsule-id>/` prefix so\n *    repeated fork imports of the same capsule shape land in predictable\n *    locations (subsequent fork imports still skip-on-exist because the\n *    target tree is computed from the source path).\n */\nexport async function importCapsule(\n  opts: ImportCapsuleOptions,\n): Promise<ImportCapsuleResult> {\n  const archiveAbs = path.resolve(opts.archivePath);\n  const rootAbs = path.resolve(opts.root);\n  await assertIsDirectoryNotSymlink(rootAbs, \"importCapsule\", \"root\");\n\n  const mode: ImportCapsuleMode = opts.mode ?? \"skip\";\n  // Reject unknown mode values up-front (rule 51). TypeScript callers get a\n  // compile-time check via the union type; JS/CLI callers get a runtime error\n  // here before any write begins — not a silent destructive fallback.\n  if (mode !== \"skip\" && mode !== \"overwrite\" && mode !== \"fork\") {\n    throw new Error(\n      `importCapsule: unknown mode ${JSON.stringify(mode)}; expected \"skip\", \"overwrite\", or \"fork\"`,\n    );\n  }\n\n  // Auto-detect encrypted archives. If the file ends with `.enc` or starts\n  // with the REMNIC-ENC magic header, decrypt it first before gunzip+parse.\n  // Rule 48: default is \"not encrypted\"; we only attempt decryption when the\n  // header is definitively present, never on ambiguous content.\n  const encrypted = await isEncryptedCapsuleFile(archiveAbs);\n  let raw: Buffer;\n  if (encrypted) {\n    if (!opts.memoryDir && !opts.passphrase) {\n      throw new Error(\n        `importCapsule: archive is encrypted but 'memoryDir' was not provided. ` +\n          `Pass the memory directory so the secure-store key can be retrieved, ` +\n          `provide the original passphrase for a format-v2 archive restore, ` +\n          `or run \\`remnic secure-store unlock\\` before importing.`,\n      );\n    }\n    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir, {\n      passphrase: opts.passphrase,\n    });\n  } else {\n    raw = await readFile(archiveAbs);\n  }\n  const json = gunzipSync(raw).toString(\"utf-8\");\n  let parsedJson: unknown;\n  try {\n    parsedJson = JSON.parse(json);\n  } catch (cause) {\n    throw new Error(\n      `importCapsule: 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    // PR 1/6 ships a V1 reader; capsule import is V2-only by design. A V1\n    // bundle does not carry a capsule block, so fork-mode (which depends on\n    // `capsule.id` for the rebase prefix) cannot work. Reject up-front per\n    // gotcha #51 instead of silently routing to a different code path.\n    throw new Error(\n      \"importCapsule: archive is V1; only V2 capsule archives are supported\",\n    );\n  }\n  const bundle = parsed.bundle as { manifest: ExportManifestV2; records: ExportMemoryRecordV1[] };\n  const manifest = bundle.manifest;\n  const capsule = manifest.capsule;\n\n  // Build a path → manifest-entry index for O(1) checksum lookup. The\n  // manifest is the source of truth; records-without-manifest-entries and\n  // manifest-entries-without-records are both treated as corruption.\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(\n      \"importCapsule: 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        `importCapsule: bundle contains duplicate record path: ${rec.path}`,\n      );\n    }\n    recordPaths.add(rec.path);\n  }\n\n  // Phase 1: verify every record matches its manifest entry AND validate all\n  // target paths before any filesystem mutation.  We do both in a single pass\n  // so a corrupted or malicious archive cannot leave the memory dir partially\n  // written (fail-closed per gotcha #25).\n  //\n  // The real root is resolved once via realpath so the subsequent per-record\n  // inside-root checks are symlink-aware: a record path like `facts/a.md`\n  // cannot write outside the intended sandbox via a symlinked subdirectory\n  // (Codex P1 feedback).  If realpath fails (root does not exist) the earlier\n  // assertIsDirectoryNotSymlink call already threw, so this should always succeed.\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  // normalize 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 try to write the same inode — the second\n  // would silently overwrite the first.  We reject the import up-front before\n  // any write (Codex P2 thread on PR #741, line 283).\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        `importCapsule: 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        `importCapsule: archive checksum mismatch for ${rec.path}: ` +\n          `expected sha256=${entry.sha256} bytes=${entry.bytes}, ` +\n          `got sha256=${sha256} bytes=${bytes}`,\n      );\n    }\n\n    // Source path validation: reject any record whose posix source path\n    // contains a `..` segment, an absolute prefix, or any component that would\n    // let fork-mode bypass its isolation invariant.  This check runs before\n    // `computeTargetPath` so that fork mode's `forks/<id>/` rebase cannot be\n    // bypassed by a path like `../../profile.md` (which `path.join` would\n    // silently collapse, landing the file inside root but outside the fork\n    // prefix — Cursor medium thread #741).  Rejecting `..` up-front is simpler\n    // and more robust than normalising after the fact.\n    //\n    // Extended guard (Codex P1 #741 round 5): also reject paths containing\n    // backslash separators (`\\`), which are Windows path separators. On Windows\n    // a path like `..\\\\escape.md` or `subdir\\\\..\\\\..\\\\escape.md` would resolve\n    // to a parent traversal but would bypass a purely posix-split check.\n    // Additionally, after posix-normalizing the path we re-check for a leading\n    // `..` or `/` — this catches edge-cases such as `subdir/../..` where the\n    // individual split segments are not `..` but the normalized result is.\n    if (rec.path.includes(\"\\\\\")) {\n      throw new Error(\n        `importCapsule: 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        `importCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Path-traversal validation (moved here from phase 2 per Cursor feedback:\n    // the traversal check must run before ANY write so a malicious archive\n    // with an escaping path that sorts last cannot land partial writes).\n    //\n    // We build targetAbs relative to the real-resolved root (rootReal) so\n    // that the inside-root check is symlink-aware: if `rootReal !== rootAbs`\n    // (the import root is itself behind a symlink), we still compare against\n    // the canonical path (Codex P1).\n    const targetRel = computeTargetPath(rec.path, mode, capsule.id);\n    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));\n    if (!isPathInsideRoot(rootReal, targetAbs)) {\n      throw new Error(\n        `importCapsule: record path escapes target root: ${rec.path}`,\n      );\n    }\n\n    // Symlink-aware containment check (Cursor thread #741 line 247/264).\n    // The lexical check above handles `..`-traversal but cannot detect\n    // symlinked subdirectories that point outside the root. We resolve the\n    // nearest existing ancestor of the target via realpath to catch symlinks\n    // anywhere in the path components. If any resolved prefix escapes rootReal,\n    // the import is rejected before any write. This applies to ALL modes,\n    // including fork mode whose rebase prefix may itself traverse a symlink.\n    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, \"importCapsule\");\n\n    // Target-file symlink check (Codex P1 #741 round 4, line 260).\n    // `assertRealpathInsideRoot` resolves the nearest existing *ancestor* to\n    // catch symlinked parent directories, but if the TARGET FILE itself already\n    // exists and is a symlink, that check passes (the parent is real) while the\n    // write would silently follow the symlink to a path outside root.  We\n    // therefore lstat the target directly: if it exists and is a symlink we\n    // reject the record up-front.  For new files the parent-canonicalization\n    // performed above is sufficient; no realpath of a non-existent file is\n    // needed.\n    const targetLstat = await lstat(targetAbs).catch(() => null);\n    if (targetLstat !== null && targetLstat.isSymbolicLink()) {\n      throw new Error(\n        `importCapsule: record target is a symlink and cannot be written to safely: ${rec.path}`,\n      );\n    }\n\n    // Duplicate normalized target path detection (Codex P2 #741, line 283).\n    // `path.join` already normalises `.` segments (e.g. `subdir/./file.md` →\n    // `subdir/file.md`).  On case-insensitive filesystems (macOS default,\n    // Windows), two paths that differ only in case would resolve to the same\n    // inode.  We fold the dedup key to lowercase so that `subdir/File.md` and\n    // `subdir/file.md` are detected as duplicates before any write occurs.\n    // This is intentionally unconditional: the cost of an extra `.toLowerCase()`\n    // on case-sensitive filesystems is negligible, and a defensive lowercase\n    // is far simpler than probing filesystem case-sensitivity at runtime.\n    const dedupKey = targetAbs.toLowerCase();\n    const firstSourcePath = seenTargetPaths.get(dedupKey);\n    if (firstSourcePath !== undefined) {\n      throw new Error(\n        `importCapsule: manifest contains two entries that resolve to the same target path: ` +\n          `\"${firstSourcePath}\" and \"${rec.path}\" both map to \"${targetRel}\"`,\n      );\n    }\n    seenTargetPaths.set(dedupKey, rec.path);\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        `importCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`,\n      );\n    }\n  }\n\n  // Phase 2: apply the mode. All records were validated in phase 1; we now\n  // write to disk. Per-record errors propagate; each individual write is\n  // atomic (mkdir + writeFile pair).\n  const imported: ImportCapsuleImportedRecord[] = [];\n  const skipped: ImportCapsuleSkippedRecord[] = [];\n  // The target's completed migration journal is a write boundary here too\n  // (issue #2213): a capsule can carry pre-migration memories whose entityRef\n  // the target already renamed, and no recurring reconciliation pass exists\n  // to absorb a stale ref after the fact. Read through the identity-keyed\n  // cache PER RECORD so a peer migration completing mid-import is picked up\n  // for every record written after it (one lstat per record).\n  const journalStateDir = path.join(rootReal, \"state\");\n  const historicalIdCache = new HistoricalEntityCanonicalIdCache();\n  // Entity pages in THIS capsule can re-establish collisions the target's\n  // journal already resolved (Codex P1): once the next migration parks the\n  // mapping, a memory canonicalized onto the canonical claimant is\n  // permanently misattributed. Memories whose ref targets a capsule-supplied\n  // entity id import byte-faithful behind the reconcile marker instead; the\n  // migration settles the collision and rewrites references per its verdict.\n  const capsuleEntityIds = new Set(\n    bundle.records\n      .map((record) => computeTargetPath(record.path, mode, capsule.id))\n      .filter((rel) => classifyEntityRefWritePath(rootReal, path.join(rootReal, fromPosixRelPath(rel))) === \"entity\")\n      .map((rel) => path.basename(rel, \".md\")),\n  );\n\n  // Sort by source path so the imported/skipped lists are deterministic\n  // regardless of bundle order. (`exportCapsule` already sorts; we re-sort\n  // defensively in case a hand-edited archive ships records in another order.)\n  const sortedRecords = [...bundle.records].sort((a, b) =>\n    a.path.localeCompare(b.path),\n  );\n\n  // The reconcile marker is published ONCE, after every record landed\n  // (Codex P1, round 21): a per-record marker could be consumed by a peer\n  // between a legacy-preserving memory write and its colliding entity page,\n  // canonicalizing the memory onto the wrong claimant irreversibly.\n  let reconcileNeeded = false;\n  const applyRecords = async (): Promise<void> => {\n  for (const rec of sortedRecords) {\n    const targetRel = computeTargetPath(rec.path, mode, capsule.id);\n    // Use rootReal (realpath-resolved) to stay consistent with phase 1's\n    // traversal validation and avoid writing through stale symlinks.\n    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));\n\n    const exists = await fileExistsAt(targetAbs);\n\n    // Skip logic applies to both `skip` mode (explicit) and `fork` mode\n    // (Cursor medium: fork mode must also be skip-on-exist for the computed\n    // fork path, because production imports generate non-deterministic IDs —\n    // so re-importing the same capsule should not overwrite user edits in the\n    // fork tree or silently change file identities by generating new IDs).\n    if ((mode === \"skip\" || mode === \"fork\") && exists) {\n      skipped.push({ path: rec.path, reason: \"exists\" });\n      continue;\n    }\n\n    let snapshotted = false;\n    if (mode === \"overwrite\" && exists) {\n      // Gotcha #54: snapshot BEFORE overwriting. If snapshot creation fails\n      // we abort this record's import rather than silently destroying\n      // history. The page-versioning module is responsible for atomic\n      // sidecar writes; we just call it.\n      if (opts.versioning && opts.versioning.enabled) {\n        const prior = await readFile(targetAbs, \"utf-8\").catch(() => \"\");\n        await createVersion(\n          targetAbs,\n          prior,\n          \"manual\",\n          opts.versioning,\n          opts.log,\n          `capsule-import: ${capsule.id}`,\n          rootReal,\n        );\n        snapshotted = true;\n      }\n    }\n\n    let contentToWrite = rec.content;\n    let rewroteId = false;\n    if (mode === \"fork\") {\n      const forked = rewriteFrontmatterIdForFork(contentToWrite, capsule.id, opts.now);\n      contentToWrite = forked.content;\n      rewroteId = forked.rewrote;\n    }\n\n    await mkdir(path.dirname(targetAbs), { recursive: true });\n    // Resolve at the write itself (mirrors capsule-merge): a peer migration\n    // can complete during the snapshot/mkdir awaits, and capsule writes bump\n    // only the corpus version, which the migration fingerprint ignores. The\n    // post-write REPAIR re-canonicalizes and rewrites when the journal moved\n    // across the write itself (a parked mapping cannot be fixed after the\n    // fact by the reconcile pass). Only memory-tier records canonicalize;\n    // entities/ pages carry relationship TARGETS only\n    // rewriteRelationshipTargets understands, so they import byte-faithful\n    // with a reconcile marker; everything else imports losslessly.\n    const targetKind = classifyEntityRefWritePath(rootReal, targetAbs);\n    const rawRef = targetKind === \"memory\" ? readEntityRefFromFrontmatter(contentToWrite) : null;\n    if (targetKind === \"memory\" && rawRef !== null && capsuleEntityIds.has(rawRef)) {\n      // Ref targets a capsule-supplied entity page (potential collision\n      // claimant): keep the legacy bytes; the DEFERRED marker below lets the\n      // migration settle the collision and rewrite per its verdict (Codex P1).\n      await writeFile(targetAbs, contentToWrite, \"utf-8\");\n      reconcileNeeded = true;\n    } else if (targetKind === \"memory\") {\n      const idsAtWrite = historicalIdCache.get(journalStateDir);\n      const rawRecord = contentToWrite;\n      contentToWrite = canonicalizeEntityRefFrontmatter(rawRecord, idsAtWrite);\n      // Snapshot the pre-write bytes: a repair failure after the write must\n      // restore them (or remove a newly created target), or the import\n      // reports failure while an overwrite already destroyed the prior state\n      // and the skipped corpus bump leaves warm caches stale (AGENTS.md §14).\n      const originalBytes = await readFile(targetAbs, \"utf-8\").catch(() => null);\n      await writeFile(targetAbs, contentToWrite, \"utf-8\");\n      try {\n        await repairContentAfterJournalMove({\n          stateDir: journalStateDir,\n          cache: historicalIdCache,\n          idsAtWrite,\n          rawContent: rawRecord,\n          lastWritten: contentToWrite,\n          rewrite: (content) => writeFile(targetAbs, content, \"utf-8\"),\n        });\n      } catch (err) {\n        if (originalBytes === null) {\n          await unlink(targetAbs).catch(() => undefined);\n        } else {\n          await writeFile(targetAbs, originalBytes, \"utf-8\").catch(() => undefined);\n        }\n        throw err;\n      }\n    } else {\n      await writeFile(targetAbs, contentToWrite, \"utf-8\");\n      if (targetKind === \"entity\") {\n        reconcileNeeded = true;\n      }\n    }\n    // Bump the corpus sentinel per write (Cursor Medium, #1902): a concurrent\n    // readAllMemories during the import must rescan and see records already on\n    // disk, never the pre-import corpus, mid-batch.\n    bumpMemoryCorpusVersionForDir(rootReal);\n    imported.push({\n      sourcePath: rec.path,\n      targetPath: targetRel,\n      snapshotted,\n      rewroteId,\n    });\n  }\n\n  // Every record — including every collision claimant entity page — is on\n  // disk; NOW the reconcile pass can settle collisions safely.\n  if (reconcileNeeded) {\n    await requestEntityCanonicalIdReconcile(journalStateDir);\n  }\n  };\n  const firstEntityId = capsuleEntityIds.values().next().value;\n  if (firstEntityId === undefined) {\n    await applyRecords();\n  } else {\n    await withRawEntityPageMutation(\n      rootReal,\n      path.join(rootReal, \"entities\", `${firstEntityId}.md`),\n      applyRecords,\n    );\n  }\n\n  // Sort skipped for stable output (see comment above).\n  skipped.sort((a, b) => a.path.localeCompare(b.path));\n\n  // Per-record corpus bumps happen inside the loop above (Cursor Medium,\n  // #1902); no after-batch bump needed here.\n\n  return { imported, skipped, manifest };\n}\n\n// ---------------------------------------------------------------------------\n// Path helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Compute the destination relative path for a record under the chosen\n * mode.\n *\n *  - `skip` / `overwrite` — identity: the record's posix path is used as-is.\n *  - `fork` — rebased under `forks/<capsule-id>/<original-path>` so the\n *    original tree is never modified.\n */\nfunction computeTargetPath(\n  sourcePosix: string,\n  mode: ImportCapsuleMode,\n  capsuleId: string,\n): string {\n  if (mode === \"fork\") return `forks/${capsuleId}/${sourcePosix}`;\n  return sourcePosix;\n}\n\nasync function fileExistsAt(absPath: string): Promise<boolean> {\n  const st = await stat(absPath).catch(() => null);\n  return st !== null && st.isFile();\n}\n\n// ---------------------------------------------------------------------------\n// Fork-mode id rewriting\n// ---------------------------------------------------------------------------\n\n/**\n * Rewrite a YAML-frontmatter `id:` field to a fork-scoped value.\n *\n * Strategy: we deliberately do NOT parse the entire YAML — memory files\n * use a deterministic top-of-file frontmatter delimited by `---` lines,\n * and the orchestrator's `parseFrontmatter` reads `id` as a top-level\n * key with a single-line scalar value. We mirror that contract:\n *\n *   - Detect a leading `---\\n` … `\\n---` block at the top of the file.\n *   - Within that block, locate the first `id:` line that is not nested\n *     under another key (cheap heuristic: line starts at column 0).\n *   - Replace its value with a new fork-id derived from `capsuleId` and\n *     a short random suffix (or {@link opts.now} when provided for tests).\n *\n * Files without a frontmatter block, or without an `id:` key inside one,\n * are returned unchanged with `rewrote: false`. This keeps non-memory\n * artifacts (READMEs, transcripts) byte-identical to the source.\n */\nfunction rewriteFrontmatterIdForFork(\n  content: string,\n  capsuleId: string,\n  now: number | undefined,\n): { content: string; rewrote: boolean } {\n  // Detect the dominant line ending in the file so we can preserve it when\n  // rebuilding the frontmatter delimiters. Splitting/joining on `\\n` silently\n  // drops `\\r` from CRLF files, changing the byte content (Cursor thread #741\n  // line 467). We detect the ending of the very first line (the opening `---`)\n  // and use that as the canonical separator for the reconstructed delimiters.\n  // All three cases are covered: CRLF (\\r\\n), LF (\\n), and bare CR (\\r).\n  const crlfMatch = /^---(\\r\\n|\\r|\\n)/.exec(content);\n  // Fall back to LF if the file starts with `---` but has no newline (EOF).\n  const eol = crlfMatch ? crlfMatch[1] : \"\\n\";\n\n  // Frontmatter block detection: `---` on its own line at the very start,\n  // followed by content, followed by `---` on its own line. The closing\n  // delimiter must be at column 0. We capture the trailing terminator\n  // (`\\r?\\n` or end-of-string) as a separate group so we can re-emit it\n  // verbatim, preserving CRLF/LF/EOF shape from the original file.\n  const fmMatch = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---(\\r?\\n|$)/.exec(content);\n  if (!fmMatch) return { content, rewrote: false };\n  const fmBody = fmMatch[1];\n  const fmTrailer = fmMatch[2];\n  const fmStart = fmMatch.index;\n  const fmEnd = fmStart + fmMatch[0].length;\n\n  // Find a top-level `id:` line. Top-level means the line begins at\n  // column 0 inside the frontmatter body (no leading whitespace) and the\n  // key is exactly `id`. We deliberately accept `id:` and `id : ` shapes\n  // but reject `nested_id:` to avoid touching unrelated keys.\n  const idLineRe = /^id:[ \\t]*([^\\r\\n]*)$/m;\n  const idMatch = idLineRe.exec(fmBody);\n  if (!idMatch) return { content, rewrote: false };\n\n  const newId = mintForkId(capsuleId, idMatch[1]?.trim() ?? \"\", now);\n  const replacedBody = fmBody.replace(idLineRe, `id: ${newId}`);\n  // Reconstruct the file: original prefix (always empty here, fmStart === 0\n  // by the `^` anchor) + frontmatter delimiters around the rewritten body.\n  // Use the detected `eol` for the opening/closing `---` lines so that CRLF\n  // files remain CRLF and LF files remain LF, preserving byte-content fidelity\n  // (Cursor thread #741 line 467).  The captured `fmTrailer` (the newline\n  // immediately after the closing `---`, or end-of-string) is re-emitted\n  // verbatim so the byte immediately after the closing fence is unchanged.\n  const prefix = content.slice(0, fmStart);\n  const tail = content.slice(fmEnd);\n  const rebuilt = `${prefix}---${eol}${replacedBody}${eol}---${fmTrailer}${tail}`;\n  return { content: rebuilt, rewrote: true };\n}\n\n/**\n * Derive a deterministic-when-`now`-is-set fork id from the capsule id and\n * the original record id. Production callers omit `now` and get a UUID\n * suffix; tests pass `now` for byte-stable assertions.\n */\nfunction mintForkId(capsuleId: string, originalId: string, now: number | undefined): string {\n  const base = originalId.length > 0 ? originalId : \"fork\";\n  if (now === undefined) {\n    const suffix = randomUUID().slice(0, 8);\n    return `${base}-fork-${capsuleId}-${suffix}`;\n  }\n  // Deterministic suffix: short hash of (capsuleId, originalId, now). Using\n  // sha256 over a sorted-key serialization (gotcha #38) so the suffix does\n  // not depend on Object.entries order.\n  const payload = JSON.stringify({ c: capsuleId, i: originalId, n: now });\n  const suffix = createHash(\"sha256\").update(payload, \"utf-8\").digest(\"hex\").slice(0, 8);\n  return `${base}-fork-${capsuleId}-${suffix}`;\n}\n\n// Note: `CapsuleBlock` is re-exported here purely so callers that want to\n// inspect the manifest block don't have to deep-import from `./types.js`.\nexport type { CapsuleBlock };\n"],"mappings":"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","names":["suffix"]}

package/dist/chunk-A5KNZSNA.js

@@ -0,0 +1,26 @@
+// src/external-wiki-mcp-tools.ts
+var EXTERNAL_WIKI_MCP_TOOLS = [
+  {
+    name: "engram.external_wiki_search",
+    description: "Search configured external compiled-wiki roots on demand. Returns ranked snippets with root-relative citations and never changes default recall.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Required topical query." },
+        limit: { type: "number", description: "Maximum hits (default 6, maximum 20)." },
+        wikiId: { type: "string", description: "Optional configured wiki id to search exclusively." },
+        maxCharsPerHit: {
+          type: "number",
+          description: "Maximum characters in each snippet (default 1000, maximum 8000)."
+        }
+      },
+      required: ["query"],
+      additionalProperties: false
+    }
+  }
+];
+
+export {
+  EXTERNAL_WIKI_MCP_TOOLS
+};
+//# sourceMappingURL=chunk-A5KNZSNA.js.map

package/dist/chunk-A5KNZSNA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/external-wiki-mcp-tools.ts"],"sourcesContent":["import type { McpTool } from \"./access-mcp.js\";\n\nexport const EXTERNAL_WIKI_MCP_TOOLS: McpTool[] = [\n  {\n    name: \"engram.external_wiki_search\",\n    description:\n      \"Search configured external compiled-wiki roots on demand. Returns ranked snippets with root-relative citations and never changes default recall.\",\n    inputSchema: {\n      type: \"object\",\n      properties: {\n        query: { type: \"string\", description: \"Required topical query.\" },\n        limit: { type: \"number\", description: \"Maximum hits (default 6, maximum 20).\" },\n        wikiId: { type: \"string\", description: \"Optional configured wiki id to search exclusively.\" },\n        maxCharsPerHit: {\n          type: \"number\",\n          description: \"Maximum characters in each snippet (default 1000, maximum 8000).\",\n        },\n      },\n      required: [\"query\"],\n      additionalProperties: false,\n    },\n  },\n];\n"],"mappings":";AAEO,IAAM,0BAAqC;AAAA,EAChD;AAAA,IACE,MAAM;AAAA,IACN,aACE;AAAA,IACF,aAAa;AAAA,MACX,MAAM;AAAA,MACN,YAAY;AAAA,QACV,OAAO,EAAE,MAAM,UAAU,aAAa,0BAA0B;AAAA,QAChE,OAAO,EAAE,MAAM,UAAU,aAAa,wCAAwC;AAAA,QAC9E,QAAQ,EAAE,MAAM,UAAU,aAAa,qDAAqD;AAAA,QAC5F,gBAAgB;AAAA,UACd,MAAM;AAAA,UACN,aAAa;AAAA,QACf;AAAA,MACF;AAAA,MACA,UAAU,CAAC,OAAO;AAAA,MAClB,sBAAsB;AAAA,IACxB;AAAA,EACF;AACF;","names":[]}