@remnic/core 9.69.22 → 9.69.24

package/dist/chunk-JPKK466T.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, randomUUID } from \"node:crypto\";\nimport path from \"node:path\";\nimport {\n  access,\n  appendFile,\n  mkdir,\n  readFile,\n  writeFile,\n  rename,\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\";\nimport { withHeldFileLock, type HeldFileLockController } from \"./utils/serialize-mutations.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   * True while the snapshot is STAGED by a guarded write that has not yet\n   * committed (issue #2330 round N+15 B). Pruning counts — and removes —\n   * only committed snapshots: a pending entry belongs to a writer whose\n   * compare-and-swap may still fail, so trading it for an older rollback\n   * point would leave history short of the cap once that writer aborts\n   * (removeVersion). The staging writer clears the flag when its write\n   * commits (pruneVersions `committedVersionId`) or drops the entry; a\n   * finalization that FAILS after the commit records the id via\n   * recordStrandedCommit, and the next pruneVersions clears it (round\n   * N+22).\n   */\n  pending?: boolean;\n}\n\n/**\n * Snapshot triggers. The runtime allow-list in `readManifest` is derived from\n * this array, so adding a trigger cannot leave a written manifest unreadable.\n */\nexport const VERSION_TRIGGERS = Object.freeze([\n  \"write\",\n  \"consolidation\",\n  \"revert\",\n  \"manual\",\n  \"semantic-merge\",\n] as const);\nexport type VersionTrigger = (typeof VERSION_TRIGGERS)[number];\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// Cross-process manifest lock (issue #2330 round N+16 B)\n// ---------------------------------------------------------------------------\n\n// withPageLock serializes manifest mutations only within ONE Remnic process.\n// Two processes sharing a memory directory could both read a manifest,\n// compute the SAME next version id, and stage colliding snapshots — and a\n// merge whose content CAS then lost called removeVersion on that shared id,\n// deleting the WINNER's committed rollback point (and concurrent\n// non-atomic manifest writes tore the JSON outright). The mutation now also\n// holds a cross-process advisory lock — the established withHeldFileLock\n// primitive, as a sibling `<manifest>.lock` file (the same `<data>.lock`\n// placement tombstones.jsonl and fact-hashes.txt use). A lock that cannot be\n// taken within the bounded wait FAILS the mutation: staging falls back to\n// the create path, and removal/prune callers already treat a throw as\n// non-fatal — no caller ever proceeds unsynchronized into the collision the\n// lock exists to prevent.\nconst MANIFEST_LOCK_STALE_MS = 30_000;\nconst MANIFEST_LOCK_MAX_WAIT_MS = 10_000;\n\n/**\n * A manifest mutation lost its advisory lock mid-section — a peer stale-broke\n * and replaced it, and the section must abort rather than publish over the\n * peer's committed mutation.\n */\nclass ManifestLockLostError extends Error {\n  constructor(mPath: string) {\n    super(\n      `page-versioning: manifest lock for ${mPath} was lost mid-section — a peer stale-broke it; aborting so the peer's mutation survives`,\n    );\n    this.name = \"ManifestLockLostError\";\n  }\n}\n\n/**\n * Revalidate lock ownership immediately before a destructive write (final\n * round B). The lock's mtime heartbeat is a TIMER — it cannot fire while the\n * process is paused past the stale window (CPU-bound section, suspended\n * machine), so a peer can break the lock and commit its own newer mutation\n * while THIS section still believes it holds it. Every mutation calls this\n * immediately before each destructive write (snapshot writeFile, manifest\n * rename, snapshot unlink) and aborts on loss — the same pattern the graph\n * JSONL lock adopted (GraphWriteLockSection / assertGraphLockHeld). A held\n * result also re-stamps the mtime, so the bounded write that follows cannot\n * itself be judged stale mid-write.\n */\nasync function assertManifestLockHeld(\n  mPath: string,\n  lock: HeldFileLockController,\n): Promise<void> {\n  if (!(await lock.refresh())) throw new ManifestLockLostError(mPath);\n}\n\nfunction withManifestLock<T>(\n  mPath: string,\n  fn: (lock: HeldFileLockController) => Promise<T>,\n): Promise<T> {\n  return withPageLock(mPath, () =>\n    withHeldFileLock(\n      `${mPath}.lock`,\n      { staleMs: MANIFEST_LOCK_STALE_MS, maxWaitMs: MANIFEST_LOCK_MAX_WAIT_MS },\n      async (acquired, lock) => {\n        if (!acquired) {\n          throw new Error(\n            `page-versioning: could not acquire the manifest lock for ${mPath} within ${MANIFEST_LOCK_MAX_WAIT_MS}ms — another process holds it`,\n          );\n        }\n        return fn(lock);\n      },\n    ),\n  );\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        !(VERSION_TRIGGERS as readonly string[]).includes(String(version.trigger)) ||\n        (version.pending !== undefined && typeof version.pending !== \"boolean\")\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  // Final round (A): publish atomically — write the temp file, then rename\n  // it over the manifest. A crash or transient failure can no longer leave a\n  // torn or truncated manifest behind, and the publish-before-cleanup\n  // ordering in every mutation guarantees a failed publication never strands\n  // a manifest entry whose snapshot file is already gone.\n  const tmp = `${mp}.${process.pid}.${randomUUID()}.tmp`;\n  try {\n    await writeFile(tmp, JSON.stringify(history, null, 2) + \"\\n\", \"utf8\");\n    await rename(tmp, mp);\n  } catch (err) {\n    await unlink(tmp).catch(() => undefined);\n    throw err;\n  }\n}\n\n// Round N+22: stranded-commit marker. A finalization whose merge had\n// ALREADY committed can still fail (manifest lock timeout, transient I/O),\n// leaving its staged entry `pending` forever — pruneExcessVersions excludes\n// pending entries, so every such failure stranded one unprunable snapshot\n// and repeated failures grew history past maxVersionsPerPage. The failed\n// finalization appends the (known-committed) version id to this marker (a\n// sibling `<manifest>.stranded` file, one id per line); the next\n// pruneVersions for the page reconciles those ids under the manifest lock.\n// Append-only by design: a one-line O_APPEND write is atomic, and a\n// clear-side rewrite could clobber an id appended by a finalization that\n// just failed against the very lock the clear holds. Ids whose entry is gone\n// or already committed are read-side no-ops, so stale lines cost one skipped\n// lookup each and the file is bounded by finalization failures (one small\n// line each). A writer that CRASHES mid-attempt records nothing — that case\n// stays covered by the pending-exclusion itself.\nasync function readStrandedCommits(markerPath: string): Promise<string[]> {\n  try {\n    const raw = await readFile(markerPath, \"utf-8\");\n    return raw.split(\"\\n\").filter((line) => /^\\d+$/.test(line.trim()));\n  } catch {\n    return [];\n  }\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. Pass\n * `options.deferPrune` to stage the snapshot WITHOUT pruning and finalize\n * with {@link pruneVersions} once the guarded write that staged it commits —\n * a failed attempt then leaves the history untouched instead of discarding\n * the oldest rollback point (issue #2330 round N+11 C). A deferred snapshot\n * is recorded `pending` until its writer commits (round N+15 B); pruning\n * counts only committed snapshots, so no prune can trade another writer's\n * staged entry for an older rollback point.\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  options?: { deferPrune?: boolean },\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 withManifestLock(mPath, async (lock) => {\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, \"utf8\"),\n      trigger,\n      ...(note !== undefined ? { note } : {}),\n      ...(options?.deferPrune === true ? { pending: true } : {}),\n    };\n\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    // Final round (B): revalidate ownership immediately before the staged\n    // snapshot write — a peer that stale-broke the lock may have committed a\n    // mutation reusing this id, and overwriting its file would corrupt the\n    // peer's published rollback point.\n    await assertManifestLockHeld(mPath, lock);\n    await writeFile(snapshotPath, content, \"utf8\");\n\n    history.versions.push(version);\n    history.currentVersion = nextId;\n\n    // Final round (A): the prune only COMPUTES the removal here; the\n    // manifest publishes it (atomic rename), and only then are the pruned\n    // snapshot files unlinked — a publication failure leaves the manifest\n    // and the files exactly as they were, never a dangling reference.\n    // The prune is skipped when the caller deferred it until its guarded\n    // write commits (issue #2330 round N+11 C).\n    const pruned = options?.deferPrune === true\n      ? []\n      : pruneExcessVersions(history, maxVersionsPerPage);\n    await assertManifestLockHeld(mPath, lock);\n    await writeManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir), history);\n    await unlinkPublishedSnapshots(mPath, lock, dir, ext, pruned, log);\n    log.debug(`page-versioning: created version ${nextId} for ${pagePath} (trigger=${trigger})`);\n\n    return version;\n  });\n}\n\n/**\n * Compute the excess COMMITTED snapshots and drop them from `history`,\n * returning the pruned entries WITHOUT touching any file — the caller\n * publishes the manifest first and unlinks the files only afterwards\n * ({@link unlinkPublishedSnapshots}, final round A). The caller holds the\n * manifest lock.\n */\nfunction pruneExcessVersions(\n  history: VersionHistory,\n  maxVersionsPerPage: number,\n): PageVersion[] {\n  if (!(maxVersionsPerPage > 0)) return [];\n  // Round N+15 (B): count only COMMITTED snapshots. Two concurrent merges\n  // can both stage (deferPrune) before either commits; a prune that counted\n  // the other writer's pending entry would drop one more rollback point\n  // than the cap requires, and that writer's abort (removeVersion) then\n  // leaves history SHORT of the cap. Pending entries are skipped entirely —\n  // never counted, never removed. (ponytail: a writer that dies mid-attempt\n  // leaves its entry pending forever — bounded by one entry per crash;\n  // age-based expiry if crash loops ever make that matter. A finalization\n  // that fails AFTER its merge committed no longer strands its entry —\n  // pruneVersions reconciles those from the stranded-commit marker, round\n  // N+22.)\n  const excess =\n    history.versions.filter((version) => version.pending !== true).length -\n    maxVersionsPerPage;\n  if (excess <= 0) return [];\n  const toRemove = new Set<PageVersion>();\n  for (const version of history.versions) {\n    if (toRemove.size >= excess) break;\n    if (version.pending === true) continue;\n    toRemove.add(version);\n  }\n  history.versions = history.versions.filter((version) => !toRemove.has(version));\n  return [...toRemove];\n}\n\n/**\n * Best-effort removal of snapshot files whose removal the manifest has\n * ALREADY published (final round A). Ownership is revalidated first: after a\n * lock loss, a peer's fresh mutation may have reused a removed id, and\n * unlinking its file would leave the PEER's manifest with a dangling\n * reference — so a lost lock aborts the cleanup (the caller surfaces the\n * error; the already-published manifest stays consistent, and the skipped\n * files are unreferenced orphans, never dangling references).\n */\nasync function unlinkPublishedSnapshots(\n  mPath: string,\n  lock: HeldFileLockController,\n  dir: string,\n  ext: string,\n  pruned: PageVersion[],\n  log: VersioningLogger,\n): Promise<void> {\n  if (pruned.length === 0) return;\n  await assertManifestLockHeld(mPath, lock);\n  for (const old of pruned) {\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/**\n * Finalize a deferred prune: drop the oldest COMMITTED snapshots (and their\n * files) until the history is back at `config.maxVersionsPerPage`. Call only\n * after the guarded write that staged the snapshot has committed — a failed\n * attempt never calls this, so it cannot discard rollback points. Pass\n * `options.committedVersionId` to clear the staging writer's `pending` flag\n * under the SAME page lock as the prune (round N+15 B): the entry becomes\n * countable exactly when — and only when — its writer's write has committed,\n * so a concurrent still-pending writer's entry is never counted or removed.\n *\n * Round N+22: each call also reconciles entries stranded by an EARLIER\n * finalization that failed after its merge committed (see\n * {@link recordStrandedCommit}) — their `pending` flags clear here, under\n * the same lock, so a transient finalization failure cannot permanently\n * exclude a committed snapshot from the prune bound.\n */\nexport async function pruneVersions(\n  pagePath: string,\n  config: VersioningConfig,\n  log: VersioningLogger = NOOP_LOGGER,\n  memoryDir?: string,\n  options?: { committedVersionId?: string },\n): Promise<void> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const rel = relPath(pagePath, resolvedMemoryDir);\n  const mPath = manifestPath(resolvedMemoryDir, config.sidecarDir, rel);\n  await withManifestLock(mPath, async (lock) => {\n    const history = await readManifest(resolvedMemoryDir, config.sidecarDir, rel);\n    const before = history.versions.length;\n    let committedCleared = false;\n    if (options?.committedVersionId !== undefined) {\n      const staged = history.versions.find(\n        (version) =>\n          version.versionId === options.committedVersionId && version.pending === true,\n      );\n      if (staged) {\n        delete staged.pending;\n        committedCleared = true;\n      }\n    }\n    // Marker ids are known-COMMITTED by construction: only a finalization\n    // failure for an already-committed merge records one, so clearing them\n    // here can never trade away a concurrent still-pending writer's entry.\n    let strandedCleared = 0;\n    for (const id of await readStrandedCommits(`${mPath}.stranded`)) {\n      const stranded = history.versions.find(\n        (version) => version.versionId === id && version.pending === true,\n      );\n      if (stranded) {\n        delete stranded.pending;\n        strandedCleared += 1;\n      }\n    }\n    // Final round (A): compute the prune, PUBLISH the manifest (atomic\n    // rename), and only then unlink the pruned snapshot files best-effort —\n    // a publication failure leaves manifest and files mutually consistent.\n    const pruned = pruneExcessVersions(history, config.maxVersionsPerPage);\n    if (history.versions.length !== before || committedCleared || strandedCleared > 0) {\n      await assertManifestLockHeld(mPath, lock);\n      await writeManifest(resolvedMemoryDir, config.sidecarDir, rel, history);\n    }\n    await unlinkPublishedSnapshots(\n      mPath,\n      lock,\n      sidecarDir(resolvedMemoryDir, config.sidecarDir, rel),\n      path.extname(pagePath) || \".md\",\n      pruned,\n      log,\n    );\n    if (strandedCleared > 0) {\n      log.debug(\n        `page-versioning: reconciled ${strandedCleared} stranded committed snapshot(s) for ${pagePath}`,\n      );\n    }\n  });\n}\n\n/**\n * Record that the guarded write behind `versionId` COMMITTED but its\n * finalizing prune failed (round N+22) — the entry's `pending` flag could\n * not be cleared, so without this record the snapshot stayed excluded from\n * pruning forever. The next {@link pruneVersions} for the page reconciles\n * the id from the marker. Best-effort: a marker-write failure is logged and\n * never thrown (the caller is already on an error path).\n */\nexport async function recordStrandedCommit(\n  pagePath: string,\n  config: VersioningConfig,\n  versionId: string,\n  log: VersioningLogger = NOOP_LOGGER,\n  memoryDir?: string,\n): Promise<void> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const rel = relPath(pagePath, resolvedMemoryDir);\n  try {\n    await appendFile(\n      `${manifestPath(resolvedMemoryDir, config.sidecarDir, rel)}.stranded`,\n      `${versionId}\\n`,\n      \"utf-8\",\n    );\n  } catch (err) {\n    log.warn(\n      `page-versioning: could not record stranded commit ${versionId} (non-fatal): ${err instanceof Error ? err.message : String(err)}`,\n    );\n  }\n}\n\n/**\n * Remove ONE version from the manifest and delete its snapshot file.\n * Idempotent: a version already gone (or never present) is a no-op.\n *\n * Used by guarded-write callers whose staged snapshot must not survive an\n * aborted attempt (issue #2330 round N+13 B): staging itself mutates\n * history, and without this rollback repeated failed attempts grow history\n * past `maxVersionsPerPage`, so a later successful commit's prune trades\n * real rollback states for duplicate failed-attempt snapshots of a body that\n * never changed. Never call this for a version a committed write relies on.\n * `currentVersion` returns to the newest remaining snapshot (or `\"0\"` when\n * history emptied) — never to a removed id.\n */\nexport async function removeVersion(\n  pagePath: string,\n  versionId: string,\n  config: VersioningConfig,\n  log: VersioningLogger = NOOP_LOGGER,\n  memoryDir?: string,\n): Promise<void> {\n  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);\n  const rel = relPath(pagePath, resolvedMemoryDir);\n  const mPath = manifestPath(resolvedMemoryDir, config.sidecarDir, rel);\n  await withManifestLock(mPath, async (lock) => {\n    const history = await readManifest(resolvedMemoryDir, config.sidecarDir, rel);\n    const index = history.versions.findIndex((version) => version.versionId === versionId);\n    if (index === -1) return;\n    const removed = history.versions[index];\n    history.versions.splice(index, 1);\n    history.currentVersion = history.versions.length > 0\n      ? String(Math.max(...history.versions.map((version) => Number(version.versionId))))\n      : \"0\";\n    // Final round (A): PUBLISH the manifest (atomic rename) BEFORE touching\n    // the snapshot file. The old order unlinked first — a publication\n    // failure (transient I/O, full disk) then left the on-disk manifest\n    // referencing a now-missing snapshot: an unusable rollback entry that\n    // getVersion/revert fail on and prune never cleans. Publish-first means\n    // a failed publication leaves manifest AND file untouched; the unlink\n    // only runs once the removal is durably published.\n    await assertManifestLockHeld(mPath, lock);\n    await writeManifest(resolvedMemoryDir, config.sidecarDir, rel, history);\n    await unlinkPublishedSnapshots(\n      mPath,\n      lock,\n      sidecarDir(resolvedMemoryDir, config.sidecarDir, rel),\n      path.extname(pagePath) || \".md\",\n      [removed],\n      log,\n    );\n    log.debug(`page-versioning: removed version ${versionId} for ${pagePath}`);\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-JCCWJHOP.js → chunk-JYZSRNR7.js}

@@ -16,7 +16,7 @@ import {
 } from "./chunk-ULM7JCDH.js";
 import {
   resolveEvalStoreDir
-} from "./chunk-MCA2X4WH.js";
+} from "./chunk-4IHBN6WU.js";
 
 // src/eval-trajectory-store.ts
 import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
@@ -237,4 +237,4 @@ export {
   writeEvalTrajectoryReport,
   readEvalTrajectoryReport
 };
-//# sourceMappingURL=chunk-JCCWJHOP.js.map
+//# sourceMappingURL=chunk-JYZSRNR7.js.map

package/dist/{chunk-7D6HXODY.js → chunk-K7724CH2.js}

@@ -1,7 +1,7 @@
 import {
   SupportPassportCreateGrantRequestSchema,
   defineOperation
-} from "./chunk-NQFCLAYT.js";
+} from "./chunk-ICKJ52PE.js";
 import {
   SupportPassportCardCategorySchema,
   SupportPassportMemoryIdSchema,
@@ -220,4 +220,4 @@ var supportPassportGrantAskOperation = defineOperation({
     result: await ctx.service.supportPassportAskGrant(grantId, secret, question, ctx.abortSignal)
   })
 });
-//# sourceMappingURL=chunk-7D6HXODY.js.map
+//# sourceMappingURL=chunk-K7724CH2.js.map

package/dist/{chunk-X33MJFD2.js → chunk-KAXCYM66.js}

@@ -4,10 +4,10 @@ import {
 import {
   hasCodexMaterializeSentinel,
   materializeForNamespace
-} from "./chunk-ZXBTTMGZ.js";
+} from "./chunk-KEF46KL2.js";
 import {
   StorageManager
-} from "./chunk-OGTKQ5MJ.js";
+} from "./chunk-XSGUMQQQ.js";
 import {
   projectProceduresToSkills
 } from "./chunk-236PXYG7.js";
@@ -134,4 +134,4 @@ export {
   runCodexMaterialize,
   runPostConsolidationMaterialize
 };
-//# sourceMappingURL=chunk-X33MJFD2.js.map
+//# sourceMappingURL=chunk-KAXCYM66.js.map

package/dist/{chunk-7RRUHJPG.js → chunk-KB2G2I6Q.js}

@@ -3,7 +3,7 @@ import {
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-RE3H6Y2X.js";
+} from "./chunk-ZIW5JVRM.js";
 import {
   ConsolidationResultSchema,
   DaySummaryResultSchema,
@@ -74,7 +74,7 @@ import {
 } from "./chunk-IVKIODHO.js";
 import {
   isMemoryCategory
-} from "./chunk-WKAXBXVA.js";
+} from "./chunk-3QQTXYZ6.js";
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
@@ -2387,4 +2387,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-7RRUHJPG.js.map
+//# sourceMappingURL=chunk-KB2G2I6Q.js.map

package/dist/{chunk-ZXBTTMGZ.js → chunk-KEF46KL2.js}

@@ -1,6 +1,3 @@
-import {
-  estimateTokenCount
-} from "./chunk-TOTT6S2V.js";
 import {
   SKILL_FILE_NAME,
   renderSkillBundle
@@ -8,9 +5,12 @@ import {
 import {
   isValidSkillSlug
 } from "./chunk-ZCUTSMR2.js";
+import {
+  estimateTokenCount
+} from "./chunk-TOTT6S2V.js";
 import {
   pathIsInside
-} from "./chunk-GCASGYIO.js";
+} from "./chunk-C7HJ3NEI.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -800,4 +800,4 @@ export {
   truncateToTokenBudget,
   describeMemoriesDir
 };
-//# sourceMappingURL=chunk-ZXBTTMGZ.js.map
+//# sourceMappingURL=chunk-KEF46KL2.js.map

package/dist/{chunk-5UZXUTVO.js → chunk-KNA3BXXL.js}

@@ -2,8 +2,12 @@
 function isErrnoCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
+function isNotFoundError(error) {
+  return isErrnoCode(error, "ENOENT");
+}
 
 export {
-  isErrnoCode
+  isErrnoCode,
+  isNotFoundError
 };
-//# sourceMappingURL=chunk-5UZXUTVO.js.map
+//# sourceMappingURL=chunk-KNA3BXXL.js.map

package/dist/chunk-KNA3BXXL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/errno.ts"],"sourcesContent":["export function isErrnoCode(error: unknown, code: string): boolean {\n  return typeof error === \"object\"\n    && error !== null\n    && \"code\" in error\n    && (error as { code?: unknown }).code === code;\n}\n\n/** True iff `error` carries Node's `ENOENT` code (missing file or directory). */\nexport function isNotFoundError(error: unknown): boolean {\n  return isErrnoCode(error, \"ENOENT\");\n}\n"],"mappings":";AAAO,SAAS,YAAY,OAAgB,MAAuB;AACjE,SAAO,OAAO,UAAU,YACnB,UAAU,QACV,UAAU,SACT,MAA6B,SAAS;AAC9C;AAGO,SAAS,gBAAgB,OAAyB;AACvD,SAAO,YAAY,OAAO,QAAQ;AACpC;","names":[]}

package/dist/{chunk-UWTDARPF.js → chunk-KTWG7CNY.js}

@@ -1,21 +1,21 @@
 import {
   resolveWorkProductLedgerDir,
   validateWorkProductLedgerEntry
-} from "./chunk-NRLELHAY.js";
+} from "./chunk-G7NYVKD6.js";
 import {
   TranscriptManager
 } from "./chunk-AM4T6CHX.js";
 import {
   resolveCommitmentLedgerDir,
   validateCommitmentLedgerEntry
-} from "./chunk-NOB2T2FC.js";
+} from "./chunk-NHLLKEKK.js";
 import {
   parseConfig
-} from "./chunk-FCATYKQA.js";
+} from "./chunk-2IOHTUP3.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
-} from "./chunk-HTP6XRUI.js";
+} from "./chunk-HM7RHKS4.js";
 import {
   assertIsoRecordedAt,
   assertSafePathSegment,
@@ -28,7 +28,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-P77QX3ID.js";
+} from "./chunk-B6O2YLUR.js";
 
 // src/resume-bundles.ts
 import path from "path";
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-UWTDARPF.js.map
+//# sourceMappingURL=chunk-KTWG7CNY.js.map

package/dist/{chunk-XQYTSZW3.js → chunk-L7Z57SID.js}

@@ -1,6 +1,6 @@
 import {
   tagPersistedMemories
-} from "./chunk-7GSSHAXC.js";
+} from "./chunk-NLYVH66G.js";
 import {
   hasBroadGraphIntent,
   planRecallMode
@@ -10,13 +10,13 @@ import {
 } from "./chunk-OD4FM2U7.js";
 import {
   parseQmdExplain
-} from "./chunk-C24UZSFW.js";
-import {
-  resolveLifecycleState
-} from "./chunk-TBBDFYXW.js";
+} from "./chunk-CEH2AFXG.js";
 import {
   classifyOrigin
 } from "./chunk-6Q3ZTEF6.js";
+import {
+  resolveLifecycleState
+} from "./chunk-TBBDFYXW.js";
 import {
   resolveScopeProfilePlan
 } from "./chunk-ESNFSSO4.js";
@@ -1712,4 +1712,4 @@ export {
   ExtractionDeadlineError,
   ExtractionRunCoordinator
 };
-//# sourceMappingURL=chunk-XQYTSZW3.js.map
+//# sourceMappingURL=chunk-L7Z57SID.js.map

package/dist/{chunk-JMAG7WZ7.js → chunk-LO4UKPKX.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-B7RWBZXW.js";
 import {
   resolveCausalTrajectoryStoreDir
-} from "./chunk-2Z3DG5CQ.js";
+} from "./chunk-B3O3IRZN.js";
 import {
   normalizeRecallTokens
 } from "./chunk-YCVB7X56.js";
@@ -16,7 +16,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-P77QX3ID.js";
+} from "./chunk-B6O2YLUR.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -339,4 +339,4 @@ export {
   scoreStitchCandidate,
   stitchCausalChain
 };
-//# sourceMappingURL=chunk-JMAG7WZ7.js.map
+//# sourceMappingURL=chunk-LO4UKPKX.js.map

package/dist/{chunk-LDWIPYJ6.js → chunk-LS2FHUML.js}

@@ -1,6 +1,6 @@
 import {
   upsertCueAnchors
-} from "./chunk-ACPCA4NO.js";
+} from "./chunk-BMWN7B3Y.js";
 import {
   normalizeRecallTokens
 } from "./chunk-YCVB7X56.js";
@@ -10,7 +10,7 @@ import {
 import {
   HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY,
   upsertAbstractionNodes
-} from "./chunk-DJUKBGAD.js";
+} from "./chunk-46EST7JO.js";
 import {
   compareDeterministicStrings
 } from "./chunk-G73MCJKL.js";
@@ -290,4 +290,4 @@ export {
   deriveHarmonicRecords,
   persistHarmonicRecords
 };
-//# sourceMappingURL=chunk-LDWIPYJ6.js.map
+//# sourceMappingURL=chunk-LS2FHUML.js.map

package/dist/{chunk-GDB4J2H3.js → chunk-MPC7TYTZ.js}

@@ -1,6 +1,6 @@
 import {
   isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-KNA3BXXL.js";
 
 // src/work/storage.ts
 import path from "path";
@@ -466,4 +466,4 @@ export {
   WORK_ID_PATTERN,
   WorkStorage
 };
-//# sourceMappingURL=chunk-GDB4J2H3.js.map
+//# sourceMappingURL=chunk-MPC7TYTZ.js.map

package/dist/{chunk-2GF27PGH.js → chunk-MRPOZBJC.js}

@@ -7,10 +7,10 @@ import {
 } from "./chunk-RL6NEVXT.js";
 import {
   assertPathInsideRoot
-} from "./chunk-GCASGYIO.js";
+} from "./chunk-C7HJ3NEI.js";
 import {
   isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-KNA3BXXL.js";
 
 // src/memory-projection-mutations.ts
 import { lstat, realpath } from "fs/promises";
@@ -115,4 +115,4 @@ export {
   rewriteProjectedMemoryEntityReference,
   rewriteProjectedEntityReferences
 };
-//# sourceMappingURL=chunk-2GF27PGH.js.map
+//# sourceMappingURL=chunk-MRPOZBJC.js.map

package/dist/{chunk-BR3OOQZQ.js → chunk-MWN6QEI2.js}

@@ -4,7 +4,7 @@ import {
 import {
   computeCorpusWatermarks,
   resolveCorpusNamespaceRoots
-} from "./chunk-EJ5RKUXW.js";
+} from "./chunk-AQ7SYDVO.js";
 
 // src/operator-doctor-corpus.ts
 var DIGEST_PREFIX_LENGTH = 12;
@@ -78,4 +78,4 @@ export {
   corpusWatermarksFromCheck,
   summarizeCorpusAndReplica
 };
-//# sourceMappingURL=chunk-BR3OOQZQ.js.map
+//# sourceMappingURL=chunk-MWN6QEI2.js.map

package/dist/{chunk-NZGO2GKL.js → chunk-MY5EDR46.js}

@@ -1,18 +1,18 @@
 import {
   StorageManager
-} from "./chunk-OGTKQ5MJ.js";
+} from "./chunk-XSGUMQQQ.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-XCB6QDL6.js";
 import {
   requestEntityCanonicalIdReconcile
-} from "./chunk-NNZFPYYX.js";
+} from "./chunk-R7QY5ZVB.js";
 import {
   decideLifecycleTransition
 } from "./chunk-TBBDFYXW.js";
 import {
   assertPathInsideRoot
-} from "./chunk-GCASGYIO.js";
+} from "./chunk-C7HJ3NEI.js";
 import {
   excludeSupportPassportPrivateMemories
 } from "./chunk-EEOUMG3J.js";
@@ -765,4 +765,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-NZGO2GKL.js.map
+//# sourceMappingURL=chunk-MY5EDR46.js.map

package/dist/{chunk-LCMUZDBZ.js → chunk-N3ZOP7KC.js}

@@ -1,6 +1,6 @@
 import {
   isValidCapsuleSince
-} from "./chunk-KQAFEZQX.js";
+} from "./chunk-VDX2J7OX.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
@@ -12,7 +12,7 @@ import {
 import {
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
   OFFLINE_SYNC_MAX_MTIME_MS
-} from "./chunk-3Q6RD76J.js";
+} from "./chunk-WQZZDN5M.js";
 import {
   validateArchiveRelativePath
 } from "./chunk-GCGJW34D.js";
@@ -492,4 +492,4 @@ export {
   actionConfidenceRequestSchema,
   validateRequest
 };
-//# sourceMappingURL=chunk-LCMUZDBZ.js.map
+//# sourceMappingURL=chunk-N3ZOP7KC.js.map

package/dist/{chunk-TVW4C7PV.js → chunk-NB3LRY4T.js}

@@ -1,18 +1,18 @@
-import {
-  withHeldFileLock
-} from "./chunk-FFAZ2XFU.js";
 import {
   computeContentHash,
   normalizeContent
 } from "./chunk-5FVVY2EB.js";
+import {
+  withHeldFileLock
+} from "./chunk-FFAZ2XFU.js";
 import {
   SecureStoreLockedError,
   readMaybeEncryptedFile,
   writeMaybeEncryptedFile
-} from "./chunk-ET2CNMLD.js";
+} from "./chunk-JN72EPOE.js";
 import {
   isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-KNA3BXXL.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -577,4 +577,4 @@ export {
   FactHashIndexNotAuthoritativeError,
   ContentHashIndex
 };
-//# sourceMappingURL=chunk-TVW4C7PV.js.map
+//# sourceMappingURL=chunk-NB3LRY4T.js.map

package/dist/{chunk-QJCWK2A7.js → chunk-ND6IQGSZ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-VQ7B2Q6M.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-WKAXBXVA.js";
+} from "./chunk-3QQTXYZ6.js";
 import {
   isCodingKnowledgeFeatureEnabled
 } from "./chunk-FEHIOYML.js";
@@ -1463,4 +1463,4 @@ export {
   serializeDecisionRecord,
   parseDecisionRecord
 };
-//# sourceMappingURL=chunk-QJCWK2A7.js.map
+//# sourceMappingURL=chunk-ND6IQGSZ.js.map

package/dist/{chunk-NOB2T2FC.js → chunk-NHLLKEKK.js}

@@ -11,7 +11,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-P77QX3ID.js";
+} from "./chunk-B6O2YLUR.js";
 
 // src/commitment-ledger.ts
 import path from "path";
@@ -225,4 +225,4 @@ export {
   applyCommitmentLedgerLifecycle,
   getCommitmentLedgerStatus
 };
-//# sourceMappingURL=chunk-NOB2T2FC.js.map
+//# sourceMappingURL=chunk-NHLLKEKK.js.map

package/dist/{chunk-7GSSHAXC.js → chunk-NLYVH66G.js}

@@ -1,7 +1,7 @@
 import {
   STRUCTURED_ATTRIBUTE_LIMITS,
   TAG_LIMITS
-} from "./chunk-WKAXBXVA.js";
+} from "./chunk-3QQTXYZ6.js";
 import {
   activityDayWindow,
   isValidActivityDate
@@ -11,7 +11,10 @@ import {
 } from "./chunk-AW4QUFQF.js";
 import {
   pathIsInside
-} from "./chunk-GCASGYIO.js";
+} from "./chunk-C7HJ3NEI.js";
+import {
+  isErrnoCode
+} from "./chunk-KNA3BXXL.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -581,9 +584,6 @@ function parseLocationDaySummary(raw) {
     contentHash: parseScalar(scalars.contentHash)
   };
 }
-function isErrnoCode(err, code) {
-  return err instanceof Error && err.code === code;
-}
 async function assertNotSymlink(target, kind) {
   let stat;
   try {
@@ -863,4 +863,4 @@ export {
   fillWearableConversationLocations,
   renderDayLocationContext
 };
-//# sourceMappingURL=chunk-7GSSHAXC.js.map
+//# sourceMappingURL=chunk-NLYVH66G.js.map