@remnic/plugin-openclaw 1.0.9 → 1.0.11

package/dist/{calibration-674TDQNV.js → calibration-WCHOK6DX.js}

@@ -1,13 +1,14 @@
-import {
-  FallbackLlmClient
-} from "./chunk-7TENHBV2.js";
-import "./chunk-3A5ELHTT.js";
 import {
   listJsonFiles
 } from "./chunk-5LE4HTVL.js";
+import {
+  FallbackLlmClient
+} from "./chunk-RQCTMECT.js";
+import "./chunk-3A5ELHTT.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
+import "./chunk-I6B2W2IY.js";
 import "./chunk-MLKGABMK.js";
 
 // ../remnic-core/src/calibration.ts
@@ -38,7 +39,13 @@ async function writeCalibrationIndex(memoryDir, index) {
   index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await writeFile(calibrationIndexPath(memoryDir), JSON.stringify(index, null, 2), "utf8");
 }
+async function readCalibrationCorrections(memoryDir) {
+  return readCorrectionsImpl(memoryDir);
+}
 async function readCorrections(memoryDir) {
+  return readCorrectionsImpl(memoryDir);
+}
+async function readCorrectionsImpl(memoryDir) {
   const correctionsDir = path.join(memoryDir, "corrections");
   const files = await listJsonFiles(correctionsDir).catch(() => {
     return [];
@@ -229,6 +236,7 @@ async function getCalibrationRulesForRecall(memoryDir) {
 export {
   buildCalibrationRecallSection,
   getCalibrationRulesForRecall,
+  readCalibrationCorrections,
   readCalibrationIndex,
   runCalibrationConsolidation,
   runCalibrationIfEnabled,

package/dist/capsule-cli-TFKLAG3S.js

@@ -0,0 +1,329 @@
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/capsule-cli.ts
+import path from "path";
+function parseCapsuleOutputFormat(raw) {
+  if (raw === void 0 || raw === null) return "text";
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(
+      `--format expects one of text, markdown, json; got ${JSON.stringify(raw)}`
+    );
+  }
+  const v = raw.trim();
+  if (v !== "text" && v !== "markdown" && v !== "json") {
+    throw new Error(
+      `--format expects one of text, markdown, json; got ${JSON.stringify(raw)}`
+    );
+  }
+  return v;
+}
+function parseCapsuleImportMode(raw) {
+  if (raw === void 0 || raw === null) return "skip";
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(
+      `--mode expects one of skip, overwrite, fork; got ${JSON.stringify(raw)}`
+    );
+  }
+  const v = raw.trim();
+  if (v !== "skip" && v !== "overwrite" && v !== "fork") {
+    throw new Error(
+      `--mode expects one of skip, overwrite, fork; got ${JSON.stringify(raw)}`
+    );
+  }
+  return v;
+}
+function parseCapsuleConflictMode(raw) {
+  if (raw === void 0 || raw === null) return "skip-conflicts";
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(
+      `--conflict-mode expects one of skip-conflicts, prefer-source, prefer-local; got ${JSON.stringify(raw)}`
+    );
+  }
+  const v = raw.trim();
+  if (v !== "skip-conflicts" && v !== "prefer-source" && v !== "prefer-local") {
+    throw new Error(
+      `--conflict-mode expects one of skip-conflicts, prefer-source, prefer-local; got ${JSON.stringify(raw)}`
+    );
+  }
+  return v;
+}
+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 parseCapsuleSince(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error(
+      `--since expects an ISO 8601 timestamp; got ${JSON.stringify(raw)}`
+    );
+  }
+  if (raw.trim() === "") {
+    throw new Error(`--since expects an ISO 8601 timestamp; received empty string`);
+  }
+  if (!ISO_8601_RE.test(raw)) {
+    throw new Error(
+      `--since is not a valid ISO 8601 timestamp: ${raw}. Accepted forms: YYYY-MM-DD, YYYY-MM-DDTHH:MM:SSZ, YYYY-MM-DDTHH:MM:SS\xB1HH:MM`
+    );
+  }
+  const ms = Date.parse(raw);
+  if (!Number.isFinite(ms)) {
+    throw new Error(`--since is not a valid ISO 8601 timestamp: ${raw}`);
+  }
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(raw);
+  if (m) {
+    const offsetMatch = /([+-])(\d{2}):?(\d{2})$/.exec(raw);
+    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);
+    if (dd.getUTCFullYear() !== Number(m[1]) || dd.getUTCMonth() + 1 !== Number(m[2]) || dd.getUTCDate() !== Number(m[3])) {
+      throw new Error(
+        `--since: calendar overflow \u2014 ${raw} normalises to a different calendar date`
+      );
+    }
+  }
+  return raw;
+}
+function parseCapsuleIncludeKinds(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error(
+      `--include-kinds expects a comma-separated list of directory names; got ${JSON.stringify(raw)}`
+    );
+  }
+  if (raw.trim() === "") {
+    throw new Error(
+      `--include-kinds expects at least one non-empty kind name`
+    );
+  }
+  const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (parts.length === 0) {
+    throw new Error(`--include-kinds expects at least one non-empty kind name`);
+  }
+  for (const p of parts) {
+    if (p.includes("/") || p.includes("\\")) {
+      throw new Error(
+        `--include-kinds entries must be top-level directory names (no path separators): ${p}`
+      );
+    }
+  }
+  return [...new Set(parts)];
+}
+function parseCapsulePeers(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error(
+      `--peers expects a comma-separated list of peer ids; got ${JSON.stringify(raw)}`
+    );
+  }
+  if (raw.trim() === "") {
+    throw new Error(`--peers expects at least one non-empty peer id`);
+  }
+  const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (parts.length === 0) {
+    throw new Error(`--peers expects at least one non-empty peer id`);
+  }
+  for (const p of parts) {
+    if (p.includes("/") || p.includes("\\") || p === "." || p === "..") {
+      throw new Error(
+        `--peers entries must be plain id tokens (no path separators): ${p}`
+      );
+    }
+  }
+  return [...new Set(parts)];
+}
+function parseCapsuleExportOptions(nameArg, opts) {
+  if (typeof nameArg !== "string" || nameArg.trim() === "") {
+    throw new Error(
+      `capsule export: <name> is required (e.g. "remnic capsule export my-capsule")`
+    );
+  }
+  const name = nameArg.trim();
+  const out = typeof opts.out === "string" && opts.out.trim() !== "" ? opts.out.trim() : void 0;
+  const since = parseCapsuleSince(opts.since);
+  const includeKinds = parseCapsuleIncludeKinds(opts.includeKinds);
+  const peers = parseCapsulePeers(opts.peers);
+  return { name, out, since, includeKinds, peers };
+}
+function parseCapsuleImportOptions(archiveArg, opts) {
+  if (typeof archiveArg !== "string" || archiveArg.trim() === "") {
+    throw new Error(
+      `capsule import: <archive> path is required (e.g. "remnic capsule import /path/to/my-capsule.capsule.json.gz")`
+    );
+  }
+  const archive = archiveArg.trim();
+  const mode = parseCapsuleImportMode(opts.mode);
+  return { archive, mode };
+}
+function parseCapsuleMergeOptions(archiveArg, opts) {
+  if (typeof archiveArg !== "string" || archiveArg.trim() === "") {
+    throw new Error(
+      `capsule merge: <archive> path is required (e.g. "remnic capsule merge /path/to/my-capsule.capsule.json.gz")`
+    );
+  }
+  const archive = archiveArg.trim();
+  const conflictMode = parseCapsuleConflictMode(opts.conflictMode);
+  return { archive, conflictMode };
+}
+function parseCapsuleListOptions(opts, defaultCapsulesDir2) {
+  const format = parseCapsuleOutputFormat(opts.format);
+  const rawDir = typeof opts.dir === "string" && opts.dir.trim() !== "" ? opts.dir.trim() : void 0;
+  const capsulesDir = rawDir ?? defaultCapsulesDir2;
+  return { format, capsulesDir };
+}
+function parseCapsuleInspectOptions(archiveArg, opts) {
+  if (typeof archiveArg !== "string" || archiveArg.trim() === "") {
+    throw new Error(
+      `capsule inspect: <archive> path is required (e.g. "remnic capsule inspect my-capsule.capsule.json.gz")`
+    );
+  }
+  const archive = archiveArg.trim();
+  const format = parseCapsuleOutputFormat(opts.format);
+  return { archive, format };
+}
+function defaultCapsulesDir(memoryDir) {
+  return path.join(memoryDir, ".capsules");
+}
+function escapeMarkdownCell(v) {
+  return v.replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+}
+function renderCapsuleList(entries, format) {
+  if (format === "json") {
+    return JSON.stringify({ capsules: entries }, null, 2);
+  }
+  if (entries.length === 0) {
+    if (format === "markdown") return "_No capsule archives found._\n";
+    return "No capsule archives found.\n";
+  }
+  if (format === "markdown") {
+    const rows = entries.map((e) => {
+      const id = escapeMarkdownCell(e.id);
+      const date = escapeMarkdownCell(e.createdAt?.slice(0, 10) ?? "\u2014");
+      const ver = escapeMarkdownCell(e.pluginVersion ?? "\u2014");
+      const files = e.fileCount !== null ? String(e.fileCount) : "\u2014";
+      const desc = escapeMarkdownCell(
+        e.description != null && e.description.trim() !== "" ? e.description.trim() : "\u2014"
+      );
+      return `| \`${id}\` | ${date} | ${ver} | ${files} | ${desc} |`;
+    });
+    return [
+      "# Capsule archives",
+      "",
+      "| ID | Created | Version | Files | Description |",
+      "| -- | ------- | ------- | ----- | ----------- |",
+      ...rows,
+      ""
+    ].join("\n");
+  }
+  const lines = entries.map((e) => {
+    const date = e.createdAt?.slice(0, 10) ?? "\u2014";
+    const files = e.fileCount !== null ? `${e.fileCount} file${e.fileCount !== 1 ? "s" : ""}` : "? files";
+    const desc = e.description != null && e.description.trim() !== "" ? `  ${e.description.trim()}` : "";
+    return `${e.id}  [${date}] [${files}]${desc}`;
+  });
+  return lines.join("\n") + "\n";
+}
+function renderCapsuleInspect(manifest, format) {
+  if (format === "json") {
+    return JSON.stringify(manifest, null, 2);
+  }
+  const {
+    capsuleId,
+    version,
+    schemaVersion,
+    createdAt,
+    pluginVersion,
+    fileCount,
+    includesTranscripts,
+    description,
+    parentCapsule,
+    retrievalPolicy,
+    includes,
+    topFiles
+  } = manifest;
+  if (format === "markdown") {
+    const policyLines = Object.entries(retrievalPolicy.tierWeights ?? {}).map(
+      ([k, v]) => `  - ${k}: ${v}`
+    );
+    const policyBlock = policyLines.length > 0 ? policyLines.join("\n") : "  _(no tier weight overrides)_";
+    return [
+      `# Capsule: \`${capsuleId}\``,
+      "",
+      `**Version:** ${version}  `,
+      `**Schema version:** ${schemaVersion}  `,
+      `**Created:** ${createdAt ?? "\u2014"}  `,
+      `**Plugin version:** ${pluginVersion ?? "\u2014"}  `,
+      `**Files:** ${fileCount}  `,
+      `**Includes transcripts:** ${includesTranscripts ? "yes" : "no"}  `,
+      `**Parent capsule:** ${parentCapsule ?? "_none_"}  `,
+      `**Description:** ${description && description.trim() !== "" ? description.trim() : "_none_"}  `,
+      "",
+      "## Includes",
+      `- taxonomy: ${includes.taxonomy ? "yes" : "no"}`,
+      `- identityAnchors: ${includes.identityAnchors ? "yes" : "no"}`,
+      `- peerProfiles: ${includes.peerProfiles ? "yes" : "no"}`,
+      `- procedural: ${includes.procedural ? "yes" : "no"}`,
+      "",
+      "## Retrieval policy",
+      `- directAnswerEnabled: ${retrievalPolicy.directAnswerEnabled ? "yes" : "no"}`,
+      `- tierWeights:`,
+      policyBlock,
+      "",
+      ...topFiles.length > 0 ? [
+        `## Files (${fileCount} total, showing first ${topFiles.length})`,
+        ...topFiles.map((f) => `- \`${f}\``),
+        ""
+      ] : [`## Files (${fileCount} total)`, "_Empty capsule._", ""]
+    ].join("\n");
+  }
+  const lines = [
+    `Capsule: ${capsuleId}`,
+    `  version:          ${version}`,
+    `  schema:           ${schemaVersion}`,
+    `  created:          ${createdAt ?? "\u2014"}`,
+    `  plugin:           ${pluginVersion ?? "\u2014"}`,
+    `  files:            ${fileCount}`,
+    `  transcripts:      ${includesTranscripts ? "yes" : "no"}`,
+    `  parent:           ${parentCapsule ?? "(none)"}`,
+    `  description:      ${description && description.trim() !== "" ? description.trim() : "(none)"}`,
+    "",
+    `  includes.taxonomy:        ${includes.taxonomy ? "yes" : "no"}`,
+    `  includes.identityAnchors: ${includes.identityAnchors ? "yes" : "no"}`,
+    `  includes.peerProfiles:    ${includes.peerProfiles ? "yes" : "no"}`,
+    `  includes.procedural:      ${includes.procedural ? "yes" : "no"}`,
+    "",
+    `  policy.directAnswer:   ${retrievalPolicy.directAnswerEnabled ? "yes" : "no"}`
+  ];
+  const weights = Object.entries(retrievalPolicy.tierWeights ?? {});
+  if (weights.length > 0) {
+    for (const [k, v] of weights) {
+      lines.push(`  policy.tierWeight[${k}]: ${v}`);
+    }
+  } else {
+    lines.push(`  policy.tierWeights:    (none)`);
+  }
+  if (topFiles.length > 0) {
+    lines.push("", `  files (first ${topFiles.length} of ${fileCount}):`);
+    for (const f of topFiles) {
+      lines.push(`    ${f}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+export {
+  defaultCapsulesDir,
+  parseCapsuleConflictMode,
+  parseCapsuleExportOptions,
+  parseCapsuleImportMode,
+  parseCapsuleImportOptions,
+  parseCapsuleIncludeKinds,
+  parseCapsuleInspectOptions,
+  parseCapsuleListOptions,
+  parseCapsuleMergeOptions,
+  parseCapsuleOutputFormat,
+  parseCapsulePeers,
+  parseCapsuleSince,
+  renderCapsuleInspect,
+  renderCapsuleList
+};

package/dist/capsule-crypto-K3IRTKRH.js

@@ -0,0 +1,17 @@
+import {
+  decryptCapsuleFile,
+  decryptCapsuleFileInMemory,
+  encryptCapsuleFile,
+  isEncryptedCapsuleFile
+} from "./chunk-SSFTU6LP.js";
+import "./chunk-CXM7EBAO.js";
+import "./chunk-JZBOXOUC.js";
+import "./chunk-6IWEAUN6.js";
+import "./chunk-YGGGUTG3.js";
+import "./chunk-MLKGABMK.js";
+export {
+  decryptCapsuleFile,
+  decryptCapsuleFileInMemory,
+  encryptCapsuleFile,
+  isEncryptedCapsuleFile
+};

package/dist/capsule-export-CVA3CKUQ.js

@@ -0,0 +1,265 @@
+import {
+  CAPSULE_SCHEMA_VERSION,
+  EXPORT_FORMAT
+} from "./chunk-YGXXBRV7.js";
+import {
+  CAPSULE_ID_PATTERN,
+  CapsuleBlockSchema,
+  ExportBundleV2Schema,
+  ExportManifestV2Schema
+} from "./chunk-K7EUBNDD.js";
+import {
+  listFilesRecursive,
+  sha256File,
+  toPosixRelPath,
+  writeJsonFile
+} from "./chunk-NKVIN6RD.js";
+import {
+  encryptCapsuleFile
+} from "./chunk-SSFTU6LP.js";
+import "./chunk-XMSDA5WA.js";
+import "./chunk-CXM7EBAO.js";
+import "./chunk-JZBOXOUC.js";
+import "./chunk-6IWEAUN6.js";
+import "./chunk-YGGGUTG3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/transfer/capsule-export.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import path from "path";
+import { gzipSync } from "zlib";
+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 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 {
+  exportCapsule
+};

package/dist/capsule-import-CFX7BY5W.js

@@ -0,0 +1,16 @@
+import {
+  importCapsule
+} from "./chunk-ETJZRIAM.js";
+import "./chunk-K7EUBNDD.js";
+import "./chunk-NKVIN6RD.js";
+import "./chunk-SSFTU6LP.js";
+import "./chunk-XMSDA5WA.js";
+import "./chunk-CXM7EBAO.js";
+import "./chunk-JZBOXOUC.js";
+import "./chunk-6IWEAUN6.js";
+import "./chunk-6OJAU466.js";
+import "./chunk-YGGGUTG3.js";
+import "./chunk-MLKGABMK.js";
+export {
+  importCapsule
+};