@cleocode/caamp 2026.5.84 → 2026.5.87

package/dist/{chunk-QSJSM57K.js → chunk-WXL7RPS4.js}

@@ -3182,13 +3182,13 @@ async function scanFile(filePath, rules) {
 }
 async function scanDirectory(dirPath) {
   const { readdir: readdir4 } = await import("fs/promises");
-  const { join: join10 } = await import("path");
+  const { join: join11 } = await import("path");
   if (!existsSync10(dirPath)) return [];
   const entries = await readdir4(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillFile = join10(dirPath, entry.name, "SKILL.md");
+      const skillFile = join11(dirPath, entry.name, "SKILL.md");
       if (existsSync10(skillFile)) {
         results.push(await scanFile(skillFile));
       }
@@ -3554,6 +3554,10 @@ var ErrorCodes = {
   INVALID_FORMAT: "E_INVALID_FORMAT",
   // Operation errors
   INSTALL_FAILED: "E_INSTALL_FAILED",
+  // Skills federation gates (T9564 — Sphere B)
+  SKILL_TRUST_GATE_BLOCKED: "E_SKILL_TRUST_GATE_BLOCKED",
+  FEDERATION_UNKNOWN_SOURCE_INTERACTIVE_REQUIRED: "E_FEDERATION_UNKNOWN_SOURCE_INTERACTIVE_REQUIRED",
+  FEDERATION_CHECKSUM_MISMATCH: "E_FEDERATION_CHECKSUM_MISMATCH",
   REMOVE_FAILED: "E_REMOVE_FAILED",
   UPDATE_FAILED: "E_UPDATE_FAILED",
   VALIDATION_FAILED: "E_VALIDATION_FAILED",
@@ -3820,6 +3824,384 @@ function registerDoctorBridge(parent) {
   );
 }
 
+// src/commands/skills/doctor-adopt.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  cpSync,
+  existsSync as existsSync13,
+  lstatSync as lstatSync4,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  realpathSync as realpathSync2,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join7 } from "path";
+import { createInterface } from "readline/promises";
+import pc2 from "picocolors";
+function cleoSkillsRoot() {
+  return join7(homedir4(), ".cleo", "skills");
+}
+function legacyAgentsSkillsRoot() {
+  return join7(homedir4(), ".local", "share", "agents", "skills");
+}
+function homeAgentsSkillsRoot() {
+  return join7(homedir4(), ".agents", "skills");
+}
+function archiveRoot() {
+  return join7(cleoSkillsRoot(), ".archive");
+}
+function auditLogRoot() {
+  return join7(cleoSkillsRoot(), ".audit-log");
+}
+function listCandidates(root) {
+  if (!existsSync13(root)) return [];
+  let entries;
+  try {
+    entries = readdirSync2(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    const full = join7(root, name);
+    let isDirLike = false;
+    try {
+      const stat4 = lstatSync4(full);
+      if (stat4.isDirectory()) {
+        isDirLike = true;
+      } else if (stat4.isSymbolicLink()) {
+        try {
+          const real = statSync(full);
+          isDirLike = real.isDirectory();
+        } catch {
+          isDirLike = false;
+        }
+      }
+    } catch {
+      isDirLike = false;
+    }
+    if (isDirLike) {
+      out.push({ name, path: full });
+    }
+  }
+  return out;
+}
+function approxDirSize(dir) {
+  let total = 0;
+  try {
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      try {
+        const stat4 = statSync(join7(dir, entry));
+        if (stat4.isFile()) total += stat4.size;
+      } catch {
+      }
+    }
+  } catch {
+    return 0;
+  }
+  return total;
+}
+function discoverOrphans(registeredNames) {
+  const cleoRoot = cleoSkillsRoot();
+  const legacyRoot = legacyAgentsSkillsRoot();
+  const homeRoot = homeAgentsSkillsRoot();
+  const seen = /* @__PURE__ */ new Map();
+  const visit = (root, via, filter) => {
+    for (const candidate of listCandidates(root)) {
+      if (seen.has(candidate.name)) continue;
+      if (registeredNames.has(candidate.name)) continue;
+      if (filter && !filter(candidate.path)) continue;
+      seen.set(candidate.name, {
+        name: candidate.name,
+        path: candidate.path,
+        discoveredVia: via,
+        hasSkillMd: existsSync13(join7(candidate.path, "SKILL.md")),
+        sizeBytes: approxDirSize(candidate.path)
+      });
+    }
+  };
+  visit(cleoRoot, "cleo");
+  visit(legacyRoot, "legacy-agents");
+  visit(homeRoot, "home-agents", (path2) => {
+    try {
+      const real = realpathSync2(path2);
+      return !real.startsWith(`${cleoRoot}/`);
+    } catch {
+      return true;
+    }
+  });
+  return Array.from(seen.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function canonicalAdoptRefusal() {
+  return {
+    code: "E_CANONICAL_ADOPT_REFUSED",
+    message: "Canonical adoption is refused on user machines. Canonical skills are owned by the CLEO core team and ONLY the owner-CI workflow may write them (architecture-v3 \xA76 invariant).",
+    remediation: "To contribute this skill to canonical: clone https://github.com/kryptobaseddev/cleo, place the skill under packages/skills/skills/<name>/, and open a PR. Local user-machine canonical writes are blocked by design."
+  };
+}
+function buildAdoptedRow(orphan, now) {
+  return {
+    name: orphan.name,
+    installPath: orphan.path,
+    installedAt: now,
+    sourceType: "user",
+    lifecycleState: "active"
+  };
+}
+function archiveAndDelete(orphan, now) {
+  const tsToken = now.replace(/[:.]/g, "-");
+  const archiveDir = join7(archiveRoot(), `${orphan.name}-${tsToken}`);
+  mkdirSync(archiveRoot(), { recursive: true });
+  cpSync(orphan.path, archiveDir, { recursive: true, dereference: false });
+  rmSync(orphan.path, { recursive: true, force: true });
+  return archiveDir;
+}
+async function applyDecision(orphan, decision, now, recordRow) {
+  const base = {
+    orphan,
+    decidedAt: now
+  };
+  if (decision === "canonical-adopt") {
+    return {
+      ...base,
+      decision,
+      applied: false,
+      refusal: canonicalAdoptRefusal(),
+      archivedTo: null
+    };
+  }
+  if (decision === "skip") {
+    return { ...base, decision, applied: true, refusal: null, archivedTo: null };
+  }
+  if (decision === "user-adopt") {
+    try {
+      await recordRow(buildAdoptedRow(orphan, now));
+      return { ...base, decision, applied: true, refusal: null, archivedTo: null };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        ...base,
+        decision,
+        applied: false,
+        refusal: {
+          code: "E_CANONICAL_ADOPT_REFUSED",
+          message: `user-adopt failed: ${message}`,
+          remediation: "Initialise the registry with `cleo skills list` then re-run."
+        },
+        archivedTo: null
+      };
+    }
+  }
+  try {
+    const archived = archiveAndDelete(orphan, now);
+    return { ...base, decision, applied: true, refusal: null, archivedTo: archived };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ...base,
+      decision,
+      applied: false,
+      refusal: {
+        code: "E_CANONICAL_ADOPT_REFUSED",
+        message: `delete failed: ${message}`,
+        remediation: "Inspect filesystem permissions and rerun with --non-interactive to verify."
+      },
+      archivedTo: null
+    };
+  }
+}
+function writeAuditLog(result) {
+  const dir = auditLogRoot();
+  mkdirSync(dir, { recursive: true });
+  const tsToken = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const path2 = join7(dir, `adopt-${tsToken}.json`);
+  const tmp = `${path2}.tmp`;
+  const payload = {
+    runId: randomUUID2(),
+    writtenAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...result
+  };
+  writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  renameSync(tmp, path2);
+  return path2;
+}
+async function promptDecision(rl, orphan) {
+  const kb = Math.round(orphan.sizeBytes / 1024);
+  process.stderr.write(
+    `
+${pc2.bold(orphan.name)}
+  path: ${orphan.path}
+  via:  ${orphan.discoveredVia}
+  size: ~${kb} KiB
+  SKILL.md: ${orphan.hasSkillMd ? "yes" : "no"}
+`
+  );
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const answer = (await rl.question("  [c]anonical-adopt | [u]ser-adopt | [d]elete | [s]kip: ")).trim().toLowerCase();
+    if (answer === "c" || answer === "canonical" || answer === "canonical-adopt") {
+      return "canonical-adopt";
+    }
+    if (answer === "u" || answer === "user" || answer === "user-adopt") {
+      return "user-adopt";
+    }
+    if (answer === "d" || answer === "delete") return "delete";
+    if (answer === "s" || answer === "skip" || answer === "") return "skip";
+    process.stderr.write(`  ${pc2.yellow("unrecognised input \u2014 try one of c/u/d/s")}
+`);
+  }
+  return "skip";
+}
+async function runDoctorAdopt(options) {
+  const discover = options.discoverFn ?? discoverOrphans;
+  const registeredNames = await options.loadRegisteredNames();
+  const orphans = discover(registeredNames);
+  const results = [];
+  const mode = options.nonInteractive ? "non-interactive" : options.autoUserAdopt ? "auto-user-adopt" : "interactive";
+  if (orphans.length === 0) {
+    const empty = {
+      totalOrphans: 0,
+      results: [],
+      auditLogPath: "",
+      mode
+    };
+    if (!options.skipAuditLog) empty.auditLogPath = writeAuditLog(empty);
+    return empty;
+  }
+  if (mode === "non-interactive") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const orphan of orphans) {
+      results.push({
+        orphan,
+        decision: "skip",
+        applied: true,
+        refusal: null,
+        archivedTo: null,
+        decidedAt: now
+      });
+    }
+  } else if (mode === "auto-user-adopt") {
+    for (const orphan of orphans) {
+      results.push(
+        await applyDecision(orphan, "user-adopt", (/* @__PURE__ */ new Date()).toISOString(), options.recordRow)
+      );
+    }
+  } else {
+    const promptFn = options.prompt ?? (async (orphan) => {
+      const rl = createInterface({ input: process.stdin, output: process.stderr });
+      try {
+        return await promptDecision(rl, orphan);
+      } finally {
+        rl.close();
+      }
+    });
+    for (const orphan of orphans) {
+      const decision = await promptFn(orphan);
+      results.push(
+        await applyDecision(orphan, decision, (/* @__PURE__ */ new Date()).toISOString(), options.recordRow)
+      );
+    }
+  }
+  const result = {
+    totalOrphans: orphans.length,
+    results,
+    auditLogPath: "",
+    mode
+  };
+  if (!options.skipAuditLog) result.auditLogPath = writeAuditLog(result);
+  return result;
+}
+var caampStandaloneAdapters = {
+  loadRegisteredNames: () => /* @__PURE__ */ new Set(),
+  recordRow: () => {
+    throw new Error(
+      "caamp standalone CLI cannot write to skills.db. Use `cleo skills doctor adopt-orphans` instead."
+    );
+  }
+};
+function registerSkillsDoctorAdopt(parent, adapters = caampStandaloneAdapters) {
+  const existing = parent.commands.find((c) => c.name() === "doctor");
+  const doctor = existing ?? parent.command("doctor").description("Diagnostics + repair for the skill system");
+  doctor.command("adopt-orphans").description(
+    "Interactive audit of on-disk skill dirs not tracked in skills.db (canonical/user/delete/skip)"
+  ).option("--json", "Output as LAFS JSON envelope (default)").option("--human", "Output a colorised human-readable summary").option("--non-interactive", "List orphans + exit without action").option("--auto-user-adopt", "Bulk-mark all orphans as source_type=user without prompting").action(
+    async (opts) => {
+      const operation = "skills.doctor.adopt-orphans";
+      const mvi = "standard";
+      let format;
+      try {
+        format = resolveFormat({
+          jsonFlag: opts.json ?? false,
+          humanFlag: opts.human ?? false,
+          projectDefault: "json"
+        });
+      } catch (error) {
+        handleFormatError(error, operation, mvi, opts.json);
+      }
+      try {
+        const result = await runDoctorAdopt({
+          nonInteractive: opts.nonInteractive ?? false,
+          autoUserAdopt: opts.autoUserAdopt ?? false,
+          loadRegisteredNames: adapters.loadRegisteredNames,
+          recordRow: adapters.recordRow
+        });
+        if (format === "json") {
+          outputSuccess(operation, mvi, result);
+          return;
+        }
+        const ok = result.results.filter((r) => r.applied);
+        const blocked = result.results.filter((r) => !r.applied);
+        console.log(pc2.bold(`
+skills doctor adopt-orphans (${result.mode})
+`));
+        console.log(
+          `  ${pc2.bold("Discovered")}: ${result.totalOrphans} orphan${result.totalOrphans === 1 ? "" : "s"}`
+        );
+        for (const r of result.results) {
+          const icon = r.decision === "skip" ? pc2.dim("\xB7") : r.applied ? pc2.green("\u2713") : pc2.red("\u2717");
+          const verb = r.applied ? r.decision : `${r.decision} (refused)`;
+          console.log(`  ${icon} ${r.orphan.name.padEnd(32)} ${pc2.dim(verb)}`);
+          if (r.refusal) {
+            console.log(`      ${pc2.yellow(r.refusal.message)}`);
+            console.log(`      ${pc2.dim(r.refusal.remediation)}`);
+          }
+          if (r.archivedTo) {
+            console.log(`      ${pc2.dim(`archived \u2192 ${r.archivedTo}`)}`);
+          }
+        }
+        console.log(
+          `
+  ${pc2.bold("Summary")}: ${pc2.green(`${ok.length} applied`)}, ${pc2.red(`${blocked.length} blocked`)}`
+        );
+        if (result.auditLogPath) {
+          console.log(`  ${pc2.dim(`audit log \u2192 ${result.auditLogPath}`)}`);
+        }
+        console.log();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+          emitJsonError(
+            operation,
+            mvi,
+            ErrorCodes.INTERNAL_ERROR,
+            message,
+            ErrorCategories.INTERNAL
+          );
+        } else {
+          console.error(pc2.red(`Error: ${message}`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+}
+
 // src/core/network/fetch.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
 var NetworkError = class extends Error {
@@ -4396,9 +4778,9 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/library-loader.ts
-import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync } from "fs";
 import { createRequire } from "module";
-import { basename as basename3, dirname as dirname4, join as join7 } from "path";
+import { basename as basename3, dirname as dirname4, join as join8 } from "path";
 var require2 = createRequire(import.meta.url);
 function loadLibraryFromModule(root) {
   let mod;
@@ -4444,16 +4826,16 @@ function loadLibraryFromModule(root) {
   return mod;
 }
 function buildLibraryFromFiles(root) {
-  const catalogPath = join7(root, "skills.json");
-  if (!existsSync13(catalogPath)) {
+  const catalogPath = join8(root, "skills.json");
+  if (!existsSync14(catalogPath)) {
     throw new Error(`No skills.json found at ${root}`);
   }
   const catalogData = JSON.parse(readFileSync(catalogPath, "utf-8"));
   const entries = catalogData.skills ?? [];
   const version = catalogData.version ?? "0.0.0";
-  const manifestPath = join7(root, "skills", "manifest.json");
+  const manifestPath = join8(root, "skills", "manifest.json");
   let manifest;
-  if (existsSync13(manifestPath)) {
+  if (existsSync14(manifestPath)) {
     manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
   } else {
     manifest = {
@@ -4463,14 +4845,14 @@ function buildLibraryFromFiles(root) {
       skills: []
     };
   }
-  const profilesDir = join7(root, "profiles");
+  const profilesDir = join8(root, "profiles");
   const profiles = /* @__PURE__ */ new Map();
-  if (existsSync13(profilesDir)) {
-    for (const file of readdirSync2(profilesDir)) {
+  if (existsSync14(profilesDir)) {
+    for (const file of readdirSync3(profilesDir)) {
       if (!file.endsWith(".json")) continue;
       try {
         const profile = JSON.parse(
-          readFileSync(join7(profilesDir, file), "utf-8")
+          readFileSync(join8(profilesDir, file), "utf-8")
         );
         profiles.set(profile.name, profile);
       } catch {
@@ -4484,9 +4866,9 @@ function buildLibraryFromFiles(root) {
   function getSkillDir2(name) {
     const entry = skillMap.get(name);
     if (entry) {
-      return dirname4(join7(root, entry.path));
+      return dirname4(join8(root, entry.path));
     }
-    return join7(root, "skills", name);
+    return join8(root, "skills", name);
   }
   function resolveDeps(names, visited = /* @__PURE__ */ new Set()) {
     const result = [];
@@ -4514,8 +4896,8 @@ function buildLibraryFromFiles(root) {
     return resolveDeps([...new Set(skills)]);
   }
   function discoverFiles(dir, ext) {
-    if (!existsSync13(dir)) return [];
-    return readdirSync2(dir).filter((f) => f.endsWith(ext)).map((f) => basename3(f, ext));
+    if (!existsSync14(dir)) return [];
+    return readdirSync3(dir).filter((f) => f.endsWith(ext)).map((f) => basename3(f, ext));
   }
   const library = {
     version,
@@ -4531,14 +4913,14 @@ function buildLibraryFromFiles(root) {
     getSkillPath(name) {
       const entry = skillMap.get(name);
       if (entry) {
-        return join7(root, entry.path);
+        return join8(root, entry.path);
       }
-      return join7(root, "skills", name, "SKILL.md");
+      return join8(root, "skills", name, "SKILL.md");
     },
     getSkillDir: getSkillDir2,
     readSkillContent(name) {
       const skillPath = library.getSkillPath(name);
-      if (!existsSync13(skillPath)) {
+      if (!existsSync14(skillPath)) {
         throw new Error(`Skill content not found: ${skillPath}`);
       }
       return readFileSync(skillPath, "utf-8");
@@ -4565,11 +4947,11 @@ function buildLibraryFromFiles(root) {
       return resolveProfileByName(name);
     },
     listSharedResources() {
-      return discoverFiles(join7(root, "skills", "_shared"), ".md");
+      return discoverFiles(join8(root, "skills", "_shared"), ".md");
     },
     getSharedResourcePath(name) {
-      const resourcePath = join7(root, "skills", "_shared", `${name}.md`);
-      return existsSync13(resourcePath) ? resourcePath : void 0;
+      const resourcePath = join8(root, "skills", "_shared", `${name}.md`);
+      return existsSync14(resourcePath) ? resourcePath : void 0;
     },
     readSharedResource(name) {
       const resourcePath = library.getSharedResourcePath(name);
@@ -4577,15 +4959,15 @@ function buildLibraryFromFiles(root) {
       return readFileSync(resourcePath, "utf-8");
     },
     listProtocols() {
-      const rootProtocols = discoverFiles(join7(root, "protocols"), ".md");
+      const rootProtocols = discoverFiles(join8(root, "protocols"), ".md");
       if (rootProtocols.length > 0) return rootProtocols;
-      return discoverFiles(join7(root, "skills", "protocols"), ".md");
+      return discoverFiles(join8(root, "skills", "protocols"), ".md");
     },
     getProtocolPath(name) {
-      const rootPath = join7(root, "protocols", `${name}.md`);
-      if (existsSync13(rootPath)) return rootPath;
-      const skillsPath = join7(root, "skills", "protocols", `${name}.md`);
-      return existsSync13(skillsPath) ? skillsPath : void 0;
+      const rootPath = join8(root, "protocols", `${name}.md`);
+      if (existsSync14(rootPath)) return rootPath;
+      const skillsPath = join8(root, "skills", "protocols", `${name}.md`);
+      return existsSync14(skillsPath) ? skillsPath : void 0;
     },
     readProtocol(name) {
       const protocolPath = library.getProtocolPath(name);
@@ -4610,8 +4992,8 @@ function buildLibraryFromFiles(root) {
       if (!entry.version) {
         issues.push({ level: "warn", field: "version", message: "Missing version" });
       }
-      const skillPath = join7(root, entry.path);
-      if (!existsSync13(skillPath)) {
+      const skillPath = join8(root, entry.path);
+      if (!existsSync14(skillPath)) {
         issues.push({
           level: "error",
           field: "path",
@@ -4670,15 +5052,15 @@ __export(catalog_exports, {
   validateAll: () => validateAll,
   validateSkillFrontmatter: () => validateSkillFrontmatter
 });
-import { existsSync as existsSync14 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join9 } from "path";
 var _library = null;
 function registerSkillLibrary(library) {
   _library = library;
 }
 function registerSkillLibraryFromPath(root) {
-  const indexPath = join8(root, "index.js");
-  if (existsSync14(indexPath)) {
+  const indexPath = join9(root, "index.js");
+  if (existsSync15(indexPath)) {
     _library = loadLibraryFromModule(root);
     return;
   }
@@ -4689,13 +5071,13 @@ function clearRegisteredLibrary() {
 }
 function discoverLibrary() {
   const envPath = process.env["CAAMP_SKILL_LIBRARY"];
-  if (envPath && existsSync14(envPath)) {
+  if (envPath && existsSync15(envPath)) {
     try {
-      const indexPath = join8(envPath, "index.js");
-      if (existsSync14(indexPath)) {
+      const indexPath = join9(envPath, "index.js");
+      if (existsSync15(indexPath)) {
         return loadLibraryFromModule(envPath);
       }
-      if (existsSync14(join8(envPath, "skills.json"))) {
+      if (existsSync15(join9(envPath, "skills.json"))) {
         return buildLibraryFromFiles(envPath);
       }
     } catch {
@@ -4802,9 +5184,9 @@ function getLibraryRoot() {
 }
 
 // src/core/skills/discovery.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { readdir as readdir3, readFile as readFile7 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
@@ -4828,8 +5210,8 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join9(skillDir, "SKILL.md");
-  if (!existsSync15(skillFile)) return null;
+  const skillFile = join10(skillDir, "SKILL.md");
+  if (!existsSync16(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
   return {
@@ -4840,12 +5222,12 @@ async function discoverSkill(skillDir) {
   };
 }
 async function discoverSkills(rootDir) {
-  if (!existsSync15(rootDir)) return [];
+  if (!existsSync16(rootDir)) return [];
   const entries = await readdir3(rootDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join9(rootDir, entry.name);
+    const skillDir = join10(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -4869,7 +5251,7 @@ async function discoverSkillsMulti(dirs) {
 }
 
 // src/core/skills/validator.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { readFile as readFile8 } from "fs/promises";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
@@ -4891,7 +5273,7 @@ var WARN_BODY_LINES = 500;
 var WARN_DESCRIPTION_LENGTH = 50;
 async function validateSkill(filePath) {
   const issues = [];
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     return {
       valid: false,
       issues: [{ level: "error", field: "file", message: "File does not exist" }],
@@ -5079,6 +5461,12 @@ export {
   buildBackupTimestamp,
   runDoctorBridge,
   registerDoctorBridge,
+  discoverOrphans,
+  applyDecision,
+  writeAuditLog,
+  runDoctorAdopt,
+  caampStandaloneAdapters,
+  registerSkillsDoctorAdopt,
   MarketplaceClient,
   RECOMMENDATION_ERROR_CODES,
   tokenizeCriteriaValue,
@@ -5107,4 +5495,4 @@ export {
   discoverSkillsMulti,
   validateSkill
 };
-//# sourceMappingURL=chunk-QSJSM57K.js.map
+//# sourceMappingURL=chunk-WXL7RPS4.js.map