@remnic/core 1.1.2 → 1.1.4

package/dist/chunk-IXEJRKCZ.js

@@ -0,0 +1,18 @@
+import {
+  resolveHomeDir
+} from "./chunk-MARWOCVP.js";
+
+// src/utils/path.ts
+import path from "path";
+function expandTildePath(p) {
+  if (p === "~") return resolveHomeDir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return path.join(resolveHomeDir(), p.slice(2));
+  }
+  return p;
+}
+
+export {
+  expandTildePath
+};
+//# sourceMappingURL=chunk-IXEJRKCZ.js.map

package/dist/chunk-IXEJRKCZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/path.ts"],"sourcesContent":["/**\n * Shared path helpers. CLAUDE.md #17 requires consistent `~` expansion across\n * every user-facing path input, but Node's `fs` does not expand `~`, so every\n * call site must go through this helper.\n */\n\nimport path from \"node:path\";\n\nimport { resolveHomeDir } from \"../runtime/env.js\";\n\n/**\n * Expand a leading `~` or `~/…` to the resolved home directory.\n *\n * Leaves paths without a leading `~` unchanged — including absolute paths,\n * relative paths, and paths that contain `~` in the middle.\n *\n * Accepts both `~/` (POSIX) and `~\\` (Windows) as separators so call sites\n * don't have to branch on platform.\n */\nexport function expandTildePath(p: string): string {\n  if (p === \"~\") return resolveHomeDir();\n  if (p.startsWith(\"~/\") || p.startsWith(\"~\\\\\")) {\n    return path.join(resolveHomeDir(), p.slice(2));\n  }\n  return p;\n}\n"],"mappings":";;;;;AAMA,OAAO,UAAU;AAaV,SAAS,gBAAgB,GAAmB;AACjD,MAAI,MAAM,IAAK,QAAO,eAAe;AACrC,MAAI,EAAE,WAAW,IAAI,KAAK,EAAE,WAAW,KAAK,GAAG;AAC7C,WAAO,KAAK,KAAK,eAAe,GAAG,EAAE,MAAM,CAAC,CAAC;AAAA,EAC/C;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-IYY4MCPG.js

@@ -0,0 +1,275 @@
+import {
+  listFilesRecursive,
+  sha256File,
+  toPosixRelPath,
+  writeJsonFile
+} from "./chunk-457A4P3L.js";
+import {
+  CAPSULE_ID_PATTERN,
+  CapsuleBlockSchema,
+  ExportBundleV2Schema,
+  ExportManifestV2Schema
+} from "./chunk-OA3L7BFR.js";
+import {
+  encryptCapsuleFile
+} from "./chunk-KNKUID7G.js";
+
+// src/transfer/capsule-export.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import path from "path";
+import { gzipSync } from "zlib";
+
+// src/transfer/constants.ts
+var EXPORT_FORMAT = "openclaw-engram-export";
+var EXPORT_SCHEMA_VERSION = 1;
+var CAPSULE_SCHEMA_VERSION = 2;
+
+// src/transfer/capsule-export.ts
+var DEFAULT_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  // Never export the secure-store directory: it contains the encryption
+  // header (KDF params + verifier) which is security-sensitive and
+  // machine-specific. The passphrase is not stored here, but including
+  // the header in a capsule would let an attacker brute-force the
+  // passphrase offline if the capsule is intercepted.
+  ".secure-store",
+  // Exclude .capsules to avoid recursive self-inclusion.
+  ".capsules"
+]);
+var TRANSCRIPTS_DIR = "transcripts";
+var PEERS_DIR = "peers";
+async function exportCapsule(opts) {
+  validateName(opts.name);
+  const sinceMs = parseSince(opts.since);
+  const includeKinds = normalizeIncludeKinds(opts.includeKinds);
+  const peerFilter = normalizePeerIds(opts.peerIds);
+  const transcriptsOverride = opts.includeTranscripts === true;
+  const rootAbs = path.resolve(opts.root);
+  await assertIsDirectory(rootAbs);
+  const outDirAbs = path.resolve(opts.outDir ?? path.join(rootAbs, ".capsules"));
+  if (outDirAbs === rootAbs) {
+    throw new Error(
+      "exportCapsule: 'outDir' must not equal 'root'. Choose a separate directory (default: <root>/.capsules) so the export does not overwrite or shadow the source tree."
+    );
+  }
+  await mkdir(outDirAbs, { recursive: true });
+  const outDirRelPosix = computeOutDirRel(rootAbs, outDirAbs);
+  const filesAbs = await listFilesRecursive(rootAbs);
+  const records = [];
+  const manifestFiles = [];
+  for (const abs of filesAbs) {
+    const relPosix = toPosixRelPath(abs, rootAbs);
+    if (!shouldInclude(relPosix, includeKinds, peerFilter, outDirRelPosix, transcriptsOverride)) continue;
+    if (sinceMs !== null) {
+      const st = await stat(abs);
+      if (st.mtimeMs < sinceMs) continue;
+    }
+    const content = await readFile(abs, "utf-8");
+    records.push({ path: relPosix, content });
+    const { sha256, bytes } = await sha256File(abs);
+    manifestFiles.push({ path: relPosix, sha256, bytes });
+  }
+  records.sort((a, b) => a.path.localeCompare(b.path));
+  manifestFiles.sort((a, b) => a.path.localeCompare(b.path));
+  const capsule = buildCapsuleBlock(opts.name, opts.capsule);
+  const includesTranscripts = transcriptsOverride || (includeKinds ?? /* @__PURE__ */ new Set()).has(TRANSCRIPTS_DIR);
+  const createdAtMs = opts.now ?? Date.now();
+  const manifest = ExportManifestV2Schema.parse({
+    format: EXPORT_FORMAT,
+    schemaVersion: CAPSULE_SCHEMA_VERSION,
+    createdAt: new Date(createdAtMs).toISOString(),
+    pluginVersion: opts.pluginVersion ?? "0.0.0",
+    includesTranscripts,
+    files: manifestFiles,
+    capsule
+  });
+  const bundle = ExportBundleV2Schema.parse({
+    manifest,
+    records
+  });
+  const archivePath = path.join(outDirAbs, `${opts.name}.capsule.json.gz`);
+  const manifestPath = path.join(outDirAbs, `${opts.name}.manifest.json`);
+  await writeJsonFile(manifestPath, manifest);
+  const json = JSON.stringify(bundle);
+  const gz = gzipSync(Buffer.from(json, "utf-8"));
+  await writeFile(archivePath, gz);
+  if (opts.encrypt === true) {
+    if (!opts.memoryDir) {
+      throw new Error(
+        "exportCapsule: 'memoryDir' is required when 'encrypt' is true so the secure-store key can be retrieved."
+      );
+    }
+    const { encPath } = await encryptCapsuleFile({
+      sourceGzPath: archivePath,
+      memoryDir: opts.memoryDir
+    });
+    const { unlink } = await import("fs/promises");
+    await unlink(archivePath);
+    return { archivePath: encPath, manifestPath, manifest, encryptedArchivePath: encPath };
+  }
+  return { archivePath, manifestPath, manifest, encryptedArchivePath: null };
+}
+function validateName(name) {
+  if (typeof name !== "string" || !CAPSULE_ID_PATTERN.test(name)) {
+    throw new Error(
+      `exportCapsule: invalid capsule name. Expected /${CAPSULE_ID_PATTERN.source}/`
+    );
+  }
+  if (name.length > 64) {
+    throw new Error(
+      "exportCapsule: invalid capsule name. Must be 64 characters or fewer."
+    );
+  }
+}
+var ISO_8601_RE = /^\d{4}-\d{2}-\d{2}(?:[Tt]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:[Zz]|[+-]\d{2}:?\d{2}))?$/;
+function parseSince(since) {
+  if (since === void 0) return null;
+  if (typeof since !== "string" || since.trim() === "") {
+    throw new Error("exportCapsule: 'since' must be a non-empty ISO-8601 string");
+  }
+  if (!ISO_8601_RE.test(since)) {
+    throw new Error(
+      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
+    );
+  }
+  const ms = Date.parse(since);
+  if (!Number.isFinite(ms)) {
+    throw new Error(
+      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
+    );
+  }
+  assertCalendarRoundTrip(since, ms);
+  return ms;
+}
+function isValidCapsuleSince(since) {
+  try {
+    parseSince(since);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertCalendarRoundTrip(since, ms) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(since);
+  if (!m) return;
+  const wantY = Number(m[1]);
+  const wantMo = Number(m[2]);
+  const wantD = Number(m[3]);
+  const offsetMatch = /([+-])(\d{2}):?(\d{2})$/.exec(since);
+  let displayMs = ms;
+  if (offsetMatch) {
+    const sign = offsetMatch[1] === "-" ? -1 : 1;
+    const offsetMin = sign * (Number(offsetMatch[2]) * 60 + Number(offsetMatch[3]));
+    displayMs = ms + offsetMin * 6e4;
+  }
+  const dd = new Date(displayMs);
+  const gotY = dd.getUTCFullYear();
+  const gotMo = dd.getUTCMonth() + 1;
+  const gotD = dd.getUTCDate();
+  if (gotY !== wantY || gotMo !== wantMo || gotD !== wantD) {
+    throw new Error(
+      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
+    );
+  }
+}
+function normalizeIncludeKinds(kinds) {
+  if (kinds === void 0) return null;
+  const set = /* @__PURE__ */ new Set();
+  for (const raw of kinds) {
+    if (typeof raw !== "string" || raw.trim() === "") {
+      throw new Error("exportCapsule: 'includeKinds' entries must be non-empty strings");
+    }
+    if (raw.includes("/") || raw.includes("\\")) {
+      throw new Error(
+        `exportCapsule: 'includeKinds' entries must be top-level segment names, got: ${raw}`
+      );
+    }
+    set.add(raw);
+  }
+  return set;
+}
+function normalizePeerIds(peerIds) {
+  if (peerIds === void 0) return null;
+  const set = /* @__PURE__ */ new Set();
+  for (const raw of peerIds) {
+    if (typeof raw !== "string" || raw.trim() === "") {
+      throw new Error("exportCapsule: 'peerIds' entries must be non-empty strings");
+    }
+    if (raw.includes("/") || raw.includes("\\") || raw === "." || raw === "..") {
+      throw new Error(
+        `exportCapsule: 'peerIds' entries must be plain segment names, got: ${raw}`
+      );
+    }
+    set.add(raw);
+  }
+  return set;
+}
+function computeOutDirRel(rootAbs, outDirAbs) {
+  const rel = path.relative(rootAbs, outDirAbs);
+  if (rel === "") return null;
+  if (rel === ".." || rel.startsWith(`..${path.sep}`)) return null;
+  if (path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join("/");
+}
+async function assertIsDirectory(absPath) {
+  const st = await stat(absPath).catch(() => null);
+  if (!st || !st.isDirectory()) {
+    throw new Error(
+      `exportCapsule: 'root' must be an existing directory: ${absPath}`
+    );
+  }
+}
+function shouldInclude(relPosix, includeKinds, peerFilter, outDirRelPosix, transcriptsOverride = false) {
+  const parts = relPosix.split("/");
+  if (parts.some((p) => DEFAULT_EXCLUDE_DIRS.has(p))) return false;
+  if (outDirRelPosix !== null) {
+    if (relPosix === outDirRelPosix) return false;
+    if (relPosix.startsWith(`${outDirRelPosix}/`)) return false;
+  }
+  const top = parts[0];
+  if (top === TRANSCRIPTS_DIR && !transcriptsOverride && (includeKinds === null || !includeKinds.has(TRANSCRIPTS_DIR))) {
+    return false;
+  }
+  if (includeKinds !== null) {
+    if (parts.length < 2) return false;
+    if (!includeKinds.has(top)) return false;
+  }
+  if (top === PEERS_DIR && peerFilter !== null) {
+    if (peerFilter.size === 0) return false;
+    if (parts.length < 2) return false;
+    if (!peerFilter.has(parts[1])) return false;
+  }
+  return true;
+}
+function buildCapsuleBlock(name, override) {
+  const parent = override?.parent ?? null;
+  const parentCapsule = override && Object.prototype.hasOwnProperty.call(override, "parentCapsule") ? override.parentCapsule ?? null : parent?.capsuleId ?? null;
+  const merged = {
+    id: name,
+    version: override?.version ?? "0.1.0",
+    schemaVersion: override?.schemaVersion ?? "taxonomy-v1",
+    parentCapsule,
+    parent,
+    description: override?.description ?? "",
+    retrievalPolicy: override?.retrievalPolicy ?? {
+      tierWeights: {},
+      directAnswerEnabled: false
+    },
+    includes: override?.includes ?? {
+      taxonomy: false,
+      identityAnchors: false,
+      peerProfiles: false,
+      procedural: false
+    }
+  };
+  return CapsuleBlockSchema.parse(merged);
+}
+
+export {
+  EXPORT_FORMAT,
+  EXPORT_SCHEMA_VERSION,
+  exportCapsule,
+  isValidCapsuleSince
+};
+//# sourceMappingURL=chunk-IYY4MCPG.js.map

package/dist/chunk-IYY4MCPG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/capsule-export.ts","../src/transfer/constants.ts"],"sourcesContent":["import { mkdir, readFile, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { gzipSync } from \"node:zlib\";\nimport { CAPSULE_SCHEMA_VERSION, EXPORT_FORMAT } from \"./constants.js\";\nimport {\n  listFilesRecursive,\n  sha256File,\n  toPosixRelPath,\n  writeJsonFile,\n} from \"./fs-utils.js\";\nimport {\n  CAPSULE_ID_PATTERN,\n  CapsuleBlockSchema,\n  ExportBundleV2Schema,\n  ExportManifestV2Schema,\n  type CapsuleBlock,\n  type ExportBundleV2,\n  type ExportManifestV2,\n  type ExportMemoryRecordV1,\n} from \"./types.js\";\nimport { encryptCapsuleFile } from \"./capsule-crypto.js\";\n\n/**\n * Default subdirectory excludes applied to every capsule export. These match\n * the existing `export-json` / `export-md` exclusions plus the `transcripts`\n * directory, which is excluded by default and only included when the caller\n * explicitly passes `transcripts` in {@link ExportCapsuleOptions.includeKinds}.\n */\nconst DEFAULT_EXCLUDE_DIRS: ReadonlySet<string> = new Set([\n  \"node_modules\",\n  \".git\",\n  // Never export the secure-store directory: it contains the encryption\n  // header (KDF params + verifier) which is security-sensitive and\n  // machine-specific. The passphrase is not stored here, but including\n  // the header in a capsule would let an attacker brute-force the\n  // passphrase offline if the capsule is intercepted.\n  \".secure-store\",\n  // Exclude .capsules to avoid recursive self-inclusion.\n  \".capsules\",\n]);\n\nconst TRANSCRIPTS_DIR = \"transcripts\" as const;\n\n/**\n * Top-level directory under {@link ExportCapsuleOptions.root} that holds\n * per-peer profile bundles. When {@link ExportCapsuleOptions.peerIds} is\n * provided, only files under `peers/<peerId>/...` for the listed ids are\n * included; the rest of the `peers/` tree is excluded.\n */\nconst PEERS_DIR = \"peers\" as const;\n\n/**\n * Options accepted by {@link exportCapsule}.\n *\n * `name` — capsule id, validated against {@link CAPSULE_ID_PATTERN}. The id\n * also forms the manifest's `capsule.id` and the archive filename.\n *\n * `root` — absolute or cwd-relative path to the memory directory to export.\n *\n * `since` — optional ISO-8601 timestamp; only files with `mtime >= since`\n * are included.\n *\n * `includeKinds` — optional allow-list of top-level subdirectory names\n * (e.g. `facts`, `entities`, `corrections`, `transcripts`). When set, files\n * directly under {@link root} are excluded and only files whose first path\n * segment is in the allow-list are kept. Pass `transcripts` here explicitly\n * to opt-in transcripts (they are excluded by default).\n *\n * `peerIds` — optional allow-list restricting the `peers/` tree to files\n * under `peers/<peerId>/...`. When omitted the entire `peers/` tree is\n * included (subject to {@link includeKinds}). When set to an empty array\n * the `peers/` tree is excluded entirely.\n *\n * `outDir` — optional output directory. Defaults to `<root>/.capsules`.\n *\n * `pluginVersion` — recorded in the manifest. Defaults to `\"0.0.0\"` so\n * tests do not need to thread a version through; production callers SHOULD\n * pass the running plugin version.\n *\n * `capsule` — optional overrides for the manifest's `capsule` block. The\n * caller may pass any subset; remaining fields are filled with conservative\n * defaults documented inline below.\n *\n * `now` — optional clock override (ms epoch) used for `manifest.createdAt`.\n * Tests pass a fixed value for deterministic output.\n *\n * `encrypt` — when `true`, encrypt the output archive using the secure-store\n * master key for `memoryDir`. The keyring must be unlocked before calling\n * (`remnic secure-store unlock`). The plaintext `.capsule.json.gz` is written\n * first, then encrypted to `<name>.capsule.json.gz.enc`; the plaintext is\n * removed after successful encryption. Requires `memoryDir` to be provided.\n *\n * `memoryDir` — required when `encrypt` is `true`. The memory directory whose\n * secure-store keyring holds the master key.\n */\nexport interface ExportCapsuleOptions {\n  name: string;\n  root: string;\n  since?: string;\n  includeKinds?: readonly string[];\n  peerIds?: readonly string[];\n  outDir?: string;\n  pluginVersion?: string;\n  capsule?: Partial<Omit<CapsuleBlock, \"id\">>;\n  now?: number;\n  /**\n   * When `true`, encrypt the output archive. Requires the secure-store to be\n   * unlocked and `memoryDir` to be set. The plaintext `.capsule.json.gz` is\n   * replaced by `<name>.capsule.json.gz.enc` on success.\n   */\n  encrypt?: boolean;\n  /**\n   * Memory directory whose secure-store keyring holds the master key. Required\n   * when `encrypt` is `true`; ignored otherwise.\n   */\n  memoryDir?: string;\n  /**\n   * When `true`, include the `transcripts/` directory in the export even\n   * though it is excluded by default. Using this flag avoids hard-coding an\n   * explicit `includeKinds` allow-list that would inadvertently drop other\n   * valid memory directories (`peers/`, `forks/`, etc.). (Cursor / #747)\n   *\n   * Ignored when `includeKinds` is provided and already contains\n   * `\"transcripts\"`.\n   */\n  includeTranscripts?: boolean;\n}\n\nexport interface ExportCapsuleResult {\n  archivePath: string;\n  manifestPath: string;\n  manifest: ExportManifestV2;\n  /** When the export was encrypted, the `.enc` path. `null` when unencrypted. */\n  encryptedArchivePath: string | null;\n}\n\n/**\n * Pure function that exports a memory directory as a portable, capsule-aware\n * V2 bundle.\n *\n * The output is a single `.capsule.json.gz` archive containing the entire\n * `ExportBundleV2` (manifest + records) plus a sidecar `manifest.json` for\n * cheap inspection. The bundle format is intentionally identical to the\n * existing `export-json` shape so PR 3/6's importer can reuse the V1 code\n * path with only a manifest version-dispatch.\n *\n * Determinism guarantees:\n *  - `manifest.files` and `bundle.records` are sorted by posix path.\n *  - `manifest.createdAt` is taken from {@link ExportCapsuleOptions.now}\n *    when provided.\n *  - The archive is gzip-compressed with default settings; no timestamp is\n *    embedded (Node's `gzipSync` does not write a header timestamp when\n *    using the synchronous helper, so byte-identical outputs are possible\n *    given identical inputs).\n *\n * Empty result handling: a capsule with zero matching files is still a\n * valid capsule and produces a well-formed manifest with an empty `files`\n * array and an archive containing the empty bundle.\n */\nexport async function exportCapsule(\n  opts: ExportCapsuleOptions,\n): Promise<ExportCapsuleResult> {\n  validateName(opts.name);\n  const sinceMs = parseSince(opts.since);\n  const includeKinds = normalizeIncludeKinds(opts.includeKinds);\n  const peerFilter = normalizePeerIds(opts.peerIds);\n  // `includeTranscripts: true` overrides the default transcripts exclusion\n  // without requiring an explicit `includeKinds` list — so callers that want\n  // all memory dirs + transcripts don't need to hard-code a list that would\n  // inadvertently drop new dirs like `peers/` or `forks/`. (Cursor / #747)\n  const transcriptsOverride = opts.includeTranscripts === true;\n\n  const rootAbs = path.resolve(opts.root);\n  await assertIsDirectory(rootAbs);\n\n  const outDirAbs = path.resolve(opts.outDir ?? path.join(rootAbs, \".capsules\"));\n  // Reject outDir === root: the input scan would otherwise be entirely\n  // skipped by `shouldInclude` (outDirRelPosix === \".\") and the export would\n  // silently succeed with an empty manifest/archive — a Rule 51 violation\n  // and a data-loss footgun for callers that point outDir at the root.\n  if (outDirAbs === rootAbs) {\n    throw new Error(\n      \"exportCapsule: 'outDir' must not equal 'root'. \" +\n        \"Choose a separate directory (default: <root>/.capsules) so the \" +\n        \"export does not overwrite or shadow the source tree.\",\n    );\n  }\n  await mkdir(outDirAbs, { recursive: true });\n\n  // If the output directory lives inside the export root, scan results would\n  // re-import previous capsule archives on subsequent runs. Compute the\n  // posix-relative path of the outDir under rootAbs (or `null` when it sits\n  // outside) so {@link shouldInclude} can skip the entire subtree.\n  const outDirRelPosix = computeOutDirRel(rootAbs, outDirAbs);\n\n  const filesAbs = await listFilesRecursive(rootAbs);\n\n  const records: ExportMemoryRecordV1[] = [];\n  const manifestFiles: ExportManifestV2[\"files\"] = [];\n\n  for (const abs of filesAbs) {\n    const relPosix = toPosixRelPath(abs, rootAbs);\n    if (!shouldInclude(relPosix, includeKinds, peerFilter, outDirRelPosix, transcriptsOverride)) continue;\n\n    if (sinceMs !== null) {\n      const st = await stat(abs);\n      if (st.mtimeMs < sinceMs) continue;\n    }\n\n    const content = await readFile(abs, \"utf-8\");\n    records.push({ path: relPosix, content });\n    const { sha256, bytes } = await sha256File(abs);\n    manifestFiles.push({ path: relPosix, sha256, bytes });\n  }\n\n  records.sort((a, b) => a.path.localeCompare(b.path));\n  manifestFiles.sort((a, b) => a.path.localeCompare(b.path));\n\n  const capsule = buildCapsuleBlock(opts.name, opts.capsule);\n  const includesTranscripts =\n    transcriptsOverride || (includeKinds ?? new Set<string>()).has(TRANSCRIPTS_DIR);\n\n  const createdAtMs = opts.now ?? Date.now();\n  const manifest = ExportManifestV2Schema.parse({\n    format: EXPORT_FORMAT,\n    schemaVersion: CAPSULE_SCHEMA_VERSION,\n    createdAt: new Date(createdAtMs).toISOString(),\n    pluginVersion: opts.pluginVersion ?? \"0.0.0\",\n    includesTranscripts,\n    files: manifestFiles,\n    capsule,\n  } satisfies ExportManifestV2);\n\n  const bundle: ExportBundleV2 = ExportBundleV2Schema.parse({\n    manifest,\n    records,\n  });\n\n  const archivePath = path.join(outDirAbs, `${opts.name}.capsule.json.gz`);\n  const manifestPath = path.join(outDirAbs, `${opts.name}.manifest.json`);\n\n  // Sidecar manifest for cheap inspection without decompressing the archive.\n  await writeJsonFile(manifestPath, manifest);\n\n  // Single-artifact gzip archive containing the whole bundle. JSON encoded\n  // before gzip so the archive is opaque to file-tree filtering. Using the\n  // sync helper keeps the function pure async (no filesystem callback chain)\n  // and matches the existing transfer modules' style.\n  const json = JSON.stringify(bundle);\n  const gz = gzipSync(Buffer.from(json, \"utf-8\"));\n  await writeFile(archivePath, gz);\n\n  // Optional encryption (PR 4/4). When opts.encrypt is true, wrap the\n  // plaintext gzip in a REMNIC-ENC sealed envelope and remove the plaintext.\n  // Per gotcha #54: write the encrypted file before removing the plaintext so\n  // a crash mid-encrypt does not destroy the only copy.\n  if (opts.encrypt === true) {\n    if (!opts.memoryDir) {\n      throw new Error(\n        \"exportCapsule: 'memoryDir' is required when 'encrypt' is true so the \" +\n          \"secure-store key can be retrieved.\",\n      );\n    }\n    const { encPath } = await encryptCapsuleFile({\n      sourceGzPath: archivePath,\n      memoryDir: opts.memoryDir,\n    });\n    // Remove the plaintext only after the encrypted file was written successfully.\n    const { unlink } = await import(\"node:fs/promises\");\n    await unlink(archivePath);\n    return { archivePath: encPath, manifestPath, manifest, encryptedArchivePath: encPath };\n  }\n\n  return { archivePath, manifestPath, manifest, encryptedArchivePath: null };\n}\n\n// ---------------------------------------------------------------------------\n// Validation helpers\n// ---------------------------------------------------------------------------\n\nfunction validateName(name: unknown): void {\n  if (typeof name !== \"string\" || !CAPSULE_ID_PATTERN.test(name)) {\n    throw new Error(\n      `exportCapsule: invalid capsule name. Expected /${CAPSULE_ID_PATTERN.source}/`,\n    );\n  }\n  if (name.length > 64) {\n    throw new Error(\n      \"exportCapsule: invalid capsule name. Must be 64 characters or fewer.\",\n    );\n  }\n}\n\n/**\n * Strict ISO-8601 form accepted by {@link parseSince}. We accept exactly two\n * shapes:\n *\n *   1. Date-only:  `YYYY-MM-DD` — interpreted as UTC midnight per ECMAScript.\n *   2. Date+time with an explicit timezone designator:\n *      `YYYY-MM-DDTHH:MM(:SS(.fff)?)?(Z|±HH:MM)`.\n *\n * Notably **rejected**: date+time **without** a timezone (e.g.\n * `2026-02-28T00:00:00`). ECMAScript treats this as local time, which makes\n * acceptance and the resulting cutoff depend on the host's `TZ` and silently\n * shifts incremental-export windows for users outside UTC. Rule 51: reject\n * inputs that silently coerce to a host-dependent meaning.\n */\nconst ISO_8601_RE =\n  /^\\d{4}-\\d{2}-\\d{2}(?:[Tt]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,9})?)?(?:[Zz]|[+-]\\d{2}:?\\d{2}))?$/;\n\nfunction parseSince(since: string | undefined): number | null {\n  if (since === undefined) return null;\n  if (typeof since !== \"string\" || since.trim() === \"\") {\n    throw new Error(\"exportCapsule: 'since' must be a non-empty ISO-8601 string\");\n  }\n  if (!ISO_8601_RE.test(since)) {\n    throw new Error(\n      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`,\n    );\n  }\n  const ms = Date.parse(since);\n  if (!Number.isFinite(ms)) {\n    throw new Error(\n      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`,\n    );\n  }\n  // Reject calendar overflow: `Date.parse(\"2026-02-31\")` returns a finite ms\n  // for March 3 because the JS Date constructor silently normalizes invalid\n  // calendar values. Round-trip through `Date` and compare the year/month/day\n  // components against the input prefix to catch this. Rule 51: silent\n  // coercion of an exact time boundary is a Rule 51 violation that breaks\n  // incremental exports.\n  assertCalendarRoundTrip(since, ms);\n  return ms;\n}\n\nexport function isValidCapsuleSince(since: string): boolean {\n  try {\n    parseSince(since);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Verify that parsing {@link since} did not silently normalize an invalid\n * calendar date (e.g. `2026-02-31` → `2026-03-03`). We extract the\n * year/month/day from the input string (regex-validated above) and compare\n * against the parsed Date's UTC components. Both date-only forms and forms\n * with an explicit Z/offset are normalized to UTC by `Date.parse`; for the\n * non-Z case where the offset shifts the calendar day across midnight, we\n * re-derive the input's intended UTC instant by accounting for the offset\n * before the comparison.\n */\nfunction assertCalendarRoundTrip(since: string, ms: number): void {\n  const m = /^(\\d{4})-(\\d{2})-(\\d{2})/.exec(since);\n  if (!m) return;\n  const wantY = Number(m[1]);\n  const wantMo = Number(m[2]);\n  const wantD = Number(m[3]);\n\n  // For inputs with an explicit non-zero offset, compare against the\n  // wall-clock components of that offset instead of UTC. Date.parse maps to\n  // UTC, so 2026-02-31T00:00:00-05:00 and 2026-02-31T00:00:00Z both fail the\n  // calendar check; the wall-clock comparison via `m[1..3]` is still the\n  // right reference because the input's stated calendar day must exist.\n  const offsetMatch = /([+-])(\\d{2}):?(\\d{2})$/.exec(since);\n  let displayMs = ms;\n  if (offsetMatch) {\n    const sign = offsetMatch[1] === \"-\" ? -1 : 1;\n    const offsetMin = sign * (Number(offsetMatch[2]) * 60 + Number(offsetMatch[3]));\n    displayMs = ms + offsetMin * 60_000;\n  }\n  const dd = new Date(displayMs);\n  const gotY = dd.getUTCFullYear();\n  const gotMo = dd.getUTCMonth() + 1;\n  const gotD = dd.getUTCDate();\n  if (gotY !== wantY || gotMo !== wantMo || gotD !== wantD) {\n    throw new Error(\n      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`,\n    );\n  }\n}\n\nfunction normalizeIncludeKinds(\n  kinds: readonly string[] | undefined,\n): ReadonlySet<string> | null {\n  if (kinds === undefined) return null;\n  // Empty array is treated as \"include nothing\" rather than \"include all\"\n  // so callers cannot accidentally widen the filter by passing []. This\n  // mirrors PR-1/6 Rule 51: reject ambiguous input — but here we model it\n  // as \"explicit empty allow-list\" rather than throwing, because empty\n  // capsules ARE valid (see acceptance criteria).\n  const set = new Set<string>();\n  for (const raw of kinds) {\n    if (typeof raw !== \"string\" || raw.trim() === \"\") {\n      throw new Error(\"exportCapsule: 'includeKinds' entries must be non-empty strings\");\n    }\n    if (raw.includes(\"/\") || raw.includes(\"\\\\\")) {\n      throw new Error(\n        `exportCapsule: 'includeKinds' entries must be top-level segment names, got: ${raw}`,\n      );\n    }\n    set.add(raw);\n  }\n  return set;\n}\n\nfunction normalizePeerIds(\n  peerIds: readonly string[] | undefined,\n): ReadonlySet<string> | null {\n  if (peerIds === undefined) return null;\n  const set = new Set<string>();\n  for (const raw of peerIds) {\n    if (typeof raw !== \"string\" || raw.trim() === \"\") {\n      throw new Error(\"exportCapsule: 'peerIds' entries must be non-empty strings\");\n    }\n    if (raw.includes(\"/\") || raw.includes(\"\\\\\") || raw === \".\" || raw === \"..\") {\n      throw new Error(\n        `exportCapsule: 'peerIds' entries must be plain segment names, got: ${raw}`,\n      );\n    }\n    set.add(raw);\n  }\n  return set;\n}\n\n/**\n * Return the posix-relative path of {@link outDirAbs} under {@link rootAbs},\n * or `null` if the output directory sits outside the export root. Used to\n * exclude the output directory's subtree from the input scan so re-running\n * the export does not package prior archives back into the new bundle.\n *\n * Both inputs are expected to be absolute paths already (post-`path.resolve`).\n */\nfunction computeOutDirRel(rootAbs: string, outDirAbs: string): string | null {\n  const rel = path.relative(rootAbs, outDirAbs);\n  // outDir == root: degenerate. {@link exportCapsule} rejects this case\n  // before calling us; this branch is defensive only. Returning `\".\"` would\n  // make `shouldInclude` drop every file, masking the misuse — return `null`\n  // instead so any direct caller that bypasses the check still produces a\n  // populated manifest rather than a silent empty export.\n  if (rel === \"\") return null;\n  // outDir outside root: nothing to exclude. Match real parent-traversal\n  // segments only — `rel.startsWith(\"..\")` would also match valid in-tree\n  // names like `..capsules` and would skip excluding that subtree. The\n  // boundary check (`rel === \"..\"` or `rel` starts with `\"..\" + sep`) is\n  // platform-aware via `path.sep` so Windows backslashes are respected.\n  if (rel === \"..\" || rel.startsWith(`..${path.sep}`)) return null;\n  if (path.isAbsolute(rel)) return null;\n  return rel.split(path.sep).join(\"/\");\n}\n\nasync function assertIsDirectory(absPath: string): Promise<void> {\n  // Mirror gotcha #24: existsSync returns true for files. The export root\n  // MUST be a directory or the walk silently succeeds with zero entries.\n  const st = await stat(absPath).catch(() => null);\n  if (!st || !st.isDirectory()) {\n    throw new Error(\n      `exportCapsule: 'root' must be an existing directory: ${absPath}`,\n    );\n  }\n}\n\nfunction shouldInclude(\n  relPosix: string,\n  includeKinds: ReadonlySet<string> | null,\n  peerFilter: ReadonlySet<string> | null,\n  outDirRelPosix: string | null,\n  transcriptsOverride = false,\n): boolean {\n  const parts = relPosix.split(\"/\");\n  if (parts.some((p) => DEFAULT_EXCLUDE_DIRS.has(p))) return false;\n\n  // Exclude the output directory subtree. Without this, re-running against\n  // the same root packages prior `.capsule.json.gz` archives and sidecar\n  // manifests as records, causing bundle bloat and leaking stale exports.\n  // `outDir === root` is rejected at the entrypoint (`exportCapsule`), so\n  // {@link computeOutDirRel} never returns `\".\"` for the in-tree case here.\n  if (outDirRelPosix !== null) {\n    if (relPosix === outDirRelPosix) return false;\n    if (relPosix.startsWith(`${outDirRelPosix}/`)) return false;\n  }\n\n  const top = parts[0];\n\n  // Transcripts are opt-in: excluded unless caller explicitly listed them\n  // in includeKinds OR passed `includeTranscripts: true`. The override flag\n  // avoids the footgun of having the CLI build a hard-coded kinds list that\n  // inadvertently drops valid memory dirs like `peers/` or `forks/`. (Cursor / #747)\n  if (\n    top === TRANSCRIPTS_DIR &&\n    !transcriptsOverride &&\n    (includeKinds === null || !includeKinds.has(TRANSCRIPTS_DIR))\n  ) {\n    return false;\n  }\n\n  if (includeKinds !== null) {\n    // includeKinds restricts to whitelisted top-level segments. Files at\n    // the repo root (no top-level dir) are excluded under an explicit\n    // allow-list because they are not categorized.\n    if (parts.length < 2) return false;\n    if (!includeKinds.has(top)) return false;\n  }\n\n  if (top === PEERS_DIR && peerFilter !== null) {\n    if (peerFilter.size === 0) return false;\n    if (parts.length < 2) return false;\n    if (!peerFilter.has(parts[1])) return false;\n  }\n\n  return true;\n}\n\n// ---------------------------------------------------------------------------\n// Capsule-block defaults\n// ---------------------------------------------------------------------------\n\n/**\n * Build a {@link CapsuleBlock} for the manifest. PR 2/6 ships a minimal\n * snapshot: tier-weights and `directAnswerEnabled` default to zod-passing\n * placeholders so the bundle parses cleanly. PRs 3/6+ will wire real\n * retrieval-policy and identity-anchor snapshots into the override path.\n *\n * Defaults (chosen to be safe + least-surprising):\n *  - `version`           — `0.1.0` (capsule authors override per release).\n *  - `schemaVersion`     — `taxonomy-v1` until the taxonomy registry stabilizes.\n *  - `parentCapsule`     — `null` (explicit \"no parent\" sentinel).\n *  - `description`       — empty string. Capsule authors override.\n *  - `retrievalPolicy`   — empty `tierWeights` map + `directAnswerEnabled: false`.\n *    Empty weights mean \"no overrides\"; importers fall back to their local\n *    policy. `false` is the least-privileged default per Rule 48.\n *  - `includes`          — all flags `false` until later PRs wire the\n *    sub-bundles in.\n */\nfunction buildCapsuleBlock(\n  name: string,\n  override: Partial<Omit<CapsuleBlock, \"id\">> | undefined,\n): CapsuleBlock {\n  // `parent` (structured, PR 4/6) and `parentCapsule` (legacy string) carry\n  // overlapping information. The schema documents the invariant: when\n  // `parent` is non-null, `parentCapsule` SHOULD equal `parent.capsuleId`.\n  // We derive the legacy field from the structured field whenever the\n  // caller supplies `parent` but omits `parentCapsule`, so a single-source\n  // override path produces a manifest that satisfies the documented\n  // invariant for legacy V2 readers (Cursor medium #751 round 3).\n  // An explicit `parentCapsule` override still wins — including an explicit\n  // `null` — so callers can intentionally diverge from the structured field\n  // for migration scenarios.\n  const parent = override?.parent ?? null;\n  const parentCapsule =\n    override && Object.prototype.hasOwnProperty.call(override, \"parentCapsule\")\n      ? (override.parentCapsule ?? null)\n      : (parent?.capsuleId ?? null);\n\n  const merged: CapsuleBlock = {\n    id: name,\n    version: override?.version ?? \"0.1.0\",\n    schemaVersion: override?.schemaVersion ?? \"taxonomy-v1\",\n    parentCapsule,\n    parent,\n    description: override?.description ?? \"\",\n    retrievalPolicy: override?.retrievalPolicy ?? {\n      tierWeights: {},\n      directAnswerEnabled: false,\n    },\n    includes: override?.includes ?? {\n      taxonomy: false,\n      identityAnchors: false,\n      peerProfiles: false,\n      procedural: false,\n    },\n  };\n  // Re-parse to surface invalid overrides with the same zod errors a caller\n  // would get when constructing a CapsuleBlock by hand.\n  return CapsuleBlockSchema.parse(merged);\n}\n","export const EXPORT_FORMAT = \"openclaw-engram-export\" as const;\nexport const EXPORT_SCHEMA_VERSION = 1 as const;\n\n/**\n * Schema version for capsule-aware (V2) export manifests. See\n * {@link ../types.ts} `ExportManifestV2Schema` for the wire format.\n *\n * V1 manifests remain the default for non-capsule exports\n * (`exportJsonBundle` / `exportMarkdownBundle`). V2 is emitted by the\n * capsule export pipeline only.\n */\nexport const CAPSULE_SCHEMA_VERSION = 2 as const;\n\n"],"mappings":"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","names":[]}