@hasna/skills 0.1.64 → 0.1.66

package/dist/index.js

@@ -47,8 +47,8 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/lib/registry.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync6 } from "fs";
+import { join as join7 } from "path";
 
 // src/lib/config.ts
 import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
@@ -272,15 +272,16 @@ function unsetConfig(key, scope = "project") {
 // src/lib/portable-skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
-  readdirSync as readdirSync4,
+  mkdtempSync,
+  readdirSync as readdirSync5,
   renameSync,
   rmSync,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, normalize as normalize2 } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join6, normalize as normalize2 } from "path";
 
 // src/lib/registry-data/development-tools.ts
 var DEVELOPMENT_TOOLS_SKILLS = [
@@ -991,11 +992,9 @@ var SKILLS = [
   ...EVENT_MANAGEMENT_SKILLS
 ];
 
-// src/lib/skill-validation.ts
-import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { isAbsolute, join as join2, normalize } from "path";
-
 // src/lib/hosted-skill-set.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
 var HOSTED_RUNTIMES = new Set(["hosted"]);
 var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
 function normalizeMarker(value) {
@@ -1007,6 +1006,16 @@ function isHostedMetadataPackage(pkg) {
     return false;
   return HOSTED_RUNTIMES.has(normalizeMarker(skills.runtime)) || HOSTED_SOURCES.has(normalizeMarker(skills.source));
 }
+function isHostedMetadataSkillDir(skillDir) {
+  const pkgPath = join2(skillDir, "package.json");
+  if (!existsSync2(pkgPath))
+    return false;
+  try {
+    return isHostedMetadataPackage(JSON.parse(readFileSync2(pkgPath, "utf8")));
+  } catch {
+    return false;
+  }
+}
 var HOSTED_METADATA_SET_EMPTY_ERROR = [
   "The hosted metadata skill set is empty, but the packaging guards that depend on it",
   "only mean anything while it is non-empty: an empty set makes every one of them pass",
@@ -1023,6 +1032,8 @@ var BRACE_SOURCE_EXCLUSION = new RegExp(`^!skills/\\{(${SLUG}(?:,${SLUG})+)\\}/s
 var SINGLE_SOURCE_EXCLUSION = new RegExp(`^!skills/(${SLUG})/src$`);
 
 // src/lib/skill-validation.ts
+import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join3, normalize } from "path";
 var VALID_SKILL_KINDS = ["executable", "instruction"];
 var DOC_FILES = ["SKILL.md", "README.md", "CLAUDE.md"];
 var RESERVED_SKILL_ENTRIES = new Set([
@@ -1076,7 +1087,7 @@ function add(target, code, message) {
   target.push({ code, message });
 }
 function readJsonFile(path) {
-  return JSON.parse(readFileSync2(path, "utf-8"));
+  return JSON.parse(readFileSync3(path, "utf-8"));
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -1160,7 +1171,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     binCommands: [],
     docFiles: []
   };
-  if (!existsSync2(skillPath)) {
+  if (!existsSync3(skillPath)) {
     add(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
     return {
       name: bareName,
@@ -1174,8 +1185,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   if (!VALID_BIN_COMMAND.test(bareName)) {
     add(issues, "skill.name_invalid", `Skill name '${bareName}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
   }
-  for (const entry of readdirSync2(skillPath).sort()) {
-    const entryPath = join2(skillPath, entry);
+  for (const entry of readdirSync3(skillPath).sort()) {
+    const entryPath = join3(skillPath, entry);
     if (RESERVED_SKILL_ENTRIES.has(entry)) {
       add(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
     }
@@ -1187,15 +1198,15 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync2(join2(skillPath, docFile)))
+    if (existsSync3(join3(skillPath, docFile)))
       metadata.docFiles.push(docFile);
   }
   if (metadata.docFiles.length === 0) {
     add(issues, "skill.docs_missing", "Missing documentation file: expected SKILL.md, README.md, or CLAUDE.md");
   }
-  const skillMdPath = join2(skillPath, "SKILL.md");
-  if (existsSync2(skillMdPath)) {
-    const frontmatter = parseSkillFrontmatter(readFileSync2(skillMdPath, "utf-8"));
+  const skillMdPath = join3(skillPath, "SKILL.md");
+  if (existsSync3(skillMdPath)) {
+    const frontmatter = parseSkillFrontmatter(readFileSync3(skillMdPath, "utf-8"));
     if (!frontmatter) {
       add(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
     } else {
@@ -1237,8 +1248,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join2(skillPath, "package.json");
-  if (!existsSync2(pkgPath)) {
+  const pkgPath = join3(skillPath, "package.json");
+  if (!existsSync3(pkgPath)) {
     if (!isInstruction)
       add(issues, "package.missing", "Missing package.json");
   } else {
@@ -1296,10 +1307,10 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
               add(issues, "package.bin_target_unsafe", `package.json bin '${command}' target '${target}' must stay inside the skill directory`);
               continue;
             }
-            const targetPath = join2(skillPath, target);
-            if (!existsSync2(targetPath)) {
+            const targetPath = join3(skillPath, target);
+            if (!existsSync3(targetPath)) {
               add(warnings, "package.bin_target_missing", `package.json bin '${command}' target '${target}' is not present before build`);
-            } else if (statSync2(targetPath).isDirectory()) {
+            } else if (statSync3(targetPath).isDirectory()) {
               add(issues, "package.bin_target_directory", `package.json bin '${command}' target '${target}' must point to a file, not a directory`);
             }
           }
@@ -1314,18 +1325,18 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join2(skillPath, "src");
+    const srcDir = join3(skillPath, "src");
     if (hostedMetadata) {
-      if (existsSync2(srcDir)) {
+      if (existsSync3(srcDir)) {
         add(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
       }
-    } else if (!existsSync2(srcDir)) {
+    } else if (!existsSync3(srcDir)) {
       add(issues, "skill.src_missing", "Missing src/ directory");
-    } else if (!existsSync2(join2(srcDir, "index.ts")) && !existsSync2(join2(srcDir, "index.js"))) {
+    } else if (!existsSync3(join3(srcDir, "index.ts")) && !existsSync3(join3(srcDir, "index.js"))) {
       add(issues, "skill.src_index_missing", "Missing src/index.ts or src/index.js");
     } else {
-      const indexPath = existsSync2(join2(srcDir, "index.ts")) ? join2(srcDir, "index.ts") : join2(srcDir, "index.js");
-      const size = statSync2(indexPath).size;
+      const indexPath = existsSync3(join3(srcDir, "index.ts")) ? join3(srcDir, "index.ts") : join3(srcDir, "index.js");
+      const size = statSync3(indexPath).size;
       if (size < 50)
         add(warnings, "skill.src_index_minimal", `Source entry point is very small (${size}B)`);
     }
@@ -1348,9 +1359,9 @@ function validateRegistryConsistency(registry, skillsDir) {
     seen.add(name);
     return false;
   })));
-  const skillDirs = existsSync2(skillsDir) ? readdirSync2(skillsDir).filter((entry) => {
-    const fullPath = join2(skillsDir, entry);
-    return !entry.startsWith(".") && entry !== "_common" && statSync2(fullPath).isDirectory();
+  const skillDirs = existsSync3(skillsDir) ? readdirSync3(skillsDir).filter((entry) => {
+    const fullPath = join3(skillsDir, entry);
+    return !entry.startsWith(".") && entry !== "_common" && statSync3(fullPath).isDirectory();
   }) : [];
   const directoryNames = new Set(skillDirs);
   const registryNameSet = new Set(registryNames);
@@ -1366,8 +1377,8 @@ function validateRegistryConsistency(registry, skillsDir) {
 
 // src/lib/skill-hash.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { join as join3, sep } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { join as join4, sep } from "path";
 var CONTENT_HASH_ALGORITHM = "sha256";
 var HASH_EXCLUDE_DIRS = new Set([".git", "node_modules", "dist", "build", ".turbo"]);
 var HASH_COVERAGE = [
@@ -1426,10 +1437,10 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join3(skillPath, entry);
-    if (!existsSync3(absolute))
+    const absolute = join4(skillPath, entry);
+    if (!existsSync4(absolute))
       continue;
-    if (statSync3(absolute).isDirectory())
+    if (statSync4(absolute).isDirectory())
       collectDirectory(files, absolute, entry);
     else
       collectFile(files, absolute, entry);
@@ -1437,14 +1448,14 @@ function collectBundleFiles(skillPath) {
   return files.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
 }
 function collectDirectory(files, dir, rel) {
-  for (const entry of readdirSync3(dir).sort()) {
+  for (const entry of readdirSync4(dir).sort()) {
     if (entry.startsWith("."))
       continue;
-    const absolute = join3(dir, entry);
+    const absolute = join4(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
-      stats = statSync3(absolute);
+      stats = statSync4(absolute);
     } catch {
       continue;
     }
@@ -1460,7 +1471,7 @@ function collectDirectory(files, dir, rel) {
   }
 }
 function collectFile(files, absolute, rel) {
-  const buffer = readFileSync3(absolute);
+  const buffer = readFileSync4(absolute);
   if (rel === "skill.json") {
     files.push({ rel: rel.split(sep).join("/"), content: new TextEncoder().encode(canonicalizeManifest(new TextDecoder().decode(buffer))) });
     return;
@@ -1660,14 +1671,14 @@ function validateRuntimeContract(manifest, issues, strict) {
 // src/lib/portable-skills-files.ts
 import {
   cpSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   realpathSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join4, relative } from "path";
+import { basename, dirname as dirname2, join as join5, relative } from "path";
 var ANY_SEGMENT_COPY_EXCLUDES = new Set([
   ".git",
   ".DS_Store",
@@ -1710,12 +1721,12 @@ function normalizePortableSkillName(name) {
   return normalized;
 }
 function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
-  const skillJsonPath = join4(skillPath, "skill.json");
-  const skillMdPath = join4(skillPath, "SKILL.md");
-  const pkgPath = join4(skillPath, "package.json");
-  const jsonManifest = existsSync4(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync4(skillMdPath) ? parseSkillFrontmatter(readFileSync4(skillMdPath, "utf-8")) ?? undefined : undefined;
-  const pkg = existsSync4(pkgPath) ? readJsonObject(pkgPath) : undefined;
+  const skillJsonPath = join5(skillPath, "skill.json");
+  const skillMdPath = join5(skillPath, "SKILL.md");
+  const pkgPath = join5(skillPath, "package.json");
+  const jsonManifest = existsSync5(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
+  const frontmatter = existsSync5(skillMdPath) ? parseSkillFrontmatter(readFileSync5(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const pkg = existsSync5(pkgPath) ? readJsonObject(pkgPath) : undefined;
   const name = normalizePortableSkillName(stringField(jsonManifest, "name") ?? frontmatter?.name ?? stringValue(pkg?.name) ?? fallbackName);
   const description = stringField(jsonManifest, "description") ?? frontmatter?.description ?? stringValue(pkg?.description) ?? `${name} skill`;
   const version = stringField(jsonManifest, "version") ?? frontmatter?.version ?? stringValue(pkg?.version) ?? PORTABLE_SKILL_DEFAULT_VERSION;
@@ -1761,7 +1772,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join4(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join5(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -1810,12 +1821,12 @@ function createPortableManifest(name, options) {
   };
 }
 function writePortableSkillTemplate(skillPath, manifest) {
-  mkdirSync2(join4(skillPath, "src"), { recursive: true });
-  writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync2(join4(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync2(join4(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync2(join4(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync2(join4(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+  mkdirSync2(join5(skillPath, "src"), { recursive: true });
+  writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync2(join5(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync2(join5(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -1840,7 +1851,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join4(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash = computeContentHash(skillPath);
   const withHash = {
@@ -1850,16 +1861,16 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join4(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
 `);
   return withHash;
 }
 function readExistingSkillJson(skillPath) {
-  const path = join4(skillPath, "skill.json");
-  if (!existsSync4(path))
+  const path = join5(skillPath, "skill.json");
+  if (!existsSync5(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
     return isRecord2(parsed) ? parsed : {};
   } catch {
     return {};
@@ -1889,28 +1900,28 @@ function ensurePortableSkillFiles(skillPath, manifest) {
     tags: next.tags?.length ? next.tags : ["custom", next.name]
   };
   const entry = next.commands[0]?.entry ?? "src/index.ts";
-  if (entry && !existsSync4(join4(skillPath, entry))) {
-    mkdirSync2(dirname2(join4(skillPath, entry)), { recursive: true });
-    writeFileSync2(join4(skillPath, entry), renderEntrypoint(next));
+  if (entry && !existsSync5(join5(skillPath, entry))) {
+    mkdirSync2(dirname2(join5(skillPath, entry)), { recursive: true });
+    writeFileSync2(join5(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync4(join4(skillPath, "SKILL.md")))
-    writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync5(join5(skillPath, "SKILL.md")))
+    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync2(join4(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync4(join4(skillPath, "SKILL.md"), "utf-8"), next));
-  if (!existsSync4(join4(skillPath, "AGENTS.md")))
-    writeFileSync2(join4(skillPath, "AGENTS.md"), renderAgentsMd(next));
+    writeFileSync2(join5(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync5(join5(skillPath, "SKILL.md"), "utf-8"), next));
+  if (!existsSync5(join5(skillPath, "AGENTS.md")))
+    writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
-  if (!existsSync4(join4(skillPath, "tsconfig.json")))
-    writeFileSync2(join4(skillPath, "tsconfig.json"), renderTsconfig());
+  if (!existsSync5(join5(skillPath, "tsconfig.json")))
+    writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
 function ensurePackageJson(skillPath, manifest) {
-  const pkgPath = join4(skillPath, "package.json");
+  const pkgPath = join5(skillPath, "package.json");
   const first = manifest.commands[0] ?? { name: manifest.name, entry: "src/index.ts" };
   const commandName = normalizePortableSkillName(first.name || manifest.name);
   const entry = (first.entry ?? "src/index.ts").replace(/^\.\//, "");
-  if (!existsSync4(pkgPath)) {
+  if (!existsSync5(pkgPath)) {
     writeFileSync2(pkgPath, renderPackageJson(manifest));
     return;
   }
@@ -1953,8 +1964,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync4(join4(skillPath, "SKILL.md"))) {
-    writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync5(join5(skillPath, "SKILL.md"))) {
+    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
   }
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
@@ -2205,7 +2216,7 @@ function inferPackageCommands(pkg, fallbackName) {
   return;
 }
 function readJsonObject(path) {
-  const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+  const parsed = JSON.parse(readFileSync5(path, "utf-8"));
   if (!isRecord2(parsed))
     throw new Error(`${basename(path)} must contain a JSON object`);
   return parsed;
@@ -2246,36 +2257,36 @@ var LEGACY_CUSTOM_DIRNAME = "custom";
 function getPortableSkillsRoot(options = {}) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join5(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache = join5(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join6(options.homeDir, ".hasna", "skills") : getDataDir();
+  const cache = join6(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
     return cache;
-  const installed = join5(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join6(appDir, INSTALLED_SKILLS_DIRNAME);
   migrateLegacySkillLayout(appDir, installed);
   return installed;
 }
 function looksLikeSkillDirectory(path) {
   if (!safeIsDirectory(path))
     return false;
-  return existsSync5(join5(path, "SKILL.md")) || existsSync5(join5(path, "skill.json")) || existsSync5(join5(path, "package.json"));
+  return existsSync6(join6(path, "SKILL.md")) || existsSync6(join6(path, "skill.json")) || existsSync6(join6(path, "package.json"));
 }
 function migrateLegacySkillLayout(appDir, installed) {
   if (!safeIsDirectory(appDir))
     return;
   const candidates = [];
   try {
-    for (const entry of readdirSync4(appDir)) {
+    for (const entry of readdirSync5(appDir)) {
       if (entry.startsWith(".") || entry === INSTALLED_SKILLS_DIRNAME)
         continue;
-      const path = join5(appDir, entry);
+      const path = join6(appDir, entry);
       if (entry === LEGACY_CUSTOM_DIRNAME) {
         if (!safeIsDirectory(path))
           continue;
         try {
-          for (const nested of readdirSync4(path)) {
+          for (const nested of readdirSync5(path)) {
             if (nested.startsWith("."))
               continue;
-            const nestedPath = join5(path, nested);
+            const nestedPath = join6(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -2289,10 +2300,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join5(installed, name);
-    if (existsSync5(target))
+    const target = join6(installed, name);
+    if (existsSync6(target))
       continue;
-    const staging = join5(installed, `.migrating-${name}-${process.pid}`);
+    const staging = join6(installed, `.migrating-${name}-${process.pid}`);
     try {
       rmSync(staging, { recursive: true, force: true });
       cpSync2(from, staging, { recursive: true, errorOnExist: false });
@@ -2305,7 +2316,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join5(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join6(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -2315,7 +2326,7 @@ function findPortableSkill(name, options = {}) {
     return null;
   }
   const path = getPortableSkillPath(normalized, options);
-  if (!existsSync5(path) || !statSync5(path).isDirectory())
+  if (!existsSync6(path) || !statSync6(path).isDirectory())
     return null;
   try {
     return summarizePortableSkill(path, normalized);
@@ -2328,10 +2339,10 @@ function listPortableSkills(options = {}) {
   if (!safeIsDirectory(root))
     return [];
   const skills = [];
-  for (const entry of readdirSync4(root).sort()) {
+  for (const entry of readdirSync5(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join5(root, entry);
+    const path = join6(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -2353,7 +2364,8 @@ function listPortableSkillMetas(options = {}) {
       tags: manifest.tags || ["custom"],
       version: skill.version,
       ...manifest.kind ? { kind: manifest.kind } : {},
-      source: "custom"
+      source: "custom",
+      ...isHostedMetadataSkillDir(skill.path) ? { serverOwned: true } : {}
     };
   });
 }
@@ -2364,8 +2376,8 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizePortableSkillName(name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join5(root, skillName);
-  if (existsSync5(skillPath)) {
+  const skillPath = join6(root, skillName);
+  if (existsSync6(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
     rmSync(skillPath, { recursive: true, force: true });
@@ -2383,7 +2395,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkillDirectory(sourceDir, options = {}) {
   const absoluteSource = normalize2(sourceDir);
-  if (!existsSync5(absoluteSource) || !statSync5(absoluteSource).isDirectory()) {
+  if (!existsSync6(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Import directory not found: ${sourceDir}`);
   }
   const continueOnError = options.continueOnError ?? true;
@@ -2394,9 +2406,9 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
   const imported = [];
   const skipped = [];
-  const entries = readdirSync4(absoluteSource, { withFileTypes: true }).map((entry) => entry.name).filter((entryName) => !entryName.startsWith(".")).sort();
+  const entries = readdirSync5(absoluteSource, { withFileTypes: true }).map((entry) => entry.name).filter((entryName) => !entryName.startsWith(".")).sort();
   for (const entryName of entries) {
-    const childPath = join5(absoluteSource, entryName);
+    const childPath = join6(absoluteSource, entryName);
     if (!safeIsDirectory(childPath))
       continue;
     if (!isSkillCandidate(childPath)) {
@@ -2425,11 +2437,11 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
 }
 function isSkillCandidate(dir) {
-  return existsSync5(join5(dir, "SKILL.md")) || existsSync5(join5(dir, "skill.json")) || existsSync5(join5(dir, "package.json"));
+  return existsSync6(join6(dir, "SKILL.md")) || existsSync6(join6(dir, "skill.json")) || existsSync6(join6(dir, "package.json"));
 }
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize2(sourcePath);
-  if (!existsSync5(absoluteSource) || !statSync5(absoluteSource).isDirectory()) {
+  if (!existsSync6(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Skill source directory not found: ${sourcePath}`);
   }
   const inferred = readPortableSkillManifest(absoluteSource, basename2(absoluteSource));
@@ -2441,8 +2453,8 @@ function portPortableSkill(sourcePath, options = {}) {
     throw new Error(`${via} Importing it would shadow the official '${skillName}'. ` + `Pass --name to choose a different name, or --allow-shadow to override deliberately.`);
   }
   const root = getPortableSkillsRoot(options);
-  const destination = join5(root, skillName);
-  if (existsSync5(destination)) {
+  const destination = join6(root, skillName);
+  if (existsSync6(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync(destination, { recursive: true, force: true });
@@ -2464,16 +2476,10 @@ function safeNormalizeName(name) {
     return;
   }
 }
-function writeCorpusSkill(input, options = {}) {
-  const name = normalizePortableSkillName(input.name);
-  const root = getPortableSkillsRoot(options);
-  const skillPath = join5(root, name);
-  const created = !existsSync5(skillPath);
-  mkdirSync3(skillPath, { recursive: true });
-  writeFileSync3(join5(skillPath, "SKILL.md"), input.skillMd);
+function buildCorpusManifest(input, name) {
   const frontmatter = parseSkillFrontmatter(input.skillMd) ?? undefined;
   const kind = input.meta?.kind ?? parseSkillKind(frontmatter?.kind) ?? "instruction";
-  const manifest = {
+  return {
     $schema: PORTABLE_SKILL_SCHEMA,
     standard: PORTABLE_SKILL_STANDARD,
     name,
@@ -2486,19 +2492,60 @@ function writeCorpusSkill(input, options = {}) {
     inputs: [],
     commands: []
   };
+}
+function writeCorpusSkill(input, options = {}) {
+  const name = normalizePortableSkillName(input.name);
+  const root = getPortableSkillsRoot(options);
+  const skillPath = join6(root, name);
+  const created = !existsSync6(skillPath);
+  mkdirSync3(skillPath, { recursive: true });
+  writeFileSync3(join6(skillPath, "SKILL.md"), input.skillMd);
+  const manifest = buildCorpusManifest(input, name);
   writeSkillJsonWithHash(skillPath, manifest);
   return { name, path: skillPath, manifest, created };
 }
+function installCorpusSkillAtomically(input, options = {}) {
+  const name = normalizePortableSkillName(input.name);
+  const root = getPortableSkillsRoot(options);
+  const target = join6(root, name);
+  const created = !existsSync6(target);
+  mkdirSync3(root, { recursive: true });
+  const staging = mkdtempSync(join6(root, `.pull-${name}-`));
+  let moved = false;
+  let backup = null;
+  try {
+    writeFileSync3(join6(staging, "SKILL.md"), input.skillMd);
+    const manifest = buildCorpusManifest(input, name);
+    writeSkillJsonWithHash(staging, manifest);
+    if (existsSync6(target)) {
+      backup = mkdtempSync(join6(root, `.pull-backup-${name}-`));
+      renameSync(target, join6(backup, name));
+      moved = true;
+    }
+    renameSync(staging, target);
+    if (moved && backup)
+      rmSync(backup, { recursive: true, force: true });
+    return { name, path: target, manifest, created };
+  } catch (error) {
+    rmSync(staging, { recursive: true, force: true });
+    if (moved && backup && existsSync6(join6(backup, name))) {
+      try {
+        renameSync(join6(backup, name), target);
+      } catch {}
+    }
+    throw error;
+  }
+}
 function validatePortableSkillDirectory(name, skillPath) {
   const normalizedName = normalizePortableSkillName(name);
   const base = validateSkillDirectory(normalizedName, skillPath);
   const issues = [...base.issues];
   const warnings = [...base.warnings];
   let manifest;
-  if (existsSync5(skillPath)) {
-    const skillJsonPath = join5(skillPath, "skill.json");
-    const skillMdPath = join5(skillPath, "SKILL.md");
-    if (!existsSync5(skillJsonPath) && !existsSync5(skillMdPath)) {
+  if (existsSync6(skillPath)) {
+    const skillJsonPath = join6(skillPath, "skill.json");
+    const skillMdPath = join6(skillPath, "SKILL.md");
+    if (!existsSync6(skillJsonPath) && !existsSync6(skillMdPath)) {
       add3(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
     try {
@@ -2517,7 +2564,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add3(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync5(join5(skillPath, "skill.json")),
+        strict: existsSync6(join6(skillPath, "skill.json")),
         skillPath
       });
       for (const issue of contractIssues)
@@ -2553,10 +2600,10 @@ function validatePortableSkillDirectory(name, skillPath) {
               add3(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
               continue;
             }
-            const entryPath = join5(skillPath, command.entry);
-            if (!existsSync5(entryPath))
+            const entryPath = join6(skillPath, command.entry);
+            if (!existsSync6(entryPath))
               add3(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
-            else if (statSync5(entryPath).isDirectory())
+            else if (statSync6(entryPath).isDirectory())
               add3(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
           }
         }
@@ -2564,7 +2611,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error) {
       add3(issues, "portable.manifest_invalid", error.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync5(join5(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync6(join6(skillPath, "AGENTS.md"))) {
       add3(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -2600,13 +2647,13 @@ async function runPortableSkill(name, args, options = {}) {
   if (!isSafeRelativePath2(command.entry)) {
     return { exitCode: 1, error: `Portable skill '${name}' command entry is unsafe` };
   }
-  const entryPath = join5(skill.path, command.entry);
-  if (!existsSync5(entryPath)) {
+  const entryPath = join6(skill.path, command.entry);
+  if (!existsSync6(entryPath)) {
     return { exitCode: 1, error: `Entry point '${command.entry}' not found in portable skill '${name}'` };
   }
-  const pkgPath = join5(skill.path, "package.json");
-  const nodeModules = join5(skill.path, "node_modules");
-  if (existsSync5(pkgPath) && !existsSync5(nodeModules) && hasPackageDependencies(pkgPath)) {
+  const pkgPath = join6(skill.path, "package.json");
+  const nodeModules = join6(skill.path, "node_modules");
+  if (existsSync6(pkgPath) && !existsSync6(nodeModules) && hasPackageDependencies(pkgPath)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skill.path,
       stdout: "pipe",
@@ -2646,7 +2693,7 @@ function summarizePortableSkill(skillPath, fallbackName) {
 }
 function safeIsDirectory(path) {
   try {
-    return statSync5(path).isDirectory();
+    return statSync6(path).isDirectory();
   } catch {
     return false;
   }
@@ -2875,20 +2922,20 @@ function parseSkillMdFrontmatter(content) {
   return Object.keys(result).length > 0 ? result : null;
 }
 function discoverSkillsInDir(dir, source = "custom") {
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return [];
   const result = [];
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join6(dir, entry.name, "SKILL.md");
-      if (!existsSync6(skillMdPath))
+      const skillMdPath = join7(dir, entry.name, "SKILL.md");
+      if (!existsSync7(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync5(skillMdPath, "utf-8");
+        content = readFileSync6(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -2903,6 +2950,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
+        ...isHostedMetadataSkillDir(join7(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -2911,20 +2959,20 @@ function discoverSkillsInDir(dir, source = "custom") {
 }
 function findExtensionSkillPath(name) {
   const config = loadConfig();
-  if (!config.extensionsDir || !existsSync6(config.extensionsDir))
+  if (!config.extensionsDir || !existsSync7(config.extensionsDir))
     return null;
   try {
-    const entries = readdirSync5(config.extensionsDir, { withFileTypes: true });
+    const entries = readdirSync6(config.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join6(config.extensionsDir, entry.name);
-      const skillMdPath = join6(skillDir, "SKILL.md");
-      if (!existsSync6(skillMdPath))
+      const skillDir = join7(config.extensionsDir, entry.name);
+      const skillMdPath = join7(skillDir, "SKILL.md");
+      if (!existsSync7(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync5(skillMdPath, "utf-8");
+        content = readFileSync6(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -2957,7 +3005,7 @@ function loadRegistry(cwd) {
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
   const extensions = config.extensionsDir ? discoverSkillsInDir(config.extensionsDir, "extension") : [];
   const portableCustom = listPortableSkillMetas();
-  const legacyCustom = discoverSkillsInDir(join6(dataDir, "custom"));
+  const legacyCustom = discoverSkillsInDir(join7(dataDir, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now;
@@ -3004,26 +3052,26 @@ function getAllTags() {
   return Array.from(tagSet).sort();
 }
 // src/lib/installer.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, rmSync as rmSync3 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9, rmSync as rmSync3 } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
 import { homedir as homedir3 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/agent-sync.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync4,
-  mkdtempSync,
-  readFileSync as readFileSync6,
-  readdirSync as readdirSync6,
+  mkdtempSync as mkdtempSync2,
+  readFileSync as readFileSync7,
+  readdirSync as readdirSync7,
   renameSync as renameSync2,
   rmSync as rmSync2,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, dirname as dirname4, join as join7 } from "path";
+import { basename as basename3, dirname as dirname4, join as join8 } from "path";
 // src/lib/home-migration.ts
 function resolveCorpusRoot(options = {}) {
   return getPortableSkillsRoot(options);
@@ -3048,9 +3096,9 @@ function resolveSyncAgents(arg) {
 function agentGlobalSkillsDir(agent, homeDir = homedir2()) {
   switch (agent) {
     case "opencode":
-      return join7(homeDir, ".config", "opencode", "skills");
+      return join8(homeDir, ".config", "opencode", "skills");
     default:
-      return join7(homeDir, `.${agent}`, "skills");
+      return join8(homeDir, `.${agent}`, "skills");
   }
 }
 function adaptSkillMdForAgent(skillMd, agent) {
@@ -3109,8 +3157,8 @@ function resolveSyncCorpus(options = {}) {
 function packageSourceRoots(source) {
   const roots = [];
   for (const sub of ["skills"]) {
-    const candidate = join7(source, sub);
-    if (existsSync7(candidate) && isDirectory(candidate))
+    const candidate = join8(source, sub);
+    if (existsSync8(candidate) && isDirectory(candidate))
       roots.push(candidate);
   }
   if (roots.length > 0)
@@ -3120,20 +3168,20 @@ function packageSourceRoots(source) {
 function containsSkillDirectories(path) {
   let entries;
   try {
-    entries = readdirSync6(path);
+    entries = readdirSync7(path);
   } catch {
     return false;
   }
   return entries.some((entry) => {
-    const candidate = join7(path, entry);
+    const candidate = join8(path, entry);
     if (!isDirectory(candidate))
       return false;
-    return existsSync7(join7(candidate, "SKILL.md")) || existsSync7(join7(candidate, "skill.json")) || existsSync7(join7(candidate, "package.json"));
+    return existsSync8(join8(candidate, "SKILL.md")) || existsSync8(join8(candidate, "skill.json")) || existsSync8(join8(candidate, "package.json"));
   });
 }
 function isDirectory(path) {
   try {
-    return statSync6(path).isDirectory();
+    return statSync7(path).isDirectory();
   } catch {
     return false;
   }
@@ -3167,7 +3215,7 @@ function syncSkillsToAgents(options = {}) {
         actions.push({
           skill: name,
           agent,
-          path: join7(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
+          path: join8(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
           action: "skip",
           reason: "not found in this machine's corpus"
         });
@@ -3177,7 +3225,7 @@ function syncSkillsToAgents(options = {}) {
   }
   for (const skill of targets) {
     const manifest = readPortableSkillManifest(skill.path, skill.name);
-    const kind = manifest.kind ?? "executable";
+    const kind = manifest.kind;
     const sourceMd = sourceSkillMd(skill.path, skill.name, manifest.description, kind, source === "source");
     for (const agent of agents) {
       const adapted = adaptSkillMdForAgent(sourceMd, agent);
@@ -3197,7 +3245,7 @@ function syncSkillsToAgents(options = {}) {
 }
 function writeManagedAgentSkill(params) {
   const homeDir = params.homeDir ?? homedir2();
-  const dir = join7(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
+  const dir = join8(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
   const result = writeManagedSkillDir(dir, params.skillMd, {
     skill: params.skill,
     source: params.source,
@@ -3214,11 +3262,11 @@ function writeManagedAgentSkill(params) {
   };
 }
 function writeManagedSkillDir(dir, skillMd, options) {
-  const skillMdPath = join7(dir, "SKILL.md");
-  const markerPath = join7(dir, SYNC_MARKER_FILE);
-  const dirExists = existsSync7(dir);
-  const managed = existsSync7(markerPath);
-  const hasSkillMd = existsSync7(skillMdPath);
+  const skillMdPath = join8(dir, "SKILL.md");
+  const markerPath = join8(dir, SYNC_MARKER_FILE);
+  const dirExists = existsSync8(dir);
+  const managed = existsSync8(markerPath);
+  const hasSkillMd = existsSync8(skillMdPath);
   if (dirExists && !managed && !hasSkillMd) {
     return {
       action: "skip",
@@ -3236,7 +3284,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
   if (dirExists && managed && hasSkillMd && !options.force && isPointerSkillMd(skillMd)) {
     let existingIsStub = false;
     try {
-      existingIsStub = isPointerSkillMd(readFileSync6(skillMdPath, "utf-8"));
+      existingIsStub = isPointerSkillMd(readFileSync7(skillMdPath, "utf-8"));
     } catch {
       existingIsStub = false;
     }
@@ -3253,11 +3301,11 @@ function writeManagedSkillDir(dir, skillMd, options) {
     return { action, path: skillMdPath };
   const parentDir = dirname4(dir);
   mkdirSync4(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync(join7(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
-  const candidateDir = join7(transactionDir, "candidate");
-  const backupDir = join7(transactionDir, "backup");
-  const candidateSkillMdPath = join7(candidateDir, "SKILL.md");
-  const candidateMarkerPath = join7(candidateDir, SYNC_MARKER_FILE);
+  const transactionDir = mkdtempSync2(join8(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
+  const candidateDir = join8(transactionDir, "candidate");
+  const backupDir = join8(transactionDir, "backup");
+  const candidateSkillMdPath = join8(candidateDir, "SKILL.md");
+  const candidateMarkerPath = join8(candidateDir, SYNC_MARKER_FILE);
   const marker = {
     managedBy: SYNC_MARKER_MANAGED_BY,
     skill: options.skill,
@@ -3284,9 +3332,9 @@ function writeManagedSkillDir(dir, skillMd, options) {
     }
     renameDirectory(candidateDir, dir);
   } catch (error) {
-    if (originalMoved && existsSync7(backupDir)) {
+    if (originalMoved && existsSync8(backupDir)) {
       try {
-        if (existsSync7(dir))
+        if (existsSync8(dir))
           rmSync2(dir, { recursive: true, force: true });
         renameDirectory(backupDir, dir);
         originalMoved = false;
@@ -3306,17 +3354,17 @@ function writeManagedSkillDir(dir, skillMd, options) {
   return { action, path: skillMdPath };
 }
 function removeManagedAgentSkill(skill, agent, homeDir = homedir2()) {
-  const dir = join7(agentGlobalSkillsDir(agent, homeDir), skill);
-  if (!existsSync7(join7(dir, SYNC_MARKER_FILE)))
+  const dir = join8(agentGlobalSkillsDir(agent, homeDir), skill);
+  if (!existsSync8(join8(dir, SYNC_MARKER_FILE)))
     return false;
   rmSync2(dir, { recursive: true, force: true });
   return true;
 }
 function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = false) {
-  if (kind === "instruction" || preferBundledDocs) {
-    const skillMdPath = join7(skillPath, "SKILL.md");
-    if (existsSync7(skillMdPath))
-      return readFileSync6(skillMdPath, "utf-8");
+  if (kind === undefined || kind === "instruction" || preferBundledDocs) {
+    const skillMdPath = join8(skillPath, "SKILL.md");
+    if (existsSync8(skillMdPath))
+      return readFileSync7(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -3346,8 +3394,8 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
   "custom",
@@ -3362,17 +3410,17 @@ var SKILLS_PROJECT_DIR = ".skills";
 var PROJECT_CONFIG_FILE = "project.json";
 var DEFAULT_EXPORT_DIR = ".skills/exports";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join8(targetDir, SKILLS_PROJECT_DIR);
+  return join9(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join8(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join9(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync7(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync8(path, "utf-8")));
   } catch {
     return null;
   }
@@ -3490,12 +3538,12 @@ var __dirname2 = dirname5(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join9(dir, "skills");
-    if (existsSync9(candidate) && !dir.includes(".skills"))
+    const candidate = join10(dir, "skills");
+    if (existsSync10(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname5(dir);
   }
-  return join9(__dirname2, "..", "skills");
+  return join10(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
@@ -3503,25 +3551,25 @@ function getSkillPath(name) {
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join9(getDataDir(), "custom", skillName);
-  if (existsSync9(legacyCustomPath))
+  const legacyCustomPath = join10(getDataDir(), "custom", skillName);
+  if (existsSync10(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join9(SKILLS_DIR, skillName);
+  return join10(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
 }
 function skillExists(name) {
-  return existsSync9(getSkillPath(name));
+  return existsSync10(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync9(getSkillPath(name))) {
+  if (!existsSync10(getSkillPath(name))) {
     const knownOfficial = Boolean(getSkill(name));
     return {
       skill: canonicalName,
@@ -3548,7 +3596,7 @@ function installSkill(name, options = {}) {
 }
 function installSkillSource(name, _options = {}) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync9(getSkillPath(name))) {
+  if (!existsSync10(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found`, mode: "source" };
   }
   return {
@@ -3569,12 +3617,12 @@ function installSkillManifest(manifest, _options = {}) {
 }
 function createLocalSkillManifest(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync9(sourcePath))
+  if (!existsSync10(sourcePath))
     return null;
   let skillMd = "";
-  const skillMdPath = join9(sourcePath, "SKILL.md");
-  if (existsSync9(skillMdPath)) {
-    skillMd = readFileSync8(skillMdPath, "utf-8");
+  const skillMdPath = join10(sourcePath, "SKILL.md");
+  if (existsSync10(skillMdPath)) {
+    skillMd = readFileSync9(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -3646,20 +3694,20 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join9(base, ".pi", "skills") : join9(homedir3(), ".pi", "agent", "skills");
+      return scope === "project" ? join10(base, ".pi", "skills") : join10(homedir3(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join9(base, ".opencode", "skills") : join9(homedir3(), ".config", "opencode", "skills");
+      return scope === "project" ? join10(base, ".opencode", "skills") : join10(homedir3(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join9(base, `.${agent}`, "skills") : join9(homedir3(), `.${agent}`, "skills");
+      return scope === "project" ? join10(base, `.${agent}`, "skills") : join10(homedir3(), `.${agent}`, "skills");
   }
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
-  return join9(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join10(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync9(getSkillPath(name))) {
+  if (!existsSync10(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found` };
   }
   const scope = options.scope ?? "global";
@@ -3683,16 +3731,16 @@ function removeSkillForAgent(name, options) {
   const canonicalName = getCanonicalSkillName(name);
   const scope = options.scope ?? "global";
   const dir = getAgentSkillPath(canonicalName, options.agent, scope, options.projectDir);
-  if (!existsSync9(join9(dir, SYNC_MARKER_FILE)))
+  if (!existsSync10(join10(dir, SYNC_MARKER_FILE)))
     return false;
   rmSync3(dir, { recursive: true, force: true });
   return true;
 }
 function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  const skillMdPath = join9(sourcePath, "SKILL.md");
-  if (existsSync9(skillMdPath))
-    return readFileSync8(skillMdPath, "utf-8");
+  const skillMdPath = join10(sourcePath, "SKILL.md");
+  if (existsSync10(skillMdPath))
+    return readFileSync9(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -3710,7 +3758,7 @@ function warnMissingDependencies(name, targetDir) {
 }
 function generateMinimalSkillMd(name) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync9(sourcePath))
+  if (!existsSync10(sourcePath))
     return null;
   const canonicalName = getCanonicalSkillName(name);
   const meta = getSkill(canonicalName);
@@ -3725,7 +3773,7 @@ function generateMinimalSkillMd(name) {
     "---",
     ""
   ].filter(Boolean);
-  const fallbackDoc = readFileIfExists(join9(sourcePath, "README.md")) || readFileIfExists(join9(sourcePath, "CLAUDE.md"));
+  const fallbackDoc = readFileIfExists(join10(sourcePath, "README.md")) || readFileIfExists(join10(sourcePath, "CLAUDE.md"));
   if (fallbackDoc)
     return `${frontmatter.join(`
 `)}${fallbackDoc.trim()}
@@ -3744,38 +3792,38 @@ skills run ${canonicalName}
 `;
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join9(getSkillPath(name), "package.json");
-  if (!existsSync9(pkgPath))
+  const pkgPath = join10(getSkillPath(name), "package.json");
+  if (!existsSync10(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync9(path) ? readFileSync8(path, "utf-8") : null;
+  return existsSync10(path) ? readFileSync9(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
 }
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync9, readdirSync as readdirSync7, statSync as statSync7, writeFileSync as writeFileSync6 } from "fs";
-import { extname, join as join10, relative as relative2 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync as readdirSync8, statSync as statSync8, writeFileSync as writeFileSync6 } from "fs";
+import { extname, join as join11, relative as relative2 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now = new Date;
   const id = createRunId(now);
   const day = now.toISOString().slice(0, 10);
   const skillName = normalizeSkillName(params.skill);
   const root = getProjectStateDir(targetDir);
-  const runDir = join10(root, "runs", day, id);
-  const logsDir = join10(runDir, "logs");
-  const exportDir = join10(root, "exports", skillName, id);
+  const runDir = join11(root, "runs", day, id);
+  const logsDir = join11(runDir, "logs");
+  const exportDir = join11(root, "exports", skillName, id);
   mkdirSync6(logsDir, { recursive: true });
   mkdirSync6(exportDir, { recursive: true });
-  mkdirSync6(join10(root, "tmp"), { recursive: true });
+  mkdirSync6(join11(root, "tmp"), { recursive: true });
   const record = {
     id,
     skill: skillName,
@@ -3826,27 +3874,27 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync6(join10(context.logsDir, "stdout.log"), stdout);
-  writeFileSync6(join10(context.logsDir, "stderr.log"), stderr);
+  writeFileSync6(join11(context.logsDir, "stdout.log"), stdout);
+  writeFileSync6(join11(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join10(context.runDir, "events.ndjson");
-  const previous = existsSync10(path) ? readFileSync9(path, "utf-8") : "";
+  const path = join11(context.runDir, "events.ndjson");
+  const previous = existsSync11(path) ? readFileSync10(path, "utf-8") : "";
   writeFileSync6(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
-  const runsRoot = join10(getProjectStateDir(targetDir), "runs");
-  if (!existsSync10(runsRoot))
+  const runsRoot = join11(getProjectStateDir(targetDir), "runs");
+  if (!existsSync11(runsRoot))
     return [];
   const records = [];
-  for (const day of readdirSync7(runsRoot).sort().reverse()) {
-    const dayDir = join10(runsRoot, day);
-    if (!statSync7(dayDir).isDirectory())
+  for (const day of readdirSync8(runsRoot).sort().reverse()) {
+    const dayDir = join11(runsRoot, day);
+    if (!statSync8(dayDir).isDirectory())
       continue;
-    for (const runId of readdirSync7(dayDir).sort().reverse()) {
-      const record = readRunRecord(join10(dayDir, runId));
+    for (const runId of readdirSync8(dayDir).sort().reverse()) {
+      const record = readRunRecord(join11(dayDir, runId));
       if (record)
         records.push(record);
       if (records.length >= limit)
@@ -3856,34 +3904,34 @@ function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   return records;
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join10(getProjectStateDir(targetDir), "runs");
-  if (!existsSync10(runsRoot))
+  const runsRoot = join11(getProjectStateDir(targetDir), "runs");
+  if (!existsSync11(runsRoot))
     return null;
-  for (const day of readdirSync7(runsRoot)) {
-    const record = readRunRecord(join10(runsRoot, day, runId));
+  for (const day of readdirSync8(runsRoot)) {
+    const record = readRunRecord(join11(runsRoot, day, runId));
     if (record)
       return record;
   }
   return null;
 }
 function getRunExportDir(runId, skill, targetDir = process.cwd()) {
-  return join10(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
+  return join11(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
 }
 function writeRunRecord(context) {
-  writeFileSync6(join10(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync6(join11(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync6(join10(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync6(join11(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
-  if (!existsSync10(context.exportDir))
+  if (!existsSync11(context.exportDir))
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
-    const stat = statSync7(path);
-    const bytes = readFileSync9(path);
+    const stat = statSync8(path);
+    const bytes = readFileSync10(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
@@ -3894,20 +3942,20 @@ function collectRunArtifacts(context) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join10(runDir, "run.json");
-  if (!existsSync10(path))
+  const path = join11(runDir, "run.json");
+  if (!existsSync11(path))
     return null;
   try {
-    return JSON.parse(readFileSync9(path, "utf-8"));
+    return JSON.parse(readFileSync10(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync7(dir)) {
-    const full = join10(dir, entry);
-    if (statSync7(full).isDirectory())
+  for (const entry of readdirSync8(dir)) {
+    const full = join11(dir, entry);
+    if (statSync8(full).isDirectory())
       files.push(...walkFiles(full));
     else
       files.push(full);
@@ -3952,16 +4000,16 @@ function mimeForPath(path) {
   }
 }
 // src/lib/skillinfo.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { join as join12 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join11(skillPath, "SKILL.md");
-  if (!existsSync11(skillMdPath))
+  const skillMdPath = join12(skillPath, "SKILL.md");
+  if (!existsSync12(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync10(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync11(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -3984,12 +4032,12 @@ var HOSTED_PROVIDER_ENV_PREFIXES = [
 ];
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync11(skillPath))
+  if (!existsSync12(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join11(skillPath, "SKILL.md")),
-    readme: readIfExists(join11(skillPath, "README.md")),
-    claudeMd: readIfExists(join11(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join12(skillPath, "SKILL.md")),
+    readme: readIfExists(join12(skillPath, "README.md")),
+    claudeMd: readIfExists(join12(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -4000,11 +4048,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync11(skillPath))
+  if (!existsSync12(skillPath))
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join11(skillPath, file));
+    const content = readIfExists(join12(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -4043,10 +4091,10 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join11(skillPath, "package.json");
-  if (existsSync11(pkgPath)) {
+  const pkgPath = join12(skillPath, "package.json");
+  if (existsSync12(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
     } catch {}
   }
@@ -4064,7 +4112,7 @@ async function runSkill(name, args, options = {}) {
   const meta = getSkill(name);
   const canonicalName = meta?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync11(skillPath)) {
+  if (!existsSync12(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
   if (isInstructionSkillDir(skillPath, meta)) {
@@ -4073,13 +4121,13 @@ async function runSkill(name, args, options = {}) {
       error: `Skill '${name}' is an instruction skill (kind: instruction) and is not runnable. Instruction skills are consumed by coding agents via SKILL.md, not executed with 'skills run'.`
     };
   }
-  const pkgPath = join11(skillPath, "package.json");
-  if (!existsSync11(pkgPath)) {
+  const pkgPath = join12(skillPath, "package.json");
+  if (!existsSync12(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
   try {
-    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint = binValues[0];
@@ -4093,12 +4141,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join11(skillPath, entryPoint);
-  if (!existsSync11(entryPath)) {
+  const entryPath = join12(skillPath, entryPoint);
+  if (!existsSync12(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join11(skillPath, "node_modules");
-  if (!existsSync11(nodeModules)) {
+  const nodeModules = join12(skillPath, "node_modules");
+  if (!existsSync12(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -4170,7 +4218,7 @@ function generateSkillMd(name) {
   if (!meta)
     return null;
   const skillPath = getSkillPath(name);
-  if (!existsSync11(skillPath))
+  if (!existsSync12(skillPath))
     return null;
   const frontmatter = [
     "---",
@@ -4179,13 +4227,13 @@ function generateSkillMd(name) {
     "---"
   ].join(`
 `);
-  const readme = readIfExists(join11(skillPath, "README.md"));
-  const claudeMd = readIfExists(join11(skillPath, "CLAUDE.md"));
+  const readme = readIfExists(join12(skillPath, "README.md"));
+  const claudeMd = readIfExists(join12(skillPath, "CLAUDE.md"));
   let cliCommand = null;
-  const pkgPath = join11(skillPath, "package.json");
-  if (existsSync11(pkgPath)) {
+  const pkgPath = join12(skillPath, "package.json");
+  if (existsSync12(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -4260,8 +4308,8 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync11(path)) {
-      return readFileSync10(path, "utf-8");
+    if (existsSync12(path)) {
+      return readFileSync11(path, "utf-8");
     }
   } catch {}
   return null;
@@ -8264,22 +8312,22 @@ function requireApiUrl(action = "This command", config, env) {
 }
 
 // src/lib/auth-store.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7, unlinkSync } from "fs";
-import { dirname as dirname6, join as join12 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
 import { homedir as homedir4 } from "os";
 function getAuthFilePath() {
-  return join12(getDataDir(), "auth.json");
+  return join13(getDataDir(), "auth.json");
 }
 function legacyAuthFilePath() {
-  return join12(process.env["HOME"] || process.env["USERPROFILE"] || homedir4(), ".skills", "auth.json");
+  return join13(process.env["HOME"] || process.env["USERPROFILE"] || homedir4(), ".skills", "auth.json");
 }
 var cachedConfig;
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const file = existsSync12(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
-    const raw = readFileSync11(file, "utf-8");
+    const file = existsSync13(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
+    const raw = readFileSync12(file, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiKey) {
       cachedConfig = null;
@@ -9379,24 +9427,24 @@ function createRemoteSkillsClient() {
   return new RemoteSkillsClient(apiKey);
 }
 // src/lib/scheduler.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join14 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join13(targetDir, ".skills", "schedules.json");
+  return join14(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  if (existsSync13(path)) {
+  if (existsSync14(path)) {
     try {
-      return JSON.parse(readFileSync12(path, "utf-8"));
+      return JSON.parse(readFileSync13(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join13(targetDir, ".skills");
-  if (!existsSync13(dir))
+  const dir = join14(targetDir, ".skills");
+  if (!existsSync14(dir))
     mkdirSync8(dir, { recursive: true });
   writeFileSync8(path, JSON.stringify(data, null, 2));
 }
@@ -9583,8 +9631,8 @@ function recordScheduleRun(id, status, targetDir) {
   saveSchedules(data, targetDir);
 }
 // src/lib/pull.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync13, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname7, join as join14 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync14, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname7, join as join15 } from "path";
 
 // src/lib/revision.ts
 import { createHash as createHash3 } from "crypto";
@@ -9875,7 +9923,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
       return reconcileTombstone(slug, corpusOptions);
     }
     if (bundleResponse.status === 404) {
-      const marker = readPullMarker(join14(getPortableSkillsRoot(corpusOptions), slug));
+      const marker = readPullMarker(join15(getPortableSkillsRoot(corpusOptions), slug));
       if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
         return { name: slug, success: true, purged: true, removed: false };
       }
@@ -9906,7 +9954,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
     return { name: slug, success: false, error: `Skill '${slug}' was not found on the configured Skills instance.` };
   }
   if (!meta?.revisionId) {
-    const marker = readPullMarker(join14(getPortableSkillsRoot(corpusOptions), slug));
+    const marker = readPullMarker(join15(getPortableSkillsRoot(corpusOptions), slug));
     if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
       return { name: slug, success: true, purged: true, removed: false };
     }
@@ -9920,7 +9968,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
     }
     throw error;
   }
-  const written = writeCorpusSkill({ name: slug, skillMd, meta }, corpusOptions);
+  const written = installCorpusSkillAtomically({ name: slug, skillMd, meta }, corpusOptions);
   writePullMarker(written.path, {
     skill: slug,
     version: written.manifest.version,
@@ -9963,8 +10011,8 @@ function provenRevision(meta, slug, bundle) {
   return declared;
 }
 function reconcileTombstone(slug, corpusOptions) {
-  const target = join14(getPortableSkillsRoot(corpusOptions), slug);
-  if (!existsSync14(join14(target, PULL_MARKER_FILE))) {
+  const target = join15(getPortableSkillsRoot(corpusOptions), slug);
+  if (!existsSync15(join15(target, PULL_MARKER_FILE))) {
     return { name: slug, success: true, tombstoned: true, removed: false, leftInPlace: true };
   }
   rmSync4(target, { recursive: true, force: true });
@@ -9972,7 +10020,7 @@ function reconcileTombstone(slug, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync13(join14(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync14(join15(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -10093,14 +10141,14 @@ function verifyBundleResponseBytes(buffer, response, verify = {}) {
 function installBundleAtomically(name, entries, options = {}, marker = {}) {
   const root = getPortableSkillsRoot(options);
   mkdirSync9(root, { recursive: true });
-  const target = join14(root, name);
-  const created = !existsSync14(target);
-  const staging = mkdtempSync2(join14(root, `.pull-${name}-`));
+  const target = join15(root, name);
+  const created = !existsSync15(target);
+  const staging = mkdtempSync3(join15(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
     for (const entry of entries) {
-      const destination = join14(staging, entry.path);
+      const destination = join15(staging, entry.path);
       mkdirSync9(dirname7(destination), { recursive: true });
       writeFileSync9(destination, entry.bytes, { mode: entry.mode });
     }
@@ -10112,9 +10160,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       ...marker.signature ? { signature: marker.signature } : {},
       ...marker.revisionId ? { revisionId: marker.revisionId } : {}
     });
-    if (existsSync14(target)) {
-      backup = mkdtempSync2(join14(root, `.pull-backup-${name}-`));
-      renameSync3(target, join14(backup, name));
+    if (existsSync15(target)) {
+      backup = mkdtempSync3(join15(root, `.pull-backup-${name}-`));
+      renameSync3(target, join15(backup, name));
       moved = true;
     }
     renameSync3(staging, target);
@@ -10122,9 +10170,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       rmSync4(backup, { recursive: true, force: true });
   } catch (error) {
     rmSync4(staging, { recursive: true, force: true });
-    if (moved && backup && existsSync14(join14(backup, name))) {
+    if (moved && backup && existsSync15(join15(backup, name))) {
       try {
-        renameSync3(join14(backup, name), target);
+        renameSync3(join15(backup, name), target);
       } catch {}
     }
     throw error;
@@ -10143,7 +10191,7 @@ function writePullMarker(dir, record) {
     ...record.revisionId ? { revisionId: record.revisionId } : {},
     syncedAt: new Date().toISOString()
   };
-  writeFileSync9(join14(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+  writeFileSync9(join15(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function safeMeta(client, slug) {
@@ -10294,7 +10342,7 @@ import { dirname as dirname8, relative as relative3 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.64",
+  version: "0.1.66",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -11302,16 +11350,16 @@ function clone2(value) {
   return JSON.parse(JSON.stringify(value));
 }
 // src/lib/feedback.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync11 } from "fs";
-import { dirname as dirname9, join as join15 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname9, join as join16 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join15(getDataDir(), "skills.db");
+  return join16(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
   const dir = dirname9(dbPath);
-  if (!existsSync15(dir))
+  if (!existsSync16(dir))
     mkdirSync11(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
@@ -11348,14 +11396,14 @@ function saveFeedback(input) {
 // src/lib/native-storage.ts
 import { createHash as createHash5, createHmac as createHmac2 } from "crypto";
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync14,
-  readdirSync as readdirSync8,
-  statSync as statSync8,
+  readFileSync as readFileSync15,
+  readdirSync as readdirSync9,
+  statSync as statSync9,
   writeFileSync as writeFileSync11
 } from "fs";
-import { dirname as dirname10, join as join16, normalize as normalize3, relative as relative4, sep as sep2 } from "path";
+import { dirname as dirname10, join as join17, normalize as normalize3, relative as relative4, sep as sep2 } from "path";
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
   "skills_sync_cursors"
@@ -11393,6 +11441,55 @@ var SKILLS_NATIVE_STORAGE_FALLBACK_ENV = {
 };
 var SKILLS_STORAGE_ENV = SKILLS_NATIVE_STORAGE_ENV;
 var SKILLS_STORAGE_FALLBACK_ENV = SKILLS_NATIVE_STORAGE_FALLBACK_ENV;
+var storageCapabilities = {
+  version: 1,
+  values: [
+    "SKILLS_NATIVE_STORAGE_ENV",
+    "SKILLS_NATIVE_STORAGE_FALLBACK_ENV",
+    "SKILLS_STORAGE_ENV",
+    "SKILLS_STORAGE_FALLBACK_ENV",
+    "SKILLS_STORAGE_TABLES",
+    "STORAGE_TABLES",
+    "SkillsPostgresSyncStore",
+    "SkillsS3ObjectStore",
+    "buildSkillsS3ObjectUrl",
+    "createSkillsPostgresSyncStore",
+    "createSkillsS3ObjectStore",
+    "createSkillsSnapshotSyncRecord",
+    "exportSkillsLocalSnapshot",
+    "getSkillsNativeStorageStatus",
+    "getSkillsStorageDatabaseEnv",
+    "getSkillsStorageDatabaseUrl",
+    "getSkillsStorageStatus",
+    "getStorageDatabaseEnv",
+    "getStorageDatabaseUrl",
+    "getStorageStatus",
+    "importSkillsLocalSnapshot",
+    "planSkillsS3SnapshotUpload",
+    "resolveSkillsNativeStorageConfig",
+    "resolveStorageConfig",
+    "signSkillsAwsV4Request",
+    "skillsPostgresSyncSchemaSql",
+    "storageCapabilities",
+    "uploadSkillsSnapshotFilesToS3"
+  ],
+  types: [
+    "AwsCredentials",
+    "SignSkillsAwsV4RequestOptions",
+    "SkillsFetch",
+    "SkillsLocalSnapshot",
+    "SkillsNativeStorageConfig",
+    "SkillsNativeStorageStatus",
+    "SkillsPostgresQueryClient",
+    "SkillsS3ObjectStoreOptions",
+    "SkillsS3PutObjectOptions",
+    "SkillsS3SnapshotPlanEntry",
+    "SkillsS3StoredObject",
+    "SkillsSnapshotFile",
+    "SkillsStorageTable",
+    "SkillsSyncRecord"
+  ]
+};
 var SKILLS_ENV_NAMESPACE = "SKILLS";
 function resolveSkillsNativeStorageConfig(env = process.env) {
   assertNoRetiredModeEnvVars(env, {
@@ -11443,7 +11540,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join16(getDataDir(), "skills.db")
+      feedbackDbPath: join17(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config.databaseUrl),
@@ -11466,9 +11563,9 @@ function getStorageStatus(options = {}) {
 function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const projectStateDir = getProjectStateDir(targetDir);
   const files = [];
-  if (existsSync16(projectStateDir)) {
+  if (existsSync17(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync14(filePath);
+      const bytes = readFileSync15(filePath);
       const relativePath = toPosix(relative4(targetDir, filePath));
       files.push({
         path: relativePath,
@@ -11493,7 +11590,7 @@ function importSkillsLocalSnapshot(snapshot, targetDir = process.cwd(), options
       continue;
     }
     const absolutePath = resolveSnapshotPath(targetDir, file.path);
-    if (existsSync16(absolutePath) && !options.overwrite) {
+    if (existsSync17(absolutePath) && !options.overwrite) {
       skipped += 1;
       continue;
     }
@@ -11799,9 +11896,9 @@ function parsePositiveInteger(value) {
 }
 function walkFiles2(dir) {
   const files = [];
-  for (const entry of readdirSync8(dir)) {
-    const full = join16(dir, entry);
-    const stats = statSync8(full);
+  for (const entry of readdirSync9(dir)) {
+    const full = join17(dir, entry);
+    const stats = statSync9(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
     else
@@ -11817,7 +11914,7 @@ function resolveSnapshotPath(targetDir, snapshotPath) {
   if (!toPosix(normalizedPath).startsWith(".skills/")) {
     throw new Error(`Snapshot path must stay inside .skills: ${snapshotPath}`);
   }
-  return join16(targetDir, normalizedPath);
+  return join17(targetDir, normalizedPath);
 }
 function normalizeS3Prefix(prefix) {
   return (prefix ?? "").trim().replace(/^\/+|\/+$/g, "");
@@ -11899,6 +11996,7 @@ export {
   unpinProjectSkill,
   syncSkillsToAgents,
   summarizeMcpToolContract,
+  storageCapabilities,
   skillsPostgresSyncSchemaSql,
   skillExists,
   signSkillsAwsV4Request,