@remnic/core 9.7.14 → 9.8.0

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/rebuild-memory-lifecycle-ledger.ts"],"sourcesContent":["import path from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { StorageManager } from \"../storage.js\";\nimport { log } from \"../logger.js\";\nimport { displayErrorDetail } from \"../runtime/better-sqlite.js\";\nimport type { MemoryLifecycleEvent } from \"../types.js\";\nimport { toBackupStamp } from \"./backup-stamp.js\";\nimport { copyExistingFileToBackup, writeFileAtomically } from \"./atomic-file.js\";\nimport {\n  buildLifecycleEventsForMemory,\n  compareMemoryLifecycleEvents,\n  sortMemoryLifecycleEvents,\n  memoryLifecycleLedgerLockPath,\n  MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS,\n} from \"../memory-lifecycle-ledger-utils.js\";\nimport { withHeldFileLock, type HeldFileLockOptions, type HeldFileLockController } from \"../utils/serialize-mutations.js\";\nimport { probeEncryptedRegularFileHeader } from \"../secure-store/secure-fs.js\";\n\n/**\n * Event types `buildLifecycleEventsForMemory` reconstructs from frontmatter.\n * Everything else in the ledger is append-only history with no frontmatter\n * equivalent and must be carried over by a preserving rebuild (issue #1910).\n */\nconst FRONTMATTER_DERIVED_EVENT_TYPES: Record<string, true> = {\n  created: true,\n  updated: true,\n  superseded: true,\n  archived: true,\n};\n\nexport interface RebuildMemoryLifecycleLedgerOptions {\n  memoryDir: string;\n  dryRun?: boolean;\n  now?: Date;\n  /**\n   * Active storage context (issue #1910). When provided, memories are read\n   * through it (so encrypted-at-rest memories in a secure-store deployment are\n   * decrypted with the live key) and the rebuilt ledger is rewritten through\n   * its secure writer (so it stays encrypted at rest). Its `dir` MUST equal\n   * `memoryDir`. When omitted, a fresh plaintext `StorageManager` is used and\n   * the ledger is written as plaintext — the CLI default.\n   */\n  storage?: StorageManager;\n  /**\n   * Preserve append-only lifecycle events that have no frontmatter equivalent\n   * (issue #1910). `buildLifecycleEventsForMemory` only reconstructs\n   * `created`/`updated`/`superseded`/`archived` from frontmatter, so a bare\n   * rebuild silently drops history like `explicit_capture_accepted`,\n   * `explicit_capture_queued`, `imported`, `promoted`, `merged`, `restored`,\n   * and `rejected`. When true, the existing ledger's non-reconstructable rows\n   * are read (via the same secure/permissive `readAllMemoryLifecycleEvents`\n   * path), merged with the rebuilt rows, deduplicated by `eventId`, and sorted\n   * canonically. Background auto-compaction sets this so it never loses events;\n   * the manual/CLI repair rebuild leaves it off (reconstruct purely from\n   * frontmatter).\n   */\n  preserveExistingEvents?: boolean;\n  /**\n   * Override the ledger-lock acquisition timing (issue #2033). Only\n   * `maxWaitMs`/`pollMs` are honored; `staleMs` stays fixed at\n   * `MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS`. Used by tests to force the\n   * lock-acquisition-failure branch (`acquired=false`) deterministically\n   * without a multi-second wait.\n   */\n  lockOptions?: Pick<HeldFileLockOptions, \"maxWaitMs\" | \"pollMs\">;\n  /**\n   * Upper bound (bytes) on the rewritten ledger when preserving events (issue\n   * #2033). A preserving compaction carries over ALL append-only history, which\n   * — if the history alone is large — could leave the rewritten ledger over the\n   * whole-file read/decrypt cap (STATE_FILE_MAX_DECRYPT_BYTES), the exact\n   * unreadable-ledger failure compaction exists to prevent. When set and the\n   * preserved payload would exceed it, the OLDEST rows are dropped from the\n   * active ledger until it fits; because the full pre-compaction ledger is\n   * copied verbatim to the timestamped backup first, those rows are archived,\n   * not lost. Ignored when `preserveExistingEvents` is off (a frontmatter-only\n   * rebuild is already bounded by the corpus). `0`/undefined disables bounding.\n   */\n  maxLedgerBytes?: number;\n}\n\nexport interface SkippedLifecycleBlankIdMemory {\n  path: string;\n}\n\nexport interface SkippedDuplicateLifecycleEvent {\n  eventId: string;\n  keptPath: string;\n  skippedPath: string;\n}\n\nexport interface RebuildMemoryLifecycleLedgerResult {\n  dryRun: boolean;\n  scannedMemories: number;\n  rebuiltRows: number;\n  outputPath: string;\n  backupPath?: string;\n  skippedBlankIdMemories: SkippedLifecycleBlankIdMemory[];\n  skippedDuplicateEvents: SkippedDuplicateLifecycleEvent[];\n  /**\n   * Count of existing-ledger rows carried over beyond the frontmatter\n   * reconstruction (only set when `preserveExistingEvents` is on; issue #1910):\n   * append-only history with no frontmatter equivalent, plus any\n   * frontmatter-derived row that raced in after the corpus scan and so was not\n   * reproduced by the reconstruction (#2033).\n   */\n  preservedAppendOnlyRows?: number;\n  /**\n   * Count of oldest rows dropped from the ACTIVE ledger to keep it under\n   * `maxLedgerBytes` (issue #2033). They remain in the verbatim timestamped\n   * backup, so this is a bound-and-archive, not a loss. Set only when bounding\n   * actually trimmed rows.\n   */\n  archivedOverflowRows?: number;\n  /**\n   * Whether the active ledger was actually backed up and rewritten (issue #2033\n   * thread PRRT_kwDORJXyws6SExst). A preserving write-mode rebuild that would\n   * reproduce the current ledger byte-for-byte (same decrypted content AND same\n   * at-rest format) skips the backup+rewrite, so callers can distinguish a real\n   * compaction from a no-op and avoid re-archiving an unchanged ledger every\n   * interval. `true` for every dry run's non-write preview is never set — only\n   * write-mode results carry it; defaults to `false` when no rewrite happened.\n   */\n  rewritten?: boolean;\n}\n\nfunction isNodeError(err: unknown): err is NodeJS.ErrnoException {\n  return typeof err === \"object\" && err !== null && \"code\" in err;\n}\n\n/** Serialized on-disk size (bytes, incl. trailing newline) of one ledger row. */\nfunction lifecycleRowBytes(event: MemoryLifecycleEvent): number {\n  return Buffer.byteLength(`${JSON.stringify(event)}\\n`, \"utf8\");\n}\n\n/**\n * Keep the NEWEST canonically-ordered events whose serialized payload fits\n * strictly under `cap` bytes (issue #2033). Recency is by `timestamp` (newest\n * first), tie-broken by the canonical comparator, so a large append-only\n * history is trimmed to its most recent rows rather than to a single memoryId\n * group (the ledger's on-disk order is by memoryId then time).\n *\n * A row too large to fit the remaining budget is SKIPPED, and scanning\n * continues to older rows that still fit — one oversized (or future-dated,\n * hence recency-first) row cannot truncate the entire older history. The kept\n * subset is returned in the input's canonical order; the caller relies on the\n * verbatim backup to retain the dropped rows.\n */\nexport function boundLifecycleEventsToByteCap(\n  events: MemoryLifecycleEvent[],\n  cap: number,\n): { kept: MemoryLifecycleEvent[]; dropped: number } {\n  if (!(cap > 0)) return { kept: events, dropped: 0 };\n  const sizes = new Map<MemoryLifecycleEvent, number>();\n  let total = 0;\n  for (const event of events) {\n    const bytes = lifecycleRowBytes(event);\n    sizes.set(event, bytes);\n    total += bytes;\n  }\n  if (total <= cap) return { kept: events, dropped: 0 };\n  const byRecency = [...events].sort((a, b) => {\n    if (a.timestamp !== b.timestamp) return b.timestamp.localeCompare(a.timestamp);\n    return -compareMemoryLifecycleEvents(a, b);\n  });\n  const keep = new Set<MemoryLifecycleEvent>();\n  let running = 0;\n  for (const event of byRecency) {\n    const bytes = sizes.get(event)!;\n    if (running + bytes > cap) continue; // skip this row, keep scanning older rows that still fit\n    running += bytes;\n    keep.add(event);\n  }\n  const kept = events.filter((event) => keep.has(event));\n  return { kept, dropped: events.length - kept.length };\n}\n\nexport async function backupExistingLedger(\n  memoryDir: string,\n  outputPath: string,\n  now: Date,\n): Promise<string | undefined> {\n  try {\n    await stat(outputPath);\n  } catch (err) {\n    if (isNodeError(err) && err.code === \"ENOENT\") {\n      return undefined;\n    }\n    throw err;\n  }\n\n  const backupPath = path.join(\n    memoryDir,\n    \"archive\",\n    \"memory-lifecycle-ledger\",\n    toBackupStamp(now),\n    \"state\",\n    \"memory-lifecycle-ledger.jsonl\",\n  );\n  return backupPath;\n}\n\nexport async function rebuildMemoryLifecycleLedger(\n  options: RebuildMemoryLifecycleLedgerOptions,\n): Promise<RebuildMemoryLifecycleLedgerResult> {\n  const dryRun = options.dryRun !== false;\n  const now = options.now ?? new Date();\n  const outputPath = path.join(options.memoryDir, \"state\", \"memory-lifecycle-ledger.jsonl\");\n  const storage = options.storage ?? new StorageManager(options.memoryDir);\n  if (options.storage && path.resolve(storage.dir) !== path.resolve(options.memoryDir)) {\n    throw new Error(\n      `rebuildMemoryLifecycleLedger: storage.dir (${storage.dir}) must match `\n      + `memoryDir (${options.memoryDir})`,\n    );\n  }\n  const secureRewrite = options.storage !== undefined;\n  const tiers = [\n    await storage.readAllMemories(),\n    await storage.readAllColdMemories(),\n    await storage.readArchivedMemories(),\n  ];\n  const allMemories = tiers.flat();\n  const skippedBlankIdMemories: SkippedLifecycleBlankIdMemory[] = [];\n  const eventCandidates: Array<{ event: MemoryLifecycleEvent; path: string }> = [];\n  for (const tier of tiers) {\n    for (const memory of [...tier].sort((left, right) => left.path.localeCompare(right.path))) {\n      if (!memory.frontmatter.id.trim()) {\n        skippedBlankIdMemories.push({ path: memory.path });\n        log.warn(`lifecycle ledger rebuild skipped blank memory id: path=${memory.path}`);\n        continue;\n      }\n      for (const event of buildLifecycleEventsForMemory(memory)) {\n        eventCandidates.push({ event, path: memory.path });\n      }\n    }\n  }\n\n  const orderedEvents = sortMemoryLifecycleEvents(eventCandidates.map((candidate) => candidate.event));\n  const candidateByEvent = new Map(\n    eventCandidates.map((candidate) => [candidate.event, candidate]),\n  );\n  const keptByEventId = new Map<string, { event: MemoryLifecycleEvent; path: string }>();\n  const events: MemoryLifecycleEvent[] = [];\n  const skippedDuplicateEvents: SkippedDuplicateLifecycleEvent[] = [];\n  for (const event of orderedEvents) {\n    const candidate = candidateByEvent.get(event)!;\n    const kept = keptByEventId.get(event.eventId);\n    if (kept) {\n      skippedDuplicateEvents.push({\n        eventId: event.eventId,\n        keptPath: kept.path,\n        skippedPath: candidate.path,\n      });\n      log.warn(\n        `lifecycle ledger rebuild skipped duplicate event_id=${event.eventId}: `\n        + `kept=${kept.path} skipped=${candidate.path}`,\n      );\n      continue;\n    }\n    keptByEventId.set(event.eventId, candidate);\n    events.push(event);\n  }\n\n  let finalEvents = events;\n  let preservedAppendOnlyRows: number | undefined;\n  let archivedOverflowRows: number | undefined;\n  let backupPath: string | undefined;\n  let rewritten = false;\n  // The preserve-read + whole-file rewrite are serialized against concurrent\n  // lifecycle appends ONLY in write mode (issue #1910, codex):\n  // appendMemoryLifecycleEvents holds this same cross-process lock, so an event\n  // appended after the preserve-read but before the atomic rename waits and\n  // lands on the compacted ledger instead of being clobbered by the rename. A\n  // DRY RUN takes no lock — it reads the ledger read-only to compute the\n  // preserve/merge/byte-cap PREVIEW and never rewrites, so it must not block\n  // appends (#2033 Cursor). The corpus scan above stays outside the lock in\n  // both modes — frontmatter-derived rows come from the memory files.\n  const runLedgerCriticalSection = async (\n    acquired: boolean,\n    lock: HeldFileLockController | null,\n  ): Promise<void> => {\n    // A WRITE that read or rewrote the ledger without the lock could race a\n    // concurrent append/rewrite and lose data, so REFUSE the unlocked fallback\n    // withHeldFileLock takes on acquisition timeout (issue #2033 CodeRabbit\n    // Critical / codex). A dry run passes lock=null and acquired=true: it never\n    // reaches the rewrite, so the unlocked preview read is safe.\n    if (!dryRun && !acquired) {\n      throw new Error(\n        \"lifecycle ledger rebuild aborted: could not acquire the ledger lock within the \"\n        + \"acquisition budget; refusing to read or rewrite unlocked so a concurrent append \"\n        + \"or compaction cannot be clobbered (issue #1910).\",\n      );\n    }\n    if (options.preserveExistingEvents) {\n      // Merge the frontmatter reconstruction (`events`) with the CURRENT ledger\n      // so compaction never deletes a lifecycle row that raced the scan (issue\n      // #1910, #2033). Read the existing ledger through the uncapped BUFFER\n      // path — it decrypts with the live key when `storage` carries the secure\n      // context and bypasses the whole-file string decrypt cap, so an oversize\n      // encrypted ledger (the exact file compaction must shrink) is still\n      // readable here rather than aborting (#2033 Cursor High).\n      // preserveExistingEvents means \"never lose history\": if the current\n      // ledger genuinely cannot be read (corruption, or a locked required\n      // store), ABORT rather than rewrite from frontmatter only and silently\n      // drop that history. An absent ledger reads as [] (ENOENT swallowed\n      // downstream), so a throw here is always a real read failure.\n      let existing: MemoryLifecycleEvent[];\n      try {\n        existing = await storage.readAllMemoryLifecycleEventsForCompaction();\n      } catch (err) {\n        throw new Error(\n          `lifecycle ledger rebuild aborted: cannot read existing events to preserve `\n          + `(${displayErrorDetail(err) || \"unknown error\"})`,\n        );\n      }\n      // The corpus scan (`events`) runs OUTSIDE the lock and is therefore a\n      // stale snapshot; `existing` is read here under the lock and is\n      // authoritative for what the ledger holds at rewrite time. A\n      // frontmatter-derived row (created/updated/superseded/archived) is safe to\n      // collapse into the reconstruction ONLY when the scan actually reproduced\n      // the same logical event — same (memoryId, eventType, timestamp), which is\n      // exactly what the live append stamps (fm.created/updated/...) and what\n      // makeRebuiltMemoryLifecycleEvent emits. A frontmatter-derived row whose\n      // content key the reconstruction did NOT produce raced in after the scan\n      // (a memory created/updated between the scan and this locked read); the\n      // reconstruction has no equivalent, so dropping it by eventType alone\n      // would delete it. Preserve it instead, deduped by content key so a\n      // retried append of the same logical event still collapses to one. Rows\n      // that are not frontmatter-derived are append-only history with no\n      // reconstruction — always carried over, deduped by eventId in the merge.\n      const contentKey = (event: MemoryLifecycleEvent): string =>\n        `${event.memoryId}\\u0000${event.eventType}\\u0000${event.timestamp}`;\n      const reconstructedKeys = new Set(events.map(contentKey));\n      const racedFrontmatterByKey = new Map<string, MemoryLifecycleEvent>();\n      const appendOnly: MemoryLifecycleEvent[] = [];\n      for (const event of existing) {\n        if (!FRONTMATTER_DERIVED_EVENT_TYPES[event.eventType]) {\n          appendOnly.push(event);\n          continue;\n        }\n        const key = contentKey(event);\n        if (reconstructedKeys.has(key)) continue; // collapsed into reconstruction\n        if (!racedFrontmatterByKey.has(key)) racedFrontmatterByKey.set(key, event);\n      }\n      const mergedById = new Map<string, MemoryLifecycleEvent>();\n      for (const event of sortMemoryLifecycleEvents([\n        ...events,\n        ...racedFrontmatterByKey.values(),\n        ...appendOnly,\n      ])) {\n        if (!mergedById.has(event.eventId)) mergedById.set(event.eventId, event);\n      }\n      finalEvents = [...mergedById.values()];\n      preservedAppendOnlyRows = finalEvents.length - events.length;\n      // Bound the rewritten ledger so a preserving compaction can never leave it\n      // over the whole-file read/decrypt cap (#2033). This must run whenever a\n      // cap is set — NOT only when `existing.length > 0`: an oversized on-disk\n      // ledger whose every row fails validation reads as `existing === []`, yet\n      // `finalEvents` (the frontmatter reconstruction) can itself exceed the cap.\n      // Overflow (oldest) rows are dropped from the active ledger but survive\n      // both in the timestamped backup (a verbatim copy when the ledger is\n      // plaintext, re-encrypted under the backup path's own AAD when it is\n      // encrypted so it still decrypts there, #2033) and, for frontmatter-derived\n      // rows, in the memory files they were reconstructed from — so a later full\n      // rebuild regenerates them.\n      if (options.maxLedgerBytes && options.maxLedgerBytes > 0) {\n        const bounded = boundLifecycleEventsToByteCap(finalEvents, options.maxLedgerBytes);\n        if (bounded.dropped > 0) {\n          finalEvents = bounded.kept;\n          archivedOverflowRows = bounded.dropped;\n          log.warn(\n            `lifecycle ledger rebuild bounded to ${options.maxLedgerBytes} bytes: `\n            + `dropped ${bounded.dropped} oldest row(s) from the active ledger `\n            + `(preserved in the backup) to stay under the read/decrypt cap.`,\n          );\n        }\n      }\n    }\n\n    // Re-assert the lock immediately before the destructive active-ledger\n    // rewrite. Everything above (the preserve read, merge, sort, byte-cap\n    // bound, and JSON serialize) is CPU-bound and blocks the event loop, so the\n    // timer heartbeat inside withHeldFileLock cannot refresh the lock's mtime;\n    // a peer that judged the lock stale within the 30s window could have broken\n    // it and appended to the current ledger. `lock.refresh()` (a) reports the\n    // lock LOST so we ABORT rather than rename our compacted file over that\n    // peer's append, and (b) when still held, re-stamps the mtime so the bounded\n    // write below cannot itself be judged stale mid-rename (issue #1910/#2033).\n    const abortIfLockLost = async (): Promise<void> => {\n      if (lock && await lock.refresh()) return;\n      throw new Error(\n        \"lifecycle ledger rebuild aborted: lost the ledger lock during the compaction \"\n        + \"rewrite (a peer stale-broke it while the event loop was blocked by CPU-bound \"\n        + \"merge/serialize); refusing to clobber a concurrent append (issue #1910/#2033).\",\n      );\n    };\n    if (!dryRun) {\n      const payload = finalEvents.map((event) => JSON.stringify(event)).join(\"\\n\");\n      const content = payload.length > 0 ? `${payload}\\n` : \"\";\n      // No-op skip (#2033 thread PRRT_kwDORJXyws6SExst): a preserving rebuild\n      // bounds the ACTIVE ledger to the read/decrypt cap, so a VALID ledger that\n      // sits above the configured compaction trigger but below the cap would\n      // otherwise be rewritten to identical content and re-archived on every\n      // maintenance interval — unbounded growth of archive/memory-lifecycle-ledger\n      // plus pointless disk/CPU churn. Skip the backup+rewrite when it would\n      // change neither the logical (decrypted) content NOR the at-rest format.\n      // The raw read here doubles as the source for the encrypted verbatim backup\n      // below, so the current ledger is read at most once. An absent ledger reads\n      // as ENOENT (a create is always a real change) and any other read/probe\n      // error propagates rather than masking a needed rewrite.\n      let currentEncrypted = false;\n      let priorRawBuffer: Buffer | null = null;\n      try {\n        currentEncrypted = await probeEncryptedRegularFileHeader(outputPath);\n        priorRawBuffer = await storage.readMemoryLifecycleLedgerRawBufferForCompaction();\n      } catch (err) {\n        if (!isNodeError(err) || err.code !== \"ENOENT\") throw err;\n      }\n      // Preserve encryption at rest (#2033). An already-encrypted ledger (or its\n      // encrypted backup) MUST be rewritten encrypted even when the\n      // `secureStoreEncryptOnWrite` policy is paused — otherwise the compaction\n      // silently DOWNGRADES encrypted state to plaintext. Force encryption\n      // whenever the current ledger is encrypted and the store is unlocked (a\n      // key is available); reaching this point with an encrypted ledger already\n      // implies an unlocked store, since the raw read above decrypts and would\n      // have thrown under a locked key. A plaintext ledger keeps the ordinary\n      // policy (`willEncryptStateWrites`), so existing plaintext behavior holds.\n      const forceEncrypt =\n        secureRewrite && currentEncrypted && storage.isSecureStoreUnlocked();\n      const replacementEncrypted =\n        secureRewrite && (storage.willEncryptStateWrites() || forceEncrypt);\n      // Compare as buffers, never decoding the raw ledger to one giant string:\n      // a multi-hundred-MB decrypted ledger can exceed V8's max string length,\n      // so `priorRawBuffer.equals(...)` (byte compare) must be used, NOT\n      // `.toString()` (#2033 giant-string invariant). `content` is the freshly\n      // serialized replacement, already a string; Buffer.from() reuses it.\n      if (\n        priorRawBuffer !== null &&\n        currentEncrypted === replacementEncrypted &&\n        priorRawBuffer.equals(Buffer.from(content, \"utf8\"))\n      ) {\n        // Nothing to change: leave the active ledger and archive untouched.\n        rewritten = false;\n      } else {\n        const desiredBackup = await backupExistingLedger(options.memoryDir, outputPath, now);\n        if (secureRewrite) {\n          // Preserve encrypted-at-rest (issue #1910). The BACKUP needs care under\n          // secure-store (#2033): when the existing ledger is encrypted, its bytes\n          // are path-bound via AAD, so a byte-for-byte copy to the archive path\n          // cannot be decrypted there — it would silently orphan the overflow rows\n          // a bounded rewrite claims to preserve. Reuse the RAW decrypted ledger\n          // content read above (no event parsing, so malformed/truncated/future\n          // rows survive exactly as the plaintext verbatim copy keeps them) and\n          // re-encrypt it under the backup path's own AAD, yielding a directly\n          // decryptable backup that retains every original byte. A PLAINTEXT\n          // existing ledger is already readable, so a verbatim copy is correct.\n          // Then rewrite the active ledger through the secure writer.\n          if (desiredBackup && currentEncrypted) {\n            const rawForBackup =\n              priorRawBuffer ?? (await storage.readMemoryLifecycleLedgerRawBufferForCompaction());\n            await storage.writeMemoryLifecycleLedgerContent(rawForBackup, desiredBackup, forceEncrypt);\n            backupPath = desiredBackup;\n          } else {\n            backupPath = desiredBackup\n              ? await copyExistingFileToBackup(outputPath, desiredBackup)\n              : undefined;\n          }\n          await abortIfLockLost();\n          await storage.writeMemoryLifecycleLedgerContent(content, undefined, forceEncrypt);\n        } else {\n          await abortIfLockLost();\n          backupPath = await writeFileAtomically(outputPath, content, desiredBackup);\n        }\n        rewritten = true;\n      }\n    }\n  };\n  // Write mode holds the ledger lock across the preserve-read and atomic\n  // rewrite so a concurrent append lands on the compacted ledger instead of\n  // being clobbered. A dry run computes the SAME preserve/merge/byte-cap\n  // preview but WITHOUT the lock (read-only, no rewrite), so `rebuiltRows`,\n  // `preservedAppendOnlyRows`, and `archivedOverflowRows` report what a --write\n  // would apply while never blocking concurrent appends (#2033 Cursor). A dry\n  // run with nothing to preserve touches nothing at all.\n  if (!dryRun) {\n    await withHeldFileLock(\n      memoryLifecycleLedgerLockPath(outputPath),\n      { staleMs: MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS, ...options.lockOptions },\n      runLedgerCriticalSection,\n    );\n  } else if (options.preserveExistingEvents) {\n    await runLedgerCriticalSection(true, null);\n  }\n\n  return {\n    dryRun,\n    scannedMemories: allMemories.length,\n    rebuiltRows: finalEvents.length,\n    outputPath,\n    backupPath,\n    skippedBlankIdMemories,\n    skippedDuplicateEvents,\n    preservedAppendOnlyRows,\n    archivedOverflowRows,\n    rewritten,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-3FAMU5TX.js → chunk-A6USBZTO.js}

@@ -5,7 +5,7 @@ import {
 import {
   serializeMutations,
   withHeldFileLock
-} from "./chunk-LTJAMRGI.js";
+} from "./chunk-WL5EBRDH.js";
 
 // src/summary-snapshot.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -147,4 +147,4 @@ export {
   writeSummarySnapshot,
   upsertSummarySnapshot
 };
-//# sourceMappingURL=chunk-3FAMU5TX.js.map
+//# sourceMappingURL=chunk-A6USBZTO.js.map

package/dist/{chunk-TXVD7PLT.js → chunk-A72SWTWW.js}

@@ -1,24 +1,24 @@
 import {
   runPostConsolidationMaterialize
-} from "./chunk-W5NKDU24.js";
+} from "./chunk-WON4APQY.js";
 import {
   discoverMemoryExtensions,
   renderExtensionsBlock,
   resolveExtensionsRoot
 } from "./chunk-JLNBQWZ2.js";
+import {
+  isSemanticConsolidationLlmOperator
+} from "./chunk-G7D6GZ5J.js";
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
 } from "./chunk-ZBJMUXZH.js";
-import {
-  isSemanticConsolidationLlmOperator
-} from "./chunk-G7D6GZ5J.js";
 import {
   resolvePipelineProcessingCapabilities
-} from "./chunk-BFPETA3S.js";
+} from "./chunk-SCCO46KZ.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/semantic-consolidation.ts
 function findSimilarClusters(memories, config) {
@@ -220,4 +220,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-TXVD7PLT.js.map
+//# sourceMappingURL=chunk-A72SWTWW.js.map

package/dist/{chunk-FC77VUX5.js → chunk-A7Q43EUZ.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/conversation-index/search.ts
 async function searchConversationIndex(qmd, query, maxResults) {
@@ -26,4 +26,4 @@ export {
   searchConversationIndex,
   searchConversationIndexFaissFailOpen
 };
-//# sourceMappingURL=chunk-FC77VUX5.js.map
+//# sourceMappingURL=chunk-A7Q43EUZ.js.map

package/dist/{chunk-UJBESW6X.js → chunk-AE7WMV4V.js}

@@ -5,7 +5,7 @@ import {
   loadTokenStore,
   revokeToken,
   saveTokenStore
-} from "./chunk-4OKLXWDZ.js";
+} from "./chunk-KNB7IBBU.js";
 import {
   getConnectorsDir,
   getRegistryPath
@@ -13,12 +13,9 @@ import {
 import {
   launchProcessSync
 } from "./chunk-O75CRYGF.js";
-import {
-  resolveConversationContextCapabilities
-} from "./chunk-BFPETA3S.js";
 import {
   coerceInstallExtension
-} from "./chunk-PHK3HARR.js";
+} from "./chunk-PQVCH2AE.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -27,9 +24,12 @@ import {
   readEnvVar,
   resolveHomeDir
 } from "./chunk-JUC24CTX.js";
+import {
+  resolveConversationContextCapabilities
+} from "./chunk-SCCO46KZ.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/connectors/index.ts
 import fs3 from "fs";
@@ -3029,4 +3029,4 @@ export {
   resolveWeCloneProxyConfigPath,
   buildWeCloneProxyConfig
 };
-//# sourceMappingURL=chunk-UJBESW6X.js.map
+//# sourceMappingURL=chunk-AE7WMV4V.js.map

package/dist/{chunk-J2HSAU72.js → chunk-AIK5W3IW.js}

@@ -10,6 +10,9 @@ import {
   parseEnvelope,
   seal
 } from "./chunk-A6XUJE5D.js";
+import {
+  isErrnoCode
+} from "./chunk-5UZXUTVO.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -34,11 +37,34 @@ var MAGIC_BYTES = Buffer.from("REMNIC-ENC", "ascii");
 var FILE_FORMAT_VERSION = 1;
 var FILE_FORMAT_FLAGS = 0;
 var MAGIC_HEADER_SIZE = MAGIC_BYTES.length + 2;
+var SECURE_STORE_ENVELOPE_OVERHEAD_BYTES = MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE;
 function isEncryptedFile(buf) {
   if (buf.length < MAGIC_HEADER_SIZE) return false;
   const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
   return b.subarray(0, MAGIC_BYTES.length).equals(MAGIC_BYTES);
 }
+async function probeEncryptedRegularFileHeader(probePath) {
+  let entryStat;
+  try {
+    entryStat = await lstat(probePath);
+  } catch (err) {
+    if (isErrnoCode(err, "ENOENT")) return false;
+    throw err;
+  }
+  if (!entryStat.isFile()) {
+    throw new Error(
+      `refusing to probe non-regular state path ${probePath} (symlink/FIFO/device); opening it could block or escape containment (#2033)`
+    );
+  }
+  const handle = await openFile(probePath, "r");
+  try {
+    const header = Buffer.alloc(MAGIC_HEADER_SIZE);
+    const { bytesRead } = await handle.read(header, 0, header.length, 0);
+    return isEncryptedFile(header.subarray(0, bytesRead));
+  } finally {
+    await handle.close();
+  }
+}
 function encryptFileBody(plain, key, aad) {
   const plainBuf = typeof plain === "string" ? Buffer.from(plain, "utf8") : plain;
   const salt = generateSalt();
@@ -442,7 +468,9 @@ export {
   FILE_FORMAT_VERSION,
   FILE_FORMAT_FLAGS,
   MAGIC_HEADER_SIZE,
+  SECURE_STORE_ENVELOPE_OVERHEAD_BYTES,
   isEncryptedFile,
+  probeEncryptedRegularFileHeader,
   encryptFileBody,
   decryptFileBody,
   filePathAad,
@@ -453,4 +481,4 @@ export {
   migrateMemoryDirToEncrypted,
   decryptMemoryDirToPlaintext
 };
-//# sourceMappingURL=chunk-J2HSAU72.js.map
+//# sourceMappingURL=chunk-AIK5W3IW.js.map

package/dist/chunk-AIK5W3IW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/secure-store/secure-fs.ts"],"sourcesContent":["/**\n * Transparent file-level encryption for the secure-store module.\n *\n * Issue #690 (PR 3/4) — storage.ts integration layer.\n *\n * This module sits between the raw filesystem and StorageManager.\n * Every memory file is either:\n *   - a plain UTF-8 text file (legacy, back-compat), or\n *   - a REMNIC-ENC sealed file (AES-256-GCM, see format below).\n *\n * On-disk format\n * --------------\n * Encrypted files begin with a 9-byte magic header:\n *\n *   REMNIC-ENC  (7 ASCII bytes)\n *   VER         (1 byte, currently 0x01)\n *   FLAGS       (1 byte, reserved, must be 0x00)\n *\n * Followed immediately by a `seal()` envelope from `cipher.ts`:\n *\n *   [VERSION:1][SALT:16][IV:12][AUTHTAG:16][CIPHERTEXT:...]\n *\n * The magic header makes encrypted files sniffable without attempting\n * a full `open()` call and gives operators a clear signal that the\n * file cannot be read by opening it in an editor.\n *\n * AAD\n * ---\n * The file path relative to the memory root is bound as Associated\n * Authenticated Data (AAD) on both encrypt and decrypt. This means\n * moving or renaming an encrypted file without re-encrypting it will\n * cause auth-tag failure on the next read — the file is tied to its\n * path. Callers that move files must re-encrypt them.\n *\n * Back-compat\n * -----------\n * `readMaybeEncryptedFile` transparently handles both formats: if the\n * file does NOT start with the magic bytes, it is returned as-is (plain\n * text). This lets an operator migrate incrementally: newly-written\n * files are encrypted while existing files continue to be read in plain\n * form until `migrateMemoryDirToEncrypted` is run.\n *\n * Naming: `secure-fs.ts` (not `vault-fs.ts`) — see `kdf.ts` naming note.\n */\n\nimport { createCipheriv, randomBytes, randomUUID } from \"node:crypto\";\nimport { lstat, mkdir, open as openFile, readFile, readdir, rename, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\nimport {\n  AUTH_TAG_LENGTH,\n  ENVELOPE_HEADER_SIZE,\n  ENVELOPE_LAYOUT,\n  ENVELOPE_SALT_LENGTH,\n  ENVELOPE_VERSION,\n  IV_LENGTH,\n  generateSalt,\n  open as openEnvelope,\n  parseEnvelope,\n  seal,\n} from \"./cipher.js\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\n\n// ---------------------------------------------------------------------------\n// Error classes\n// ---------------------------------------------------------------------------\n\n/**\n * Thrown when a read is attempted but the keyring entry for this\n * store is absent (i.e. `secure-store unlock` has not been run\n * since the last daemon start).\n */\nexport class SecureStoreLockedError extends Error {\n  constructor(message = \"secure-store is locked — run `remnic secure-store unlock` to decrypt\") {\n    super(message);\n    this.name = \"SecureStoreLockedError\";\n  }\n}\n\n/**\n * Thrown when `open()` fails because the auth tag does not validate.\n * This covers both wrong-key and tampered-ciphertext scenarios —\n * intentionally indistinguishable from the caller's perspective.\n */\nexport class SecureStoreDecryptError extends Error {\n  constructor(message = \"secure-store decryption failed — wrong key or tampered ciphertext\") {\n    super(message);\n    this.name = \"SecureStoreDecryptError\";\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Magic header\n// ---------------------------------------------------------------------------\n\n/** Magic bytes: the ASCII string \"REMNIC-ENC\" (10 bytes). */\nexport const MAGIC_BYTES = Buffer.from(\"REMNIC-ENC\", \"ascii\");\n\n/** Current on-disk version byte. */\nexport const FILE_FORMAT_VERSION = 0x01;\n\n/** Reserved flags byte — must be 0x00. */\nexport const FILE_FORMAT_FLAGS = 0x00;\n\n/** Total size of the magic header prefix (magic + version + flags). */\nexport const MAGIC_HEADER_SIZE = MAGIC_BYTES.length + 2; // 12 bytes\n\n/**\n * Exact, deterministic bytes `writeMaybeEncryptedFile` adds to an encrypted\n * file beyond its plaintext body: the magic header prefix plus the fixed\n * envelope header (version + salt + IV + auth tag). AES-256-GCM ciphertext\n * matches the plaintext length and the state-file write path applies no\n * compression, so an encrypted state file is exactly `plaintext +\n * SECURE_STORE_ENVELOPE_OVERHEAD_BYTES` on disk. Compaction reserves this so an\n * encrypted ledger lands strictly below the reader's whole-file decrypt cap\n * (issue #2033).\n */\nexport const SECURE_STORE_ENVELOPE_OVERHEAD_BYTES = MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE;\n\n// ---------------------------------------------------------------------------\n// Detection\n// ---------------------------------------------------------------------------\n\n/**\n * Return true iff `buf` begins with the REMNIC-ENC magic header.\n * Does not validate the envelope; just identifies the format.\n */\nexport function isEncryptedFile(buf: Uint8Array): boolean {\n  if (buf.length < MAGIC_HEADER_SIZE) return false;\n  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);\n  return b.subarray(0, MAGIC_BYTES.length).equals(MAGIC_BYTES);\n}\n\n/**\n * True when the REGULAR file at `probePath` is encrypted at rest (its first\n * bytes are the REMNIC-ENC magic header). ENOENT resolves to false — an absent\n * file has nothing to probe. A symlink, FIFO, device, or any other non-regular\n * path is REFUSED with a throw rather than opened: opening a FIFO blocks until a\n * writer appears and a symlink would redirect the probe outside our tree. The\n * ledgers and per-event spills we manage are always regular files, so a\n * non-regular path is an anomaly the caller must treat as unsafe, never follow\n * (#2033). Shared by the CLI ledger recovery probe and the auto-compaction probe\n * so both enforce identical open safety.\n */\nexport async function probeEncryptedRegularFileHeader(probePath: string): Promise<boolean> {\n  let entryStat;\n  try {\n    entryStat = await lstat(probePath);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) return false;\n    throw err;\n  }\n  if (!entryStat.isFile()) {\n    throw new Error(\n      `refusing to probe non-regular state path ${probePath} `\n      + `(symlink/FIFO/device); opening it could block or escape containment (#2033)`,\n    );\n  }\n  const handle = await openFile(probePath, \"r\");\n  try {\n    const header = Buffer.alloc(MAGIC_HEADER_SIZE);\n    const { bytesRead } = await handle.read(header, 0, header.length, 0);\n    return isEncryptedFile(header.subarray(0, bytesRead));\n  } finally {\n    await handle.close();\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Encrypt / decrypt file body\n// ---------------------------------------------------------------------------\n\n/**\n * Encrypt `plain` (UTF-8 content of a memory file) and return a\n * Buffer ready to write to disk.\n *\n * @param plain  Plain-text file content (UTF-8 string or Buffer).\n * @param key    32-byte AES-256 key from the keyring.\n * @param aad    Optional associated data — defaults to empty if omitted.\n *               Callers should pass the file path relative to memoryDir\n *               so the ciphertext is bound to its location.\n */\nexport function encryptFileBody(plain: string | Buffer, key: Buffer, aad?: Buffer): Buffer {\n  const plainBuf = typeof plain === \"string\" ? Buffer.from(plain, \"utf8\") : plain;\n  const salt = generateSalt();\n  const envelope = seal(key, salt, plainBuf, aad ? { aad } : {});\n\n  const header = Buffer.alloc(MAGIC_HEADER_SIZE);\n  MAGIC_BYTES.copy(header, 0);\n  header.writeUInt8(FILE_FORMAT_VERSION, MAGIC_BYTES.length);\n  header.writeUInt8(FILE_FORMAT_FLAGS, MAGIC_BYTES.length + 1);\n\n  return Buffer.concat([header, envelope]);\n}\n\n/**\n * Decrypt a buffer produced by `encryptFileBody` and return the\n * original UTF-8 content.\n *\n * Throws `SecureStoreDecryptError` on auth failure (wrong key or\n * tampered ciphertext). Throws a plain `Error` for structural problems\n * (truncated buffer, wrong magic, unsupported version).\n */\nexport function decryptFileBody(buf: Buffer, key: Buffer, aad?: Buffer): Buffer {\n  if (!isEncryptedFile(buf)) {\n    throw new Error(\"decryptFileBody: buffer does not start with REMNIC-ENC magic header\");\n  }\n  const version = buf.readUInt8(MAGIC_BYTES.length);\n  if (version !== FILE_FORMAT_VERSION) {\n    throw new Error(\n      `decryptFileBody: unsupported file format version ${version} (this build supports ${FILE_FORMAT_VERSION})`\n    );\n  }\n  const flags = buf.readUInt8(MAGIC_BYTES.length + 1);\n  if (flags !== FILE_FORMAT_FLAGS) {\n    throw new Error(`decryptFileBody: unknown flags byte 0x${flags.toString(16).padStart(2, \"0\")}`);\n  }\n  const envelope = buf.subarray(MAGIC_HEADER_SIZE);\n  parseEnvelope(envelope);\n  try {\n    return openEnvelope(key, envelope, aad ? { aad } : {});\n  } catch (err) {\n    const msg = err instanceof Error ? err.message : String(err);\n    throw new SecureStoreDecryptError(`secure-store decryption failed: ${msg}`);\n  }\n}\n\nfunction buildHeaderAad(salt: Uint8Array): Buffer {\n  const out = Buffer.alloc(1 + ENVELOPE_SALT_LENGTH);\n  out.writeUInt8(ENVELOPE_VERSION, 0);\n  Buffer.from(salt).copy(out, 1);\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Path → AAD helper\n// ---------------------------------------------------------------------------\n\n/**\n * Build the AAD buffer for a file at `filePath` relative to\n * `memoryDir`. The AAD binds the ciphertext to its path so a\n * file cannot be silently relocated without re-encryption.\n *\n * When `memoryDir` is supplied and `filePath` is absolute, the\n * relative sub-path is used. Otherwise `filePath` is used verbatim.\n */\nexport function filePathAad(filePath: string, memoryDir?: string): Buffer {\n  let rel = filePath;\n  if (memoryDir && path.isAbsolute(filePath)) {\n    rel = path.relative(memoryDir, filePath);\n  }\n  return Buffer.from(rel, \"utf8\");\n}\n\n// ---------------------------------------------------------------------------\n// High-level read / write helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Read a file from `filePath`.\n *\n * - If the file is plaintext (no magic header), return its content\n *   as-is — back-compat with unencrypted stores.\n * - If the file is encrypted AND `key` is provided, decrypt and return\n *   the plaintext content.\n * - If the file is encrypted AND `key` is null, throw\n *   `SecureStoreLockedError`.\n *\n * @param filePath  Absolute path to the file.\n * @param key       32-byte AES-256 key, or null when the store is locked.\n * @param memoryDir Memory root for path-bound AAD.  Should be absolute.\n */\nexport async function readMaybeEncryptedFileBuffer(\n  filePath: string,\n  key: Buffer | null,\n  memoryDir?: string\n): Promise<Buffer> {\n  const buf = await readFile(filePath);\n  if (!isEncryptedFile(buf)) {\n    // Plain file — legacy or unencrypted store.\n    return buf;\n  }\n  // Encrypted — key required.\n  if (key === null) {\n    throw new SecureStoreLockedError(\n      `secure-store is locked — cannot read encrypted file at ${filePath}. Run \\`remnic secure-store unlock\\` to decrypt.`\n    );\n  }\n  return decryptFileBodyForPath(buf, key, filePath, memoryDir);\n}\n\nexport async function readMaybeEncryptedFile(\n  filePath: string,\n  key: Buffer | null,\n  memoryDir?: string\n): Promise<string> {\n  return (await readMaybeEncryptedFileBuffer(filePath, key, memoryDir)).toString(\"utf8\");\n}\n\nexport interface WriteMaybeEncryptedFileOptions {\n  /**\n   * File mode bits. Default 0o600 (owner read/write only).\n   * Applied only on create; existing files inherit their existing mode.\n   */\n  mode?: number;\n  /**\n   * If true, write atomically via a temp file + rename (CLAUDE.md gotcha #54).\n   * Default true.\n   */\n  atomic?: boolean;\n}\n\n/**\n * Write `content` to `filePath`.\n *\n * - If `key` is provided and non-null, encrypt the content first.\n * - If `key` is null, write the content as plain UTF-8 (unencrypted store).\n *\n * Writes atomically: content is written to a unique temp file\n * first, then renamed into place (CLAUDE.md gotcha #54 — never delete\n * before write).\n */\nexport async function writeMaybeEncryptedFile(\n  filePath: string,\n  content: string | Buffer,\n  key: Buffer | null,\n  options: WriteMaybeEncryptedFileOptions = {},\n  memoryDir?: string\n): Promise<void> {\n  const { mode = 0o600, atomic = true } = options;\n  await mkdir(path.dirname(filePath), { recursive: true });\n\n  let data: Buffer | string;\n  if (key !== null) {\n    const aad = filePathAad(filePath, memoryDir);\n    data = encryptFileBody(content, key, aad);\n  } else {\n    data = content;\n  }\n\n  if (atomic) {\n    const tempPath = uniqueAtomicTempPath(filePath, \"tmp\");\n    try {\n      await writeFile(tempPath, data, { mode });\n      await rename(tempPath, filePath);\n    } catch (err) {\n      // Best-effort cleanup of the temp file.\n      try {\n        await unlink(tempPath);\n      } catch {\n        // ignore\n      }\n      throw err;\n    }\n  } else {\n    await writeFile(filePath, data, { mode });\n  }\n}\n\nexport async function writeMaybeEncryptedFileFromChunks(\n  filePath: string,\n  chunks: AsyncIterable<Buffer>,\n  key: Buffer | null,\n  options: WriteMaybeEncryptedFileOptions = {},\n  memoryDir?: string\n): Promise<void> {\n  const { mode = 0o600, atomic = true } = options;\n  await mkdir(path.dirname(filePath), { recursive: true });\n  const writePath = atomic ? `${filePath}.tmp-${process.pid}-${Date.now()}` : filePath;\n  let completed = false;\n  try {\n    const handle = await openFile(writePath, \"w\", mode);\n    try {\n      if (key !== null) {\n        const salt = generateSalt();\n        const iv = randomBytes(IV_LENGTH);\n        const header = Buffer.alloc(MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE);\n        MAGIC_BYTES.copy(header, 0);\n        header.writeUInt8(FILE_FORMAT_VERSION, MAGIC_BYTES.length);\n        header.writeUInt8(FILE_FORMAT_FLAGS, MAGIC_BYTES.length + 1);\n        const envelopeOffset = MAGIC_HEADER_SIZE;\n        header.writeUInt8(ENVELOPE_VERSION, envelopeOffset + ENVELOPE_LAYOUT.version);\n        salt.copy(header, envelopeOffset + ENVELOPE_LAYOUT.salt);\n        iv.copy(header, envelopeOffset + ENVELOPE_LAYOUT.iv);\n        await handle.write(header);\n\n        const cipher = createCipheriv(\"aes-256-gcm\", key, iv, { authTagLength: AUTH_TAG_LENGTH });\n        const aad = filePathAad(filePath, memoryDir);\n        cipher.setAAD(Buffer.concat([buildHeaderAad(salt), aad]));\n        for await (const chunk of chunks) {\n          if (chunk.length === 0) continue;\n          const encrypted = cipher.update(chunk);\n          if (encrypted.length > 0) await handle.write(encrypted);\n        }\n        const final = cipher.final();\n        if (final.length > 0) await handle.write(final);\n        const authTag = cipher.getAuthTag();\n        await handle.write(authTag, 0, authTag.length, MAGIC_HEADER_SIZE + ENVELOPE_LAYOUT.authTag);\n      } else {\n        for await (const chunk of chunks) {\n          if (chunk.length > 0) await handle.write(chunk);\n        }\n      }\n    } finally {\n      await handle.close();\n    }\n    if (atomic) {\n      await rename(writePath, filePath);\n    }\n    completed = true;\n  } finally {\n    if (!completed && atomic) {\n      await unlink(writePath).catch(() => {});\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Migration\n// ---------------------------------------------------------------------------\n\nexport interface MigrateResult {\n  /** Number of files successfully encrypted. */\n  encrypted: number;\n  /** Number of files already encrypted (skipped). */\n  skipped: number;\n  /** Files that failed to encrypt (path → error message). */\n  errors: Array<{ filePath: string; error: string }>;\n}\n\nexport interface DecryptResult {\n  /** Number of files successfully decrypted back to plaintext. */\n  decrypted: number;\n  /** Number of files already plaintext (skipped). */\n  skipped: number;\n  /** Files that failed to decrypt (path → error message). */\n  errors: Array<{ filePath: string; error: string }>;\n}\n\n/**\n * Walk `dir` recursively, find encryptable storage-managed files that are not\n * yet encrypted, and re-write them as encrypted files under `key`.\n *\n * Safety rules per CLAUDE.md gotchas #54 and #25:\n *   1. A page-version snapshot is taken (via `createVersion`) BEFORE\n *      each overwrite so the plaintext version is preserved in history.\n *      Since this module has no direct access to `page-versioning.ts`\n *      internals, callers who have page-versioning configured should\n *      pass `onBeforeEncrypt` to take the snapshot.\n *   2. The new encrypted content is written to a temp file first,\n *      then renamed atomically — never deleted before written.\n *   3. If encryption of any file fails, the error is recorded and the\n *      original file is left intact (partial migration is safe).\n *\n * @param dir              Absolute path to the memory directory.\n * @param key              32-byte AES-256 key.\n * @param onBeforeEncrypt  Optional callback invoked before encrypting\n *                         each file. Can be used to take page-version\n *                         snapshots. Errors here are non-fatal.\n */\nexport async function migrateMemoryDirToEncrypted(\n  dir: string,\n  key: Buffer,\n  onBeforeEncrypt?: (filePath: string) => Promise<void>\n): Promise<MigrateResult> {\n  const result: MigrateResult = { encrypted: 0, skipped: 0, errors: [] };\n\n  const files = await collectEncryptableStorageFiles(dir);\n  for (const filePath of files) {\n    try {\n      const buf = await readFile(filePath);\n      if (isEncryptedFile(buf)) {\n        result.skipped++;\n        continue;\n      }\n      // Call optional pre-encryption hook (e.g. page-version snapshot).\n      if (onBeforeEncrypt) {\n        try {\n          await onBeforeEncrypt(filePath);\n        } catch {\n          // Non-fatal — continue with encryption even if snapshot fails.\n        }\n      }\n      const content = buf.toString(\"utf8\");\n      const aad = filePathAad(filePath, dir);\n      const encrypted = encryptFileBody(content, key, aad);\n\n      // Atomic write: temp → rename (gotcha #54).\n      const tempPath = uniqueAtomicTempPath(filePath, \"enc-tmp\");\n      try {\n        await writeFile(tempPath, encrypted, { mode: 0o600 });\n        await rename(tempPath, filePath);\n        result.encrypted++;\n      } catch (writeErr) {\n        // Clean up temp file, leave original intact.\n        try {\n          const { unlink } = await import(\"node:fs/promises\");\n          await unlink(tempPath);\n        } catch {\n          // ignore\n        }\n        throw writeErr;\n      }\n    } catch (err) {\n      result.errors.push({\n        filePath,\n        error: err instanceof Error ? err.message : String(err),\n      });\n    }\n  }\n\n  return result;\n}\n\n/**\n * Walk `dir` recursively, find storage-managed encrypted files, and\n * re-write them as plaintext under the same paths.\n *\n * This is the reversible counterpart to {@link migrateMemoryDirToEncrypted}.\n * It only touches files under the same storage-managed roots, skips\n * plaintext files, skips symlinks, excludes `.secure-store/`, and writes\n * each plaintext replacement via temp-file + rename so a per-file failure\n * leaves the ciphertext intact.\n */\nexport async function decryptMemoryDirToPlaintext(dir: string, key: Buffer): Promise<DecryptResult> {\n  const result: DecryptResult = { decrypted: 0, skipped: 0, errors: [] };\n\n  const files = await collectStorageManagedFiles(dir, isDecryptableStoragePath);\n  for (const filePath of files) {\n    try {\n      const buf = await readFile(filePath);\n      if (!isEncryptedFile(buf)) {\n        result.skipped++;\n        continue;\n      }\n\n      const plaintext = decryptFileBodyForPath(buf, key, filePath, dir);\n      const tempPath = uniqueAtomicTempPath(filePath, \"dec-tmp\");\n      try {\n        await writeFile(tempPath, plaintext, { mode: 0o600 });\n        await rename(tempPath, filePath);\n        result.decrypted++;\n      } catch (writeErr) {\n        try {\n          await unlink(tempPath);\n        } catch {\n          // ignore cleanup errors; original ciphertext is still intact.\n        }\n        throw writeErr;\n      }\n    } catch (err) {\n      result.errors.push({\n        filePath,\n        error: err instanceof Error ? err.message : String(err),\n      });\n    }\n  }\n\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction uniqueAtomicTempPath(filePath: string, label: string): string {\n  return `${filePath}.${label}-${process.pid}-${Date.now()}-${randomUUID()}`;\n}\n\nfunction decryptFileBodyForPath(buf: Buffer, key: Buffer, filePath: string, memoryDir?: string): Buffer {\n  const aad = filePathAad(filePath, memoryDir);\n  try {\n    return decryptFileBody(buf, key, aad);\n  } catch (err) {\n    if (!(err instanceof SecureStoreDecryptError)) {\n      throw err;\n    }\n    const legacyRoot = legacyNamespaceAadRootForFile(filePath, memoryDir);\n    if (legacyRoot) {\n      try {\n        return decryptFileBody(buf, key, filePathAad(filePath, legacyRoot));\n      } catch {\n        // Fall through to the namespace-reader fallback below.\n      }\n    }\n\n    const topLevelRoot = topLevelAadRootForNamespaceReader(filePath, memoryDir);\n    if (topLevelRoot) {\n      try {\n        return decryptFileBody(buf, key, filePathAad(filePath, topLevelRoot));\n      } catch {\n        // Preserve the caller-facing error from the canonical decrypt attempt.\n      }\n    }\n\n    throw err;\n  }\n}\n\nfunction topLevelAadRootForNamespaceReader(filePath: string, memoryDir?: string): string | null {\n  if (!memoryDir || !path.isAbsolute(filePath)) return null;\n  const resolvedMemoryDir = path.resolve(memoryDir);\n  const rel = path.relative(resolvedMemoryDir, filePath);\n  if (rel === \"\" || rel.startsWith(\"..\") || path.isAbsolute(rel)) return null;\n  const parts = resolvedMemoryDir.split(path.sep);\n  if (parts.length < 3 || parts.at(-2) !== \"namespaces\" || !parts.at(-1)) return null;\n  const topLevelRoot = parts.slice(0, -2).join(path.sep) || path.sep;\n  const topRel = path.relative(topLevelRoot, filePath);\n  if (topRel === \"\" || topRel.startsWith(\"..\") || path.isAbsolute(topRel)) {\n    return null;\n  }\n  const topParts = topRel.split(path.sep);\n  if (topParts[0] !== \"namespaces\" || topParts[1] !== parts.at(-1)) {\n    return null;\n  }\n  return topLevelRoot;\n}\n\nfunction legacyNamespaceAadRootForFile(filePath: string, memoryDir?: string): string | null {\n  if (!memoryDir || !path.isAbsolute(filePath)) return null;\n  const rel = path.relative(memoryDir, filePath);\n  if (rel === \"\" || rel.startsWith(\"..\") || path.isAbsolute(rel)) return null;\n  const parts = rel.split(path.sep);\n  if (parts[0] === \"namespaces\" && parts.length >= 3 && parts[1]) {\n    return path.join(memoryDir, \"namespaces\", parts[1]);\n  }\n  return null;\n}\n\n/**\n * Recursively collect files under `dir` that are read through the\n * storage-layer secure-store helpers, excluding symlinked entries and\n * `.secure-store/` metadata.\n */\nasync function collectEncryptableStorageFiles(dir: string, rootDir = dir): Promise<string[]> {\n  return collectStorageManagedFiles(dir, isEncryptableStoragePath, rootDir);\n}\n\n/**\n * Recursively collect regular files under storage-managed roots, excluding\n * symlinked entries and `.secure-store/` metadata. This broader collector is\n * used by the decrypt/disable path so future encrypted sidecars can be\n * restored without requiring extension-specific logic.\n */\nasync function collectStorageManagedFiles(\n  dir: string,\n  includeFile: (filePath: string, rootDir: string) => boolean,\n  rootDir = dir\n): Promise<string[]> {\n  const results: string[] = [];\n  let scanDir = dir;\n  let scanRootDir = rootDir;\n  if (path.resolve(dir) === path.resolve(rootDir)) {\n    const normalizedRoot = await resolveStorageManagedRootForScan(dir);\n    if (!normalizedRoot) return results;\n    scanDir = normalizedRoot;\n    scanRootDir = normalizedRoot;\n  }\n  let names: string[];\n  try {\n    names = await readdir(scanDir, { encoding: \"utf8\" });\n  } catch {\n    return results;\n  }\n  for (const name of names) {\n    if (name.startsWith(\".secure-store\")) continue;\n    const full = path.join(scanDir, name);\n    let isDir = false;\n    let isFile = false;\n    try {\n      const s = await lstat(full);\n      if (s.isSymbolicLink()) continue;\n      isDir = s.isDirectory();\n      isFile = s.isFile();\n    } catch {\n      continue;\n    }\n    if (isDir) {\n      const sub = await collectStorageManagedFiles(full, includeFile, scanRootDir);\n      results.push(...sub);\n    } else if (isFile && includeFile(full, scanRootDir)) {\n      results.push(full);\n    }\n  }\n  return results;\n}\n\nasync function resolveStorageManagedRootForScan(dir: string): Promise<string | null> {\n  const lstatPath = normalizePathForLstat(dir);\n  let stat: Awaited<ReturnType<typeof lstat>>;\n  try {\n    stat = await lstat(lstatPath);\n  } catch (error) {\n    if (isFsErrorWithCode(error, \"ENOENT\")) return null;\n    throw error;\n  }\n  if (stat.isSymbolicLink()) {\n    throw new Error(`secure-store migration root must not be a symlink: ${dir}`);\n  }\n  if (!stat.isDirectory()) {\n    throw new Error(`secure-store migration root must be a directory: ${dir}`);\n  }\n  return lstatPath;\n}\n\nfunction normalizePathForLstat(filePath: string): string {\n  return stripTrailingPathSeparators(path.normalize(filePath));\n}\n\nfunction isFsErrorWithCode(error: unknown, code: string): boolean {\n  return typeof error === \"object\" && error !== null && (error as { code?: unknown }).code === code;\n}\n\nfunction stripTrailingPathSeparators(filePath: string): string {\n  const root = path.parse(filePath).root;\n  let end = filePath.length;\n  while (\n    end > root.length &&\n    (filePath[end - 1] === path.sep || filePath[end - 1] === path.posix.sep || filePath[end - 1] === path.win32.sep)\n  ) {\n    end -= 1;\n  }\n  return end === filePath.length ? filePath : filePath.slice(0, end);\n}\n\nfunction isEncryptableStoragePath(filePath: string, rootDir: string): boolean {\n  const rel = path.relative(rootDir, filePath);\n  if (rel === \"\" || rel.startsWith(\"..\") || path.isAbsolute(rel)) return false;\n  const normalized = normalizeStorageRelativePath(rel);\n  if (normalized === \"profile.md\") return true;\n  if (isEncryptableStateSidecar(normalized)) return true;\n  if (isEncryptableSummarySidecar(normalized)) return true;\n  const firstSegment = normalized.split(\"/\", 1)[0];\n  return ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS.has(firstSegment) && normalized.endsWith(\".md\");\n}\n\nfunction isDecryptableStoragePath(filePath: string, rootDir: string): boolean {\n  if (isEncryptableStoragePath(filePath, rootDir)) return true;\n  const rel = path.relative(rootDir, filePath);\n  if (rel === \"\" || rel.startsWith(\"..\") || path.isAbsolute(rel)) return false;\n  const normalized = normalizeStorageRelativePath(rel);\n  const firstSegment = normalized.split(\"/\", 1)[0];\n  return DECRYPTABLE_SIDECAR_ROOTS.has(firstSegment);\n}\n\nfunction normalizeStorageRelativePath(rel: string): string {\n  const normalized = rel.split(path.sep).join(\"/\");\n  const parts = normalized.split(\"/\");\n  if (parts[0] === \"namespaces\" && parts.length >= 3) {\n    return parts.slice(2).join(\"/\");\n  }\n  return normalized;\n}\n\n// Every recall MEMORY category directory (facts/ + the CATEGORY_DIR_MAP memory\n// dirs) must be encryptable at rest — #1546 routes decision/preference/moment/...\n// memories into their own dirs, so hardcoding only facts/corrections/procedures/\n// reasoning-traces would silently write those categories in plaintext on\n// encrypted stores. RECALL_FALLBACK_DIRS is the single source of truth for that\n// set; the extra non-category markdown roots (artifacts/archive/entities/\n// identity) are appended.\n//\n// questions/ is deliberately EXCLUDED (RECALL_FALLBACK_DIRS omits the non-memory\n// queue dirs): the question queue is written/resolved through plain readFile/\n// writeFile (StorageManager.writeQuestion/resolveQuestion), NOT the secure-file\n// helpers. Encrypting questions/ here would make migration seal those files,\n// after which resolveQuestion() would read ciphertext as UTF-8, fail to update\n// the frontmatter, and overwrite/corrupt the file while returning success\n// (codex #1563 review). Keeping questions/ plaintext preserves the queue's\n// existing behavior; #1546 does not change question encryption.\nconst ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS = new Set<string>([\n  ...RECALL_FALLBACK_DIRS,\n  \"artifacts\",\n  \"archive\",\n  \"entities\",\n  \"identity\",\n]);\n\nconst ENCRYPTABLE_STATE_SIDECARS = new Set([\n  \"state/behavior-signals.jsonl\",\n  \"state/buffer-surprise-ledger.jsonl\",\n  \"state/buffer.json\",\n  \"state/compression-guideline-draft-state.json\",\n  \"state/compression-guideline-state.json\",\n  \"state/compression-guidelines.draft.md\",\n  \"state/compression-guidelines.md\",\n  \"state/entity-synthesis-queue.json\",\n  \"state/fact-hashes.txt\",\n  \"state/memory-actions.jsonl\",\n  \"state/memory-lifecycle-ledger.jsonl\",\n  \"state/meta.json\",\n  \"state/reextract-jobs.jsonl\",\n  \"state/topics.json\",\n]);\n\nfunction isEncryptableStateSidecar(normalized: string): boolean {\n  return ENCRYPTABLE_STATE_SIDECARS.has(normalized);\n}\n\nfunction isEncryptableSummarySidecar(normalized: string): boolean {\n  return normalized.startsWith(\"summaries/\") && normalized.endsWith(\".json\");\n}\n\nconst DECRYPTABLE_SIDECAR_ROOTS = new Set([\"state\", \"indexes\", \"index\", \"provenance\"]);\n"],"mappings":"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","names":["unlink"]}

package/dist/{chunk-OKUEZOGW.js → chunk-AITCS2RC.js}

@@ -1,6 +1,6 @@
 import {
   invalidateDerivedAndGlobalForDir
-} from "./chunk-X47LWMKA.js";
+} from "./chunk-XMMESCPD.js";
 import {
   deleteInFlightReadsForDir
 } from "./chunk-PDJTHRAW.js";
@@ -24,4 +24,4 @@ export {
   MEMORY_CORPUS_VERSION_SENTINEL,
   bumpMemoryCorpusVersionForDir
 };
-//# sourceMappingURL=chunk-OKUEZOGW.js.map
+//# sourceMappingURL=chunk-AITCS2RC.js.map

package/dist/{chunk-OC35KQIN.js → chunk-AJ7QCSIS.js}

@@ -1,16 +1,16 @@
 import {
   createVersion
-} from "./chunk-VZ5OJE4X.js";
+} from "./chunk-5VQJBH2G.js";
 import {
   bumpMemoryCorpusVersionForDir
-} from "./chunk-OKUEZOGW.js";
+} from "./chunk-AITCS2RC.js";
 import {
   parseExportBundle
 } from "./chunk-WEHSQBFR.js";
 import {
   decryptCapsuleFileInMemory,
   isEncryptedCapsuleFile
-} from "./chunk-437S3G37.js";
+} from "./chunk-DQEMWVMT.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot,
@@ -231,4 +231,4 @@ function mintForkId(capsuleId, originalId, now) {
 export {
   importCapsule
 };
-//# sourceMappingURL=chunk-OC35KQIN.js.map
+//# sourceMappingURL=chunk-AJ7QCSIS.js.map

package/dist/{chunk-FNMFJWBY.js → chunk-ANEUPF6O.js}

@@ -9,13 +9,13 @@ import {
   resolveLocalLlmCapabilities,
   resolveMemoryLifecycleCapabilities,
   resolvePipelineProcessingCapabilities
-} from "./chunk-BFPETA3S.js";
-import {
-  log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-SCCO46KZ.js";
 import {
   isAbortError
 } from "./chunk-PVGDJXVK.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
 
 // src/search/embed-helper.ts
 var DEFAULT_OPENAI_MODEL = "text-embedding-3-small";
@@ -310,4 +310,4 @@ function normalizeHttpEmbeddingVector(vector) {
 export {
   EmbedHelper
 };
-//# sourceMappingURL=chunk-FNMFJWBY.js.map
+//# sourceMappingURL=chunk-ANEUPF6O.js.map

package/dist/chunk-AREGMX2J.js

@@ -0,0 +1,50 @@
+// src/offline-sync-exclude-globs.ts
+var OFFLINE_DECRYPT_STAGING_DIR_PREFIX = ".remnic-offline-decrypt-";
+var DEFAULT_OFFLINE_SYNC_EXCLUDE_GLOBS = [
+  // Leading `**/` matches zero or more segments, so each pattern covers both
+  // the root `state/` dir AND per-namespace `namespaces/<ns>/state/` dirs
+  // (Cursor review on PR #1793: multi-namespace deployments previously kept
+  // pushing their namespaced live sqlite files).
+  "**/state/*.sqlite",
+  "**/state/*.sqlite-*",
+  "**/state/index_tags.json",
+  "**/state/entity-mention-index.json",
+  "**/state/memory-governance/runs/**",
+  // Rotated recall-impression archives (issue #1910). The active
+  // recall_impressions.jsonl stays remote-authoritative; only the .1..N
+  // archives and the .lock are node-local and never pushed/hashed.
+  "**/state/recall_impressions.jsonl.*",
+  // Durable recall-impression pending spill directory (issue #2033). Node-local:
+  // an impression spills a per-event file here when its rotation lock cannot be
+  // acquired, and the next lock holder folds them back into the synced active
+  // recall_impressions.jsonl. The `.*` glob above matches the directory name but
+  // not its children, so exclude the contents explicitly.
+  "**/state/recall_impressions.jsonl.pending.d/**",
+  // Durable lifecycle-append pending spill directory (issue #2033). Node-local:
+  // an append spills a per-event file here when it cannot get the ledger lock,
+  // and the next lock holder folds them back into the synced
+  // memory-lifecycle-ledger.jsonl. Pushing them would duplicate rows remotely.
+  // The offline-sync snapshot entrypoints drain this queue first (access-service
+  // `drainPendingLifecycleForSync` -> `StorageManager.drainPendingMemoryLifecycleEventsForSync`),
+  // aborting the snapshot when durable rows cannot be folded, so excluding the
+  // dir never silently drops append-only lifecycle history (promotions/imports).
+  "**/state/memory-lifecycle-ledger.jsonl.pending.d/**",
+  // The active lifecycle ledger lock is node-local and must never be
+  // transferred to another node during an offline snapshot.
+  "**/state/memory-lifecycle-ledger.jsonl.lock",
+  // Transient plaintext decrypt staging (issue #2033 P1). The CLI offline
+  // decrypt path materializes a decrypted secure-store file under an owner-only
+  // `<OFFLINE_DECRYPT_STAGING_DIR_PREFIX>*` dir before hashing/pushing, removing
+  // it in a `finally`. A hard crash between create and cleanup would otherwise
+  // let a later snapshot walk `<prefix>*/content` and push decrypted secure-store
+  // plaintext to the remote. Exclude the dir and its contents unconditionally so
+  // a crash-orphan can never be enumerated into a snapshot; the leading `**/`
+  // matches the root-level dir (zero segments) and any nested placement.
+  "**/.remnic-offline-decrypt-*/**"
+];
+
+export {
+  OFFLINE_DECRYPT_STAGING_DIR_PREFIX,
+  DEFAULT_OFFLINE_SYNC_EXCLUDE_GLOBS
+};
+//# sourceMappingURL=chunk-AREGMX2J.js.map

package/dist/chunk-AREGMX2J.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/offline-sync-exclude-globs.ts"],"sourcesContent":["// Issue #1786: node-local runtime state that each node rebuilds from synced\n// records. Pushing these wastes bandwidth, corrupts the remote's live state\n// dir, and trips the large-file push retry loop on a live SQLite database.\n// Extracted from offline-sync.ts (issue #1995) so the god-file line-count\n// ratchet does not grow when the list gains entries; behavior is unchanged.\n/**\n * Directory-name prefix for the transient plaintext staging dir the CLI offline\n * decrypt path (`offline-storage-io.ts`) creates under the memory root when it\n * must materialize a decrypted secure-store file before hashing/pushing (#2033\n * P1). Shared here so the hard-exclude glob below and the CLI's `mkdtemp` prefix\n * can never drift apart: a crash-orphaned staging dir must NEVER be enumerated\n * into an offline snapshot, or decrypted secure-store plaintext would leak into\n * the remote push.\n */\nexport const OFFLINE_DECRYPT_STAGING_DIR_PREFIX = \".remnic-offline-decrypt-\";\n\nexport const DEFAULT_OFFLINE_SYNC_EXCLUDE_GLOBS: readonly string[] = [\n  // Leading `**/` matches zero or more segments, so each pattern covers both\n  // the root `state/` dir AND per-namespace `namespaces/<ns>/state/` dirs\n  // (Cursor review on PR #1793: multi-namespace deployments previously kept\n  // pushing their namespaced live sqlite files).\n  \"**/state/*.sqlite\",\n  \"**/state/*.sqlite-*\",\n  \"**/state/index_tags.json\",\n  \"**/state/entity-mention-index.json\",\n  \"**/state/memory-governance/runs/**\",\n  // Rotated recall-impression archives (issue #1910). The active\n  // recall_impressions.jsonl stays remote-authoritative; only the .1..N\n  // archives and the .lock are node-local and never pushed/hashed.\n  \"**/state/recall_impressions.jsonl.*\",\n  // Durable recall-impression pending spill directory (issue #2033). Node-local:\n  // an impression spills a per-event file here when its rotation lock cannot be\n  // acquired, and the next lock holder folds them back into the synced active\n  // recall_impressions.jsonl. The `.*` glob above matches the directory name but\n  // not its children, so exclude the contents explicitly.\n  \"**/state/recall_impressions.jsonl.pending.d/**\",\n  // Durable lifecycle-append pending spill directory (issue #2033). Node-local:\n  // an append spills a per-event file here when it cannot get the ledger lock,\n  // and the next lock holder folds them back into the synced\n  // memory-lifecycle-ledger.jsonl. Pushing them would duplicate rows remotely.\n  // The offline-sync snapshot entrypoints drain this queue first (access-service\n  // `drainPendingLifecycleForSync` -> `StorageManager.drainPendingMemoryLifecycleEventsForSync`),\n  // aborting the snapshot when durable rows cannot be folded, so excluding the\n  // dir never silently drops append-only lifecycle history (promotions/imports).\n  \"**/state/memory-lifecycle-ledger.jsonl.pending.d/**\",\n  // The active lifecycle ledger lock is node-local and must never be\n  // transferred to another node during an offline snapshot.\n  \"**/state/memory-lifecycle-ledger.jsonl.lock\",\n  // Transient plaintext decrypt staging (issue #2033 P1). The CLI offline\n  // decrypt path materializes a decrypted secure-store file under an owner-only\n  // `<OFFLINE_DECRYPT_STAGING_DIR_PREFIX>*` dir before hashing/pushing, removing\n  // it in a `finally`. A hard crash between create and cleanup would otherwise\n  // let a later snapshot walk `<prefix>*/content` and push decrypted secure-store\n  // plaintext to the remote. Exclude the dir and its contents unconditionally so\n  // a crash-orphan can never be enumerated into a snapshot; the leading `**/`\n  // matches the root-level dir (zero segments) and any nested placement.\n  \"**/.remnic-offline-decrypt-*/**\",\n];\n"],"mappings":";AAcO,IAAM,qCAAqC;AAE3C,IAAM,qCAAwD;AAAA;AAAA;AAAA;AAAA;AAAA,EAKnE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA;AAAA;AAAA;AAAA,EAGA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA;AACF;","names":[]}