@remnic/core 9.65.3 → 9.65.4

package/dist/{chunk-7QOO4LGC.js → chunk-3JZBPTLD.js}

@@ -57,7 +57,7 @@ import {
 } from "./chunk-IIFFC3RL.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-TDKSCV62.js";
+} from "./chunk-3NH3VP3U.js";
 import {
   archiveObservations
 } from "./chunk-YLBE6PLR.js";
@@ -80,21 +80,21 @@ import {
 } from "./chunk-6FC3IZ26.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-7KFIMGMP.js";
+} from "./chunk-ECLJ4LA2.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-4XDGYCZI.js";
+} from "./chunk-J3ATBB7M.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-AYDDB3XI.js";
+} from "./chunk-OCCHUEZB.js";
 import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-URHCUXKI.js";
+} from "./chunk-AXGFOFNY.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -105,7 +105,7 @@ import {
 } from "./chunk-AM4T6CHX.js";
 import {
   parseXrayCliOptions
-} from "./chunk-2VXWFYJE.js";
+} from "./chunk-R2MZCYA6.js";
 import {
   collectPatternMemories,
   explainPatternMemory,
@@ -127,7 +127,7 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-OLWTCWQ2.js";
+} from "./chunk-YZJM6CLF.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -152,7 +152,7 @@ import {
 } from "./chunk-6GUG4YNM.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-QXIQPCCN.js";
+} from "./chunk-UFR6HX7A.js";
 import {
   rescoreMemoryImportance
 } from "./chunk-UOBPK2OS.js";
@@ -175,7 +175,7 @@ import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-QFMO32TO.js";
+} from "./chunk-DUZARALI.js";
 import {
   buildConnectorRowsFromDefinitions,
   parseConnectorsListOptions,
@@ -196,11 +196,11 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   parseConfig
-} from "./chunk-76PL4XLG.js";
+} from "./chunk-DPNXADEI.js";
 import {
   EngramAccessHttpServer,
   MeetingsInputError
-} from "./chunk-BKYPJUQL.js";
+} from "./chunk-XGM3VQWG.js";
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
@@ -210,13 +210,13 @@ import {
   loadChatSession,
   processChatMessage,
   sessionBelongsToPrincipal
-} from "./chunk-VA5KMSAE.js";
+} from "./chunk-SR5LNI6Q.js";
 import {
   getAbstractionNodeStoreStatus
 } from "./chunk-DJUKBGAD.js";
 import {
   EngramAccessService
-} from "./chunk-WN5FSGLE.js";
+} from "./chunk-AZLLH6YA.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -233,10 +233,10 @@ import {
   parseRecallExplainFormat,
   renderRecallExplain,
   renderXray
-} from "./chunk-AZAA5DNP.js";
+} from "./chunk-YOXVZJFM.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-GUXS322H.js";
+} from "./chunk-2MVTAIL3.js";
 import {
   getObjectiveStateStoreStatus
 } from "./chunk-HTP6XRUI.js";
@@ -245,30 +245,33 @@ import {
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-EIVIB73I.js";
+} from "./chunk-KOO37E4Y.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-OJD4WS2E.js";
+} from "./chunk-OZDFB22S.js";
 import {
   analyzeGraphHealth
 } from "./chunk-BIJAWZYW.js";
 import {
   resolveNamespaceChildRoot
-} from "./chunk-S7Q5CM7E.js";
+} from "./chunk-TJFI3K2O.js";
 import {
   OKF_RESERVED_BASENAMES,
   meetingIdDate,
   okfTypeForCategory
-} from "./chunk-PAYGC3BD.js";
+} from "./chunk-THVI4Y7X.js";
 import {
   isValidTranscriptDate
 } from "./chunk-UHVXE24Y.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-NXKJHSDN.js";
+} from "./chunk-LBFFNDFM.js";
+import {
+  composeMemoryEnvelope
+} from "./chunk-RAIUTAZZ.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-XCB6QDL6.js";
@@ -283,6 +286,20 @@ import {
 import {
   renderExtractionLivenessStats
 } from "./chunk-3SG4FGDV.js";
+import {
+  SKILL_FILE_NAME,
+  SKILL_IMPORT_SOURCE,
+  parseSkillBundle,
+  projectProceduresToSkills,
+  renderSkillBundle,
+  sanitizeSkillSlug
+} from "./chunk-236PXYG7.js";
+import {
+  BUILTIN_SKILLS
+} from "./chunk-ZCUTSMR2.js";
+import {
+  buildProcedurePersistBody
+} from "./chunk-QDW3E4RD.js";
 import {
   getCausalTrajectoryStoreStatus
 } from "./chunk-PP7R754B.js";
@@ -299,7 +316,8 @@ import {
   STATE_FILE_MAX_DECRYPT_BYTES
 } from "./chunk-DVYRD4HY.js";
 import {
-  assertPathInsideRoot
+  assertPathInsideRoot,
+  pathIsInside
 } from "./chunk-GCASGYIO.js";
 import {
   inferMemoryStatus,
@@ -349,8 +367,8 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/cli.ts
-import path5 from "path";
-import { access, lstat as lstat2, readFile, readdir as readdir2, realpath as realpath2, unlink } from "fs/promises";
+import path6 from "path";
+import { access, lstat as lstat3, readFile as readFile2, readdir as readdir3, realpath as realpath3, unlink } from "fs/promises";
 import { createHash } from "crypto";
 
 // src/wearables/registry.ts
@@ -1351,6 +1369,242 @@ function registerOkfCommands(cmd, orchestrator) {
   });
 }
 
+// src/procedural/skill-io.ts
+import { lstat, mkdir, readdir, readFile, realpath, writeFile } from "fs/promises";
+import path3 from "path";
+async function exportSkillBundles(options) {
+  const outDir = path3.resolve(options.outDir);
+  await mkdir(outDir, { recursive: true });
+  const slugs = [];
+  for (const bundle of options.bundles) {
+    const dir = path3.join(outDir, bundle.slug);
+    if (!pathIsInside(outDir, dir)) {
+      throw new Error(`skill export: refusing to write outside ${outDir} (slug ${bundle.slug})`);
+    }
+    try {
+      const existing = await lstat(dir);
+      if (existing.isSymbolicLink()) {
+        throw new Error(`skill export: refusing to write through symlink ${dir}`);
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    await mkdir(dir, { recursive: true });
+    const skillPath = path3.join(dir, SKILL_FILE_NAME);
+    try {
+      const existingSkill = await lstat(skillPath);
+      if (existingSkill.isSymbolicLink()) {
+        throw new Error(`skill export: refusing to write through symlink ${skillPath}`);
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    await writeFile(skillPath, renderSkillBundle(bundle), "utf-8");
+    slugs.push(bundle.slug);
+  }
+  return { outDir, slugs };
+}
+async function readSkillBundlesFromDir(dir) {
+  const root = path3.resolve(dir);
+  const rootStat = await lstat(root);
+  if (rootStat.isSymbolicLink()) {
+    throw new Error(`skill import: refusing to walk symlinked directory ${root}`);
+  }
+  if (!rootStat.isDirectory()) {
+    throw new Error(`skill import: ${root} is not a directory`);
+  }
+  const rootReal = await realpath(root);
+  const bundles = [];
+  const skipped = [];
+  const entries = await readdir(root, { withFileTypes: true });
+  entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  for (const entry of entries) {
+    try {
+      if (entry.isSymbolicLink()) {
+        skipped.push({ entry: entry.name, reason: "symlink" });
+        continue;
+      }
+      if (!entry.isDirectory()) continue;
+      const bundleDir = path3.join(root, entry.name);
+      const bundleReal = await realpath(bundleDir);
+      if (!pathIsInside(rootReal, bundleReal)) {
+        skipped.push({ entry: entry.name, reason: "resolves outside the import root" });
+        continue;
+      }
+      const skillPath = path3.join(bundleDir, SKILL_FILE_NAME);
+      let skillStat;
+      try {
+        skillStat = await lstat(skillPath);
+      } catch {
+        skipped.push({ entry: entry.name, reason: `no ${SKILL_FILE_NAME}` });
+        continue;
+      }
+      if (skillStat.isSymbolicLink() || !skillStat.isFile()) {
+        skipped.push({ entry: entry.name, reason: `${SKILL_FILE_NAME} is not a regular file` });
+        continue;
+      }
+      const parsed = parseSkillBundle(await readFile(skillPath, "utf-8"), sanitizeSkillSlug(entry.name));
+      if (!parsed) {
+        skipped.push({ entry: entry.name, reason: "empty body" });
+        continue;
+      }
+      const siblings = await readdir(bundleDir);
+      bundles.push({
+        ...parsed,
+        hasUnimportedResources: siblings.some((name) => name !== SKILL_FILE_NAME)
+      });
+    } catch (err) {
+      skipped.push({
+        entry: entry.name,
+        reason: `unreadable: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return { bundles, skipped };
+}
+async function persistImportedSkills(options) {
+  const imported = [];
+  const rejected = [];
+  for (const bundle of options.bundles) {
+    const title = (bundle.description ?? bundle.name ?? bundle.slug).trim() || bundle.slug;
+    const content = bundle.steps ? buildProcedurePersistBody(title, bundle.steps) : bundle.body;
+    const envelope = composeMemoryEnvelope(
+      {
+        content,
+        category: "procedure",
+        tags: ["skill-import", "procedure"],
+        structuredAttributes: {
+          skill_slug: bundle.slug,
+          // Basename only — never an operator's absolute path.
+          skill_source: `${bundle.slug}/${SKILL_FILE_NAME}`,
+          ...bundle.provenance.memoryId ? { skill_origin_memory_id: bundle.provenance.memoryId } : {},
+          ...bundle.hasUnimportedResources ? { hasUnimportedResources: "true" } : {}
+        }
+      },
+      { source: SKILL_IMPORT_SOURCE },
+      // Machine-generated / externally authored input — salvage, warn on drops.
+      { salvage: true }
+    );
+    if (envelope.salvageNotes.length > 0) {
+      log.warn(`skill-import write salvaged invalid fields: ${envelope.salvageNotes.join("; ")}`);
+    }
+    const written = await options.storage.writeSealedMemory(envelope, { status: "pending_review" });
+    if (written.tombstoneBlocked) {
+      rejected.push({ slug: bundle.slug, reason: "blocked by a tombstone; left for review" });
+      continue;
+    }
+    imported.push({
+      slug: bundle.slug,
+      memoryId: written.id,
+      steps: bundle.steps?.length ?? 0,
+      hasUnimportedResources: bundle.hasUnimportedResources
+    });
+  }
+  return { imported, rejected };
+}
+
+// src/cli/skills-commands.ts
+function parseMaxSkills(raw, fallback) {
+  if (raw === void 0 || raw === null || raw === "") return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`Invalid --max-skills '${String(raw)}'. Expected a non-negative integer (0 exports nothing).`);
+  }
+  return value;
+}
+function registerSkillsCommands(exportCmd, importCmd, orchestrator) {
+  exportCmd.command("skills").description(
+    "Export active procedure memories as portable skills/<slug>/SKILL.md bundles (issue #2369). Read-only with respect to memory."
+  ).option("--out <dir>", "Output directory (e.g. a host skills dir or a git repo)").option("--max-skills <n>", "Cap on exported bundles (0 exports none; default from config)").option("--namespace <ns>", "Namespace to export (default: config defaultNamespace)", "").action(async (...args) => {
+    const options = args[0] ?? {};
+    const out = options.out ? String(options.out) : "";
+    if (!out) {
+      console.error("Missing --out. Example: remnic export skills --out ./exported-skills");
+      process.exitCode = 1;
+      return;
+    }
+    if (orchestrator.config.procedural.enabled !== true) {
+      console.error(
+        "procedural memory is disabled (procedural.enabled=false); there are no procedure memories to export."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    let maxSkills;
+    try {
+      maxSkills = parseMaxSkills(options.maxSkills, orchestrator.config.procedural.skillProjection.maxSkills);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+      return;
+    }
+    const namespace = options.namespace ? String(options.namespace) : "";
+    const storage = await orchestrator.getStorageForNamespace(namespace || void 0);
+    const bundles = projectProceduresToSkills(await storage.readAllMemories(), {
+      maxSkills,
+      reservedSlugs: BUILTIN_SKILLS.map((skill) => skill.slug)
+    });
+    const result = await exportSkillBundles({ bundles, outDir: expandTildePath(out) });
+    console.log(`Exported ${result.slugs.length} skill bundle(s) to ${result.outDir}`);
+    for (const slug of result.slugs) {
+      console.log(`  ${slug}/SKILL.md`);
+    }
+    console.log("OK");
+  });
+  importCmd.command("skills <dir>").description(
+    "Import skills/<slug>/SKILL.md bundles as pending_review procedure memories (issue #2369). Never executes bundle scripts."
+  ).option("--namespace <ns>", "Namespace to import into (default: config defaultNamespace)", "").action(async (...args) => {
+    const dir = args[0] ? String(args[0]) : "";
+    const options = args[1] ?? {};
+    if (!dir) {
+      console.error("Usage: remnic import skills <dir>");
+      process.exitCode = 1;
+      return;
+    }
+    if (orchestrator.config.procedural.enabled !== true) {
+      console.error(
+        "procedural memory is disabled (procedural.enabled=false); enable it before importing procedures."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    let read;
+    try {
+      read = await readSkillBundlesFromDir(expandTildePath(dir));
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+      return;
+    }
+    for (const skip of read.skipped) {
+      console.log(`Skipped ${skip.entry}: ${skip.reason}`);
+    }
+    if (read.bundles.length === 0) {
+      console.log("No SKILL.md bundles found.");
+      console.log("OK");
+      return;
+    }
+    const namespace = options.namespace ? String(options.namespace) : "";
+    const storage = await orchestrator.getStorageForNamespace(namespace || void 0);
+    const { imported, rejected } = await persistImportedSkills({ storage, bundles: read.bundles });
+    await orchestrator.qmd.probe();
+    if (orchestrator.qmd.isAvailable()) {
+      await orchestrator.qmd.update();
+    } else {
+      console.log(`QMD unavailable in this process; skipped reindex. Status: ${orchestrator.qmd.debugStatus()}`);
+    }
+    console.log(`Imported ${imported.length} procedure(s) as pending_review (promote after review).`);
+    for (const record of imported) {
+      const resources = record.hasUnimportedResources ? " [has unimported resources]" : "";
+      console.log(`  ${record.slug}: ${record.steps} step(s)${resources}`);
+    }
+    for (const reject of rejected) {
+      console.log(`  ${reject.slug}: ${reject.reason}`);
+    }
+    console.log("OK");
+  });
+}
+
 // src/cli/harmonic-search.ts
 async function runHarmonicSearchCliCommand(options) {
   if (!options.harmonicRetrievalEnabled) return [];
@@ -1714,10 +1968,10 @@ function registerCreationLedgerCommands(cmd, orchestrator) {
 }
 
 // src/maintenance/rebuild-memory-lifecycle-ledger-cli.ts
-import path3 from "path";
+import path4 from "path";
 async function runRebuildMemoryLifecycleLedgerCliCommand(options) {
   const storage = options.storage;
-  const ledgerPath = path3.join(options.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+  const ledgerPath = path4.join(options.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
   const encrypted = await probeEncryptedRegularFileHeader(ledgerPath);
   if (encrypted && !(storage?.isSecureStoreUnlocked() ?? false)) {
     throw new Error(
@@ -2214,8 +2468,8 @@ assistant> ${result.reply}
 
 // src/training-export/converter.ts
 import { constants } from "fs";
-import { lstat, open, readdir, realpath } from "fs/promises";
-import path4 from "path";
+import { lstat as lstat2, open, readdir as readdir2, realpath as realpath2 } from "fs/promises";
+import path5 from "path";
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
   if (!match) return null;
@@ -2249,40 +2503,40 @@ function parseFrontmatter(raw) {
 }
 async function safeRealpath(p) {
   try {
-    return await realpath(p);
+    return await realpath2(p);
   } catch {
     return null;
   }
 }
 function isContainedPath(real, containmentRoot) {
-  return real === containmentRoot || real.startsWith(containmentRoot + path4.sep);
+  return real === containmentRoot || real.startsWith(containmentRoot + path5.sep);
 }
 async function collectMarkdownFiles(dir, containmentRoot) {
   const files = [];
   const walk = async (d) => {
     let dStat = null;
     try {
-      dStat = await lstat(d);
+      dStat = await lstat2(d);
     } catch {
       return;
     }
     if (dStat.isSymbolicLink()) return;
     let entries;
     try {
-      entries = await readdir(d, { withFileTypes: true });
+      entries = await readdir2(d, { withFileTypes: true });
     } catch {
       return;
     }
     const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of sorted) {
-      const full = path4.join(d, entry.name);
+      const full = path5.join(d, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         let st = null;
         try {
-          st = await lstat(full);
+          st = await lstat2(full);
         } catch {
           continue;
         }
@@ -2357,9 +2611,9 @@ async function convertMemoriesToRecords(options) {
   const { memoryDir } = options;
   const containmentRoot = await safeRealpath(memoryDir);
   if (!containmentRoot) return [];
-  const dirs = RECALL_FALLBACK_DIRS.map((dir) => path4.join(memoryDir, dir));
+  const dirs = RECALL_FALLBACK_DIRS.map((dir) => path5.join(memoryDir, dir));
   if (options.includeEntities) {
-    dirs.push(path4.join(memoryDir, "entities"));
+    dirs.push(path5.join(memoryDir, "entities"));
   }
   const allFiles = [];
   for (const dir of dirs) {
@@ -3367,7 +3621,7 @@ function policyVersionForValues(values, config) {
   return createHash("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path5.join(config.memoryDir, "state", fileName);
+  const filePath = path6.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -3972,7 +4226,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
 }
 async function runReplayCliCommand(orchestrator, options) {
   const extractionIdleTimeoutMs = Number.isFinite(options.extractionIdleTimeoutMs) ? Math.max(1e3, Math.floor(options.extractionIdleTimeoutMs)) : 15 * 6e4;
-  const inputRaw = await readFile(options.inputPath, "utf-8");
+  const inputRaw = await readFile2(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -4064,7 +4318,7 @@ async function runBulkImportCliCommand(opts) {
       "Bulk import persistence is not wired: no ingestBatch callback was provided by the host CLI. Use --dry-run to validate without persisting, or invoke via `openclaw engram bulk-import` which supplies the orchestrator-backed ingestion path."
     );
   }
-  const inputRaw = await readFile(opts.file, "utf-8");
+  const inputRaw = await readFile2(opts.file, "utf-8");
   let inputParsed;
   try {
     inputParsed = JSON.parse(inputRaw);
@@ -4128,7 +4382,7 @@ async function runBulkImportCliCommand(opts) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile(pkgPath, "utf-8");
+    const raw = await readFile2(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -4144,7 +4398,7 @@ async function exists(p) {
   }
 }
 function assertSafeNamespaceSegment(namespace) {
-  if (namespace.length === 0 || namespace === "." || namespace === ".." || namespace.includes("/") || namespace.includes("\\") || path5.isAbsolute(namespace) || path5.win32.isAbsolute(namespace)) {
+  if (namespace.length === 0 || namespace === "." || namespace === ".." || namespace.includes("/") || namespace.includes("\\") || path6.isAbsolute(namespace) || path6.win32.isAbsolute(namespace)) {
     throw new Error(`invalid namespace: ${namespace}`);
   }
 }
@@ -4167,7 +4421,7 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace, options) {
 async function walkMemoryMarkdownFiles(memoryDir, visit) {
   let memoryRootReal;
   try {
-    memoryRootReal = await realpath2(memoryDir);
+    memoryRootReal = await realpath3(memoryDir);
   } catch {
     return;
   }
@@ -4178,25 +4432,25 @@ async function walkMemoryMarkdownFiles(memoryDir, visit) {
   };
   const walk = async (dir) => {
     try {
-      const dirStat = await lstat2(dir);
+      const dirStat = await lstat3(dir);
       if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) return;
-      assertPathInsideRoot(memoryRootReal, await realpath2(dir), dir);
+      assertPathInsideRoot(memoryRootReal, await realpath3(dir), dir);
     } catch (err) {
       skip(dir, err);
       return;
     }
     let entries;
     try {
-      entries = await readdir2(dir, { withFileTypes: true });
+      entries = await readdir3(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path5.join(dir, entryName);
+      const fullPath = path6.join(dir, entryName);
       try {
-        assertPathInsideRoot(memoryRootReal, await realpath2(fullPath), fullPath);
+        assertPathInsideRoot(memoryRootReal, await realpath3(fullPath), fullPath);
       } catch (err) {
         skip(fullPath, err);
         continue;
@@ -4209,7 +4463,7 @@ async function walkMemoryMarkdownFiles(memoryDir, visit) {
       await visit(fullPath);
     }
   };
-  for (const root of RECALL_FALLBACK_DIRS.map((dir) => path5.join(memoryDir, dir))) {
+  for (const root of RECALL_FALLBACK_DIRS.map((dir) => path6.join(memoryDir, dir))) {
     await walk(root);
   }
 }
@@ -4224,7 +4478,7 @@ async function readAllMemoryFiles(memoryDir) {
   const out = [];
   await walkMemoryMarkdownFiles(memoryDir, async (fullPath) => {
     try {
-      const raw = await readFile(fullPath, "utf-8");
+      const raw = await readFile2(fullPath, "utf-8");
       const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
       if (!parsed) return;
       const fmRaw = parsed[1];
@@ -4819,7 +5073,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         if (plan.moved.length > 0) {
           console.log("\nEntries:");
           for (const move of plan.moved) {
-            console.log(`- ${path5.basename(move.from)}`);
+            console.log(`- ${path6.basename(move.from)}`);
           }
         }
         if (dryRun) {
@@ -4901,7 +5155,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           console.log(formatNamespaceMaintenanceHealthText(summary));
         }
       });
-      cmd.command("export").description("Export Remnic memory to JSON, Markdown bundle, or SQLite").option("--format <format>", "Export format: json|md|sqlite", "json").option("--out <path>", "Output path (dir for json/md, file for sqlite)").option("--include-transcripts", "Include transcripts in export (default: false)").option("--namespace <ns>", "Namespace to export (v3.0+, default: config defaultNamespace)", "").action(async (...args) => {
+      const exportCmd = cmd.command("export").description("Export Remnic memory to JSON, Markdown bundle, or SQLite").option("--format <format>", "Export format: json|md|sqlite", "json").option("--out <path>", "Output path (dir for json/md, file for sqlite)").option("--include-transcripts", "Include transcripts in export (default: false)").option("--namespace <ns>", "Namespace to export (v3.0+, default: config defaultNamespace)", "").action(async (...args) => {
         const options = args[0] ?? {};
         const format = String(options.format ?? "json");
         const out = options.out ? String(options.out) : "";
@@ -4944,7 +5198,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         }
         console.log("OK");
       });
-      cmd.command("import").description("Import Remnic memory from JSON bundle, Markdown bundle, or SQLite").option("--from <path>", "Import source path (dir or file)").option("--format <format>", "Import format: auto|json|md|sqlite", "auto").option("--conflict <mode>", "Conflict policy: skip|overwrite|dedupe", "skip").option("--dry-run", "Validate import without writing files").option("--namespace <ns>", "Namespace to import into (v3.0+, default: config defaultNamespace)", "").action(async (...args) => {
+      const importCmd = cmd.command("import").description("Import Remnic memory from JSON bundle, Markdown bundle, or SQLite").option("--from <path>", "Import source path (dir or file)").option("--format <format>", "Import format: auto|json|md|sqlite", "auto").option("--conflict <mode>", "Conflict policy: skip|overwrite|dedupe", "skip").option("--dry-run", "Validate import without writing files").option("--namespace <ns>", "Namespace to import into (v3.0+, default: config defaultNamespace)", "").action(async (...args) => {
         const options = args[0] ?? {};
         const from = options.from ? String(options.from) : "";
         const formatOpt = String(options.format ?? "auto");
@@ -4989,6 +5243,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         }
         console.log("OK");
       });
+      registerSkillsCommands(exportCmd, importCmd, orchestrator);
       cmd.command("backup").description("Create a timestamped backup of the Remnic memory directory").option("--out-dir <dir>", "Backup root directory").option("--retention-days <n>", "Delete backups older than N days", "0").option("--include-transcripts", "Include transcripts (default false)").option("--namespace <ns>", "Namespace to back up (v3.0+, default: config defaultNamespace)", "").option("--encrypt", "Encrypt the backup archive with the secure-store master key (must be unlocked)").action(async (...args) => {
         const options = args[0] ?? {};
         const outDir = options.outDir ? String(options.outDir) : "";
@@ -5118,15 +5373,15 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const capsulesDir = defaultCapsulesDir(memoryDir);
         const { stat: statMerge } = await import("fs/promises");
         let sourceArchive = expandTildePath(parsed.archive);
-        const looksLikePath = sourceArchive.startsWith("/") || sourceArchive.startsWith("./") || sourceArchive.startsWith("../") || sourceArchive.includes(path5.sep);
+        const looksLikePath = sourceArchive.startsWith("/") || sourceArchive.startsWith("./") || sourceArchive.startsWith("../") || sourceArchive.includes(path6.sep);
         if (!looksLikePath) {
-          const cwdResolved = path5.resolve(sourceArchive);
+          const cwdResolved = path6.resolve(sourceArchive);
           const cwdSt = await statMerge(cwdResolved).catch(() => null);
           if (cwdSt && cwdSt.isFile()) {
             sourceArchive = cwdResolved;
           } else {
-            const byId = path5.join(capsulesDir, `${sourceArchive}.capsule.json.gz`);
-            const byIdEnc = path5.join(capsulesDir, `${sourceArchive}.capsule.json.gz.enc`);
+            const byId = path6.join(capsulesDir, `${sourceArchive}.capsule.json.gz`);
+            const byIdEnc = path6.join(capsulesDir, `${sourceArchive}.capsule.json.gz.enc`);
             const stId = await statMerge(byId).catch(() => null);
             if (stId && stId.isFile()) {
               sourceArchive = byId;
@@ -5184,10 +5439,10 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const dirWasExplicit = typeof opts.dir === "string" && opts.dir.trim() !== "";
         const parsed = parseCapsuleListOptions(opts, defaultDir);
         const capsulesDir = expandTildePath(parsed.capsulesDir);
-        const { readdir: readdir3, readFile: readFile2, stat } = await import("fs/promises");
+        const { readdir: readdir4, readFile: readFile3, stat } = await import("fs/promises");
         let dirEntries;
         try {
-          dirEntries = await readdir3(capsulesDir);
+          dirEntries = await readdir4(capsulesDir);
         } catch (err) {
           const code = err.code;
           if (dirWasExplicit) {
@@ -5207,10 +5462,10 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         ).sort();
         const entries = [];
         for (const archiveName of archives) {
-          const archivePath = path5.join(capsulesDir, archiveName);
+          const archivePath = path6.join(capsulesDir, archiveName);
           const id = archiveName.replace(/\.capsule\.json\.gz\.enc$/, "").replace(/\.capsule\.json\.gz$/, "");
           const manifestName = `${id}.manifest.json`;
-          const manifestPath = path5.join(capsulesDir, manifestName);
+          const manifestPath = path6.join(capsulesDir, manifestName);
           let createdAt = null;
           let pluginVersion = null;
           let fileCount = null;
@@ -5223,7 +5478,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           }
           if (hasManifest) {
             try {
-              const raw = await readFile2(manifestPath, "utf-8");
+              const raw = await readFile3(manifestPath, "utf-8");
               const sidecar = JSON.parse(raw);
               createdAt = typeof sidecar.createdAt === "string" ? sidecar.createdAt : null;
               pluginVersion = typeof sidecar.pluginVersion === "string" ? sidecar.pluginVersion : null;
@@ -5265,15 +5520,15 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const parsed = parseCapsuleInspectOptions(archiveArg, opts);
         const { stat } = await import("fs/promises");
         let archivePath = expandTildePath(parsed.archive);
-        const looksLikePath = archivePath.startsWith("/") || archivePath.startsWith("./") || archivePath.startsWith("../") || archivePath.includes(path5.sep);
+        const looksLikePath = archivePath.startsWith("/") || archivePath.startsWith("./") || archivePath.startsWith("../") || archivePath.includes(path6.sep);
         if (!looksLikePath) {
-          const cwdResolved = path5.resolve(archivePath);
+          const cwdResolved = path6.resolve(archivePath);
           const cwdSt = await stat(cwdResolved).catch(() => null);
           if (cwdSt && cwdSt.isFile()) {
             archivePath = cwdResolved;
           } else {
-            const byId = path5.join(capsulesDir, `${archivePath}.capsule.json.gz`);
-            const byIdEnc = path5.join(capsulesDir, `${archivePath}.capsule.json.gz.enc`);
+            const byId = path6.join(capsulesDir, `${archivePath}.capsule.json.gz`);
+            const byIdEnc = path6.join(capsulesDir, `${archivePath}.capsule.json.gz.enc`);
             const st = await stat(byId).catch(() => null);
             if (st && st.isFile()) {
               archivePath = byId;
@@ -5289,8 +5544,8 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const sidecarPath = archivePath.replace(/\.enc$/, "").replace(/\.capsule\.json\.gz$/, ".manifest.json");
         let sidecar = null;
         try {
-          const { readFile: readFile2 } = await import("fs/promises");
-          const raw = await readFile2(sidecarPath, "utf-8");
+          const { readFile: readFile3 } = await import("fs/promises");
+          const raw = await readFile3(sidecarPath, "utf-8");
           sidecar = JSON.parse(raw);
         } catch {
         }
@@ -5327,10 +5582,10 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           }
           manifest = parsed2.bundle.manifest;
         } else {
-          const { readFile: readFile2 } = await import("fs/promises");
+          const { readFile: readFile3 } = await import("fs/promises");
           const { gunzipSync } = await import("zlib");
           const { parseExportBundle } = await import("./transfer/types.js");
-          const buf = await readFile2(archivePath);
+          const buf = await readFile3(archivePath);
           const json = gunzipSync(buf).toString("utf-8");
           const parsed2 = parseExportBundle(JSON.parse(json));
           if (parsed2.capsuleVersion !== 2) {
@@ -7264,7 +7519,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           return;
         }
         const expandedTarget = expandTildePath(rawTarget);
-        const targetPath = path5.isAbsolute(expandedTarget) ? expandedTarget : path5.join(orchestrator.config.memoryDir, expandedTarget);
+        const targetPath = path6.isAbsolute(expandedTarget) ? expandedTarget : path6.join(orchestrator.config.memoryDir, expandedTarget);
         const { runConsolidationUndo, formatConsolidationUndoResult } = await import("./consolidation-undo.js");
         const result = await runConsolidationUndo({
           storage: orchestrator.storage,
@@ -7302,7 +7557,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path5.join(resolveHomeDir(), ".openclaw", "workspace");
+        const workspaceDir = path6.join(resolveHomeDir(), ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -7525,8 +7780,8 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path5.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path5.join(memoryDir, "threads"));
+        const memoryDir = path6.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path6.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -8444,6 +8699,9 @@ function parseDuration(duration) {
 export {
   INJECTION_SCREEN_THRESHOLD,
   screenCandidateFact,
+  exportSkillBundles,
+  readSkillBundlesFromDir,
+  persistImportedSkills,
   auditMemoryStore,
   formatAuditMemoryReport,
   registerWearableConnector,
@@ -8553,4 +8811,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-7QOO4LGC.js.map
+//# sourceMappingURL=chunk-3JZBPTLD.js.map