@hasna/skills 0.1.64 → 0.1.66

package/bin/index.js

@@ -36860,7 +36860,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.1.64",
+    version: "0.1.66",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -38888,6 +38888,8 @@ var init_registry_data = __esm(() => {
 });
 
 // src/lib/hosted-skill-set.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
 function normalizeMarker(value) {
   return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
@@ -38897,6 +38899,16 @@ function isHostedMetadataPackage(pkg) {
     return false;
   return HOSTED_RUNTIMES.has(normalizeMarker(skills.runtime)) || HOSTED_SOURCES.has(normalizeMarker(skills.source));
 }
+function isHostedMetadataSkillDir(skillDir) {
+  const pkgPath = join4(skillDir, "package.json");
+  if (!existsSync4(pkgPath))
+    return false;
+  try {
+    return isHostedMetadataPackage(JSON.parse(readFileSync3(pkgPath, "utf8")));
+  } catch {
+    return false;
+  }
+}
 var HOSTED_RUNTIMES, HOSTED_SOURCES, HOSTED_METADATA_SET_EMPTY_ERROR, SLUG = "[^,{}/]+", BRACE_SOURCE_EXCLUSION, SINGLE_SOURCE_EXCLUSION;
 var init_hosted_skill_set = __esm(() => {
   HOSTED_RUNTIMES = new Set(["hosted"]);
@@ -38917,13 +38929,13 @@ var init_hosted_skill_set = __esm(() => {
 });
 
 // src/lib/skill-validation.ts
-import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { isAbsolute, join as join4, normalize } from "path";
+import { existsSync as existsSync5, lstatSync, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join5, normalize } from "path";
 function add2(target, code, message) {
   target.push({ code, message });
 }
 function readJsonFile(path) {
-  return JSON.parse(readFileSync3(path, "utf-8"));
+  return JSON.parse(readFileSync4(path, "utf-8"));
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -39007,7 +39019,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     binCommands: [],
     docFiles: []
   };
-  if (!existsSync4(skillPath)) {
+  if (!existsSync5(skillPath)) {
     add2(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
     return {
       name: bareName,
@@ -39021,8 +39033,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   if (!VALID_BIN_COMMAND.test(bareName)) {
     add2(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 = join4(skillPath, entry);
+  for (const entry of readdirSync3(skillPath).sort()) {
+    const entryPath = join5(skillPath, entry);
     if (RESERVED_SKILL_ENTRIES.has(entry)) {
       add2(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
     }
@@ -39034,15 +39046,15 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync4(join4(skillPath, docFile)))
+    if (existsSync5(join5(skillPath, docFile)))
       metadata.docFiles.push(docFile);
   }
   if (metadata.docFiles.length === 0) {
     add2(issues, "skill.docs_missing", "Missing documentation file: expected SKILL.md, README.md, or CLAUDE.md");
   }
-  const skillMdPath = join4(skillPath, "SKILL.md");
-  if (existsSync4(skillMdPath)) {
-    const frontmatter = parseSkillFrontmatter(readFileSync3(skillMdPath, "utf-8"));
+  const skillMdPath = join5(skillPath, "SKILL.md");
+  if (existsSync5(skillMdPath)) {
+    const frontmatter = parseSkillFrontmatter(readFileSync4(skillMdPath, "utf-8"));
     if (!frontmatter) {
       add2(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
     } else {
@@ -39084,8 +39096,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join4(skillPath, "package.json");
-  if (!existsSync4(pkgPath)) {
+  const pkgPath = join5(skillPath, "package.json");
+  if (!existsSync5(pkgPath)) {
     if (!isInstruction)
       add2(issues, "package.missing", "Missing package.json");
   } else {
@@ -39143,10 +39155,10 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
               add2(issues, "package.bin_target_unsafe", `package.json bin '${command}' target '${target}' must stay inside the skill directory`);
               continue;
             }
-            const targetPath = join4(skillPath, target);
-            if (!existsSync4(targetPath)) {
+            const targetPath = join5(skillPath, target);
+            if (!existsSync5(targetPath)) {
               add2(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()) {
               add2(issues, "package.bin_target_directory", `package.json bin '${command}' target '${target}' must point to a file, not a directory`);
             }
           }
@@ -39161,18 +39173,18 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join4(skillPath, "src");
+    const srcDir = join5(skillPath, "src");
     if (hostedMetadata) {
-      if (existsSync4(srcDir)) {
+      if (existsSync5(srcDir)) {
         add2(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
       }
-    } else if (!existsSync4(srcDir)) {
+    } else if (!existsSync5(srcDir)) {
       add2(issues, "skill.src_missing", "Missing src/ directory");
-    } else if (!existsSync4(join4(srcDir, "index.ts")) && !existsSync4(join4(srcDir, "index.js"))) {
+    } else if (!existsSync5(join5(srcDir, "index.ts")) && !existsSync5(join5(srcDir, "index.js"))) {
       add2(issues, "skill.src_index_missing", "Missing src/index.ts or src/index.js");
     } else {
-      const indexPath = existsSync4(join4(srcDir, "index.ts")) ? join4(srcDir, "index.ts") : join4(srcDir, "index.js");
-      const size2 = statSync2(indexPath).size;
+      const indexPath = existsSync5(join5(srcDir, "index.ts")) ? join5(srcDir, "index.ts") : join5(srcDir, "index.js");
+      const size2 = statSync3(indexPath).size;
       if (size2 < 50)
         add2(warnings, "skill.src_index_minimal", `Source entry point is very small (${size2}B)`);
     }
@@ -39242,8 +39254,8 @@ var init_skill_validation = __esm(() => {
 
 // src/lib/skill-hash.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import { join as join5, sep } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { join as join6, sep } from "path";
 function normalizeLineEndings(content) {
   return content.replace(/\r\n/g, `
 `).replace(/\r/g, `
@@ -39289,10 +39301,10 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join5(skillPath, entry);
-    if (!existsSync5(absolute))
+    const absolute = join6(skillPath, entry);
+    if (!existsSync6(absolute))
       continue;
-    if (statSync3(absolute).isDirectory())
+    if (statSync4(absolute).isDirectory())
       collectDirectory(files, absolute, entry);
     else
       collectFile(files, absolute, entry);
@@ -39300,14 +39312,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 = join5(dir, entry);
+    const absolute = join6(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
-      stats = statSync3(absolute);
+      stats = statSync4(absolute);
     } catch {
       continue;
     }
@@ -39323,7 +39335,7 @@ function collectDirectory(files, dir, rel) {
   }
 }
 function collectFile(files, absolute, rel) {
-  const buffer = readFileSync4(absolute);
+  const buffer = readFileSync5(absolute);
   if (rel === "skill.json") {
     files.push({ rel: rel.split(sep).join("/"), content: new TextEncoder().encode(canonicalizeManifest(new TextDecoder().decode(buffer))) });
     return;
@@ -39378,7 +39390,7 @@ function hashSkillMarkdown(content) {
   return hash.digest("hex");
 }
 function hashSkillMarkdownFile(path) {
-  return hashSkillMarkdown(readFileSync4(path, "utf-8"));
+  return hashSkillMarkdown(readFileSync5(path, "utf-8"));
 }
 var CONTENT_HASH_ALGORITHM = "sha256", HASH_EXCLUDE_DIRS, HASH_COVERAGE;
 var init_skill_hash = __esm(() => {
@@ -39558,14 +39570,14 @@ var init_skill_contract = __esm(() => {
 // src/lib/portable-skills-files.ts
 import {
   cpSync,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   realpathSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join6, relative } from "path";
+import { basename, dirname as dirname2, join as join7, relative } from "path";
 function defaultRuntimeContract(entrypoint = "src/index.ts") {
   return {
     runtime: "bun",
@@ -39589,12 +39601,12 @@ function normalizePortableSkillName(name) {
   return normalized;
 }
 function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
-  const skillJsonPath = join6(skillPath, "skill.json");
-  const skillMdPath = join6(skillPath, "SKILL.md");
-  const pkgPath = join6(skillPath, "package.json");
-  const jsonManifest = existsSync6(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync6(skillMdPath) ? parseSkillFrontmatter(readFileSync5(skillMdPath, "utf-8")) ?? undefined : undefined;
-  const pkg = existsSync6(pkgPath) ? readJsonObject(pkgPath) : undefined;
+  const skillJsonPath = join7(skillPath, "skill.json");
+  const skillMdPath = join7(skillPath, "SKILL.md");
+  const pkgPath = join7(skillPath, "package.json");
+  const jsonManifest = existsSync7(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
+  const frontmatter = existsSync7(skillMdPath) ? parseSkillFrontmatter(readFileSync6(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const pkg = existsSync7(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;
@@ -39640,7 +39652,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join6(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join7(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -39689,12 +39701,12 @@ function createPortableManifest(name, options) {
   };
 }
 function writePortableSkillTemplate(skillPath, manifest) {
-  mkdirSync2(join6(skillPath, "src"), { recursive: true });
-  writeFileSync2(join6(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync2(join6(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync2(join6(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync2(join6(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync2(join6(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+  mkdirSync2(join7(skillPath, "src"), { recursive: true });
+  writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync2(join7(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync2(join7(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync2(join7(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync2(join7(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -39719,7 +39731,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join6(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync2(join7(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash = computeContentHash(skillPath);
   const withHash = {
@@ -39729,16 +39741,16 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join6(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync2(join7(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
 `);
   return withHash;
 }
 function readExistingSkillJson(skillPath) {
-  const path = join6(skillPath, "skill.json");
-  if (!existsSync6(path))
+  const path = join7(skillPath, "skill.json");
+  if (!existsSync7(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
     return isRecord2(parsed) ? parsed : {};
   } catch {
     return {};
@@ -39768,28 +39780,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 && !existsSync6(join6(skillPath, entry))) {
-    mkdirSync2(dirname2(join6(skillPath, entry)), { recursive: true });
-    writeFileSync2(join6(skillPath, entry), renderEntrypoint(next));
+  if (entry && !existsSync7(join7(skillPath, entry))) {
+    mkdirSync2(dirname2(join7(skillPath, entry)), { recursive: true });
+    writeFileSync2(join7(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync6(join6(skillPath, "SKILL.md")))
-    writeFileSync2(join6(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync7(join7(skillPath, "SKILL.md")))
+    writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync2(join6(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync5(join6(skillPath, "SKILL.md"), "utf-8"), next));
-  if (!existsSync6(join6(skillPath, "AGENTS.md")))
-    writeFileSync2(join6(skillPath, "AGENTS.md"), renderAgentsMd(next));
+    writeFileSync2(join7(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync6(join7(skillPath, "SKILL.md"), "utf-8"), next));
+  if (!existsSync7(join7(skillPath, "AGENTS.md")))
+    writeFileSync2(join7(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
-  if (!existsSync6(join6(skillPath, "tsconfig.json")))
-    writeFileSync2(join6(skillPath, "tsconfig.json"), renderTsconfig());
+  if (!existsSync7(join7(skillPath, "tsconfig.json")))
+    writeFileSync2(join7(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
 function ensurePackageJson(skillPath, manifest) {
-  const pkgPath = join6(skillPath, "package.json");
+  const pkgPath = join7(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 (!existsSync6(pkgPath)) {
+  if (!existsSync7(pkgPath)) {
     writeFileSync2(pkgPath, renderPackageJson(manifest));
     return;
   }
@@ -39832,8 +39844,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync6(join6(skillPath, "SKILL.md"))) {
-    writeFileSync2(join6(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync7(join7(skillPath, "SKILL.md"))) {
+    writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(next));
   }
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
@@ -40084,7 +40096,7 @@ function inferPackageCommands(pkg, fallbackName) {
   return;
 }
 function readJsonObject(path) {
-  const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+  const parsed = JSON.parse(readFileSync6(path, "utf-8"));
   if (!isRecord2(parsed))
     throw new Error(`${basename(path)} must contain a JSON object`);
   return parsed;
@@ -40140,48 +40152,49 @@ var init_portable_skills_files = __esm(() => {
 // src/lib/portable-skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   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 join7, normalize as normalize2 } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join8, normalize as normalize2 } from "path";
 function getPortableSkillsRoot(options = {}) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join7(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache3 = join7(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join8(options.homeDir, ".hasna", "skills") : getDataDir();
+  const cache3 = join8(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache3))
     return cache3;
-  const installed = join7(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join8(appDir, INSTALLED_SKILLS_DIRNAME);
   migrateLegacySkillLayout(appDir, installed);
   return installed;
 }
 function looksLikeSkillDirectory(path) {
   if (!safeIsDirectory(path))
     return false;
-  return existsSync7(join7(path, "SKILL.md")) || existsSync7(join7(path, "skill.json")) || existsSync7(join7(path, "package.json"));
+  return existsSync8(join8(path, "SKILL.md")) || existsSync8(join8(path, "skill.json")) || existsSync8(join8(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 = join7(appDir, entry);
+      const path = join8(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 = join7(path, nested);
+            const nestedPath = join8(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -40195,10 +40208,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join7(installed, name);
-    if (existsSync7(target))
+    const target = join8(installed, name);
+    if (existsSync8(target))
       continue;
-    const staging = join7(installed, `.migrating-${name}-${process.pid}`);
+    const staging = join8(installed, `.migrating-${name}-${process.pid}`);
     try {
       rmSync(staging, { recursive: true, force: true });
       cpSync2(from, staging, { recursive: true, errorOnExist: false });
@@ -40211,7 +40224,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join7(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join8(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -40221,7 +40234,7 @@ function findPortableSkill(name, options = {}) {
     return null;
   }
   const path = getPortableSkillPath(normalized, options);
-  if (!existsSync7(path) || !statSync5(path).isDirectory())
+  if (!existsSync8(path) || !statSync6(path).isDirectory())
     return null;
   try {
     return summarizePortableSkill(path, normalized);
@@ -40234,10 +40247,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 = join7(root, entry);
+    const path = join8(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -40259,7 +40272,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 } : {}
     };
   });
 }
@@ -40269,8 +40283,8 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizePortableSkillName(name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join7(root, skillName);
-  if (existsSync7(skillPath)) {
+  const skillPath = join8(root, skillName);
+  if (existsSync8(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
     rmSync(skillPath, { recursive: true, force: true });
@@ -40288,7 +40302,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkillDirectory(sourceDir, options = {}) {
   const absoluteSource = normalize2(sourceDir);
-  if (!existsSync7(absoluteSource) || !statSync5(absoluteSource).isDirectory()) {
+  if (!existsSync8(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Import directory not found: ${sourceDir}`);
   }
   const continueOnError = options.continueOnError ?? true;
@@ -40299,9 +40313,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 = join7(absoluteSource, entryName);
+    const childPath = join8(absoluteSource, entryName);
     if (!safeIsDirectory(childPath))
       continue;
     if (!isSkillCandidate(childPath)) {
@@ -40330,11 +40344,11 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
 }
 function isSkillCandidate(dir) {
-  return existsSync7(join7(dir, "SKILL.md")) || existsSync7(join7(dir, "skill.json")) || existsSync7(join7(dir, "package.json"));
+  return existsSync8(join8(dir, "SKILL.md")) || existsSync8(join8(dir, "skill.json")) || existsSync8(join8(dir, "package.json"));
 }
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize2(sourcePath);
-  if (!existsSync7(absoluteSource) || !statSync5(absoluteSource).isDirectory()) {
+  if (!existsSync8(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Skill source directory not found: ${sourcePath}`);
   }
   const inferred = readPortableSkillManifest(absoluteSource, basename2(absoluteSource));
@@ -40346,8 +40360,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 = join7(root, skillName);
-  if (existsSync7(destination)) {
+  const destination = join8(root, skillName);
+  if (existsSync8(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync(destination, { recursive: true, force: true });
@@ -40369,16 +40383,10 @@ function safeNormalizeName(name) {
     return;
   }
 }
-function writeCorpusSkill(input, options = {}) {
-  const name = normalizePortableSkillName(input.name);
-  const root = getPortableSkillsRoot(options);
-  const skillPath = join7(root, name);
-  const created = !existsSync7(skillPath);
-  mkdirSync3(skillPath, { recursive: true });
-  writeFileSync3(join7(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,
@@ -40391,8 +40399,38 @@ function writeCorpusSkill(input, options = {}) {
     inputs: [],
     commands: []
   };
-  writeSkillJsonWithHash(skillPath, manifest);
-  return { name, path: skillPath, manifest, created };
+}
+function installCorpusSkillAtomically(input, options = {}) {
+  const name = normalizePortableSkillName(input.name);
+  const root = getPortableSkillsRoot(options);
+  const target = join8(root, name);
+  const created = !existsSync8(target);
+  mkdirSync3(root, { recursive: true });
+  const staging = mkdtempSync(join8(root, `.pull-${name}-`));
+  let moved = false;
+  let backup = null;
+  try {
+    writeFileSync3(join8(staging, "SKILL.md"), input.skillMd);
+    const manifest = buildCorpusManifest(input, name);
+    writeSkillJsonWithHash(staging, manifest);
+    if (existsSync8(target)) {
+      backup = mkdtempSync(join8(root, `.pull-backup-${name}-`));
+      renameSync(target, join8(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 && existsSync8(join8(backup, name))) {
+      try {
+        renameSync(join8(backup, name), target);
+      } catch {}
+    }
+    throw error;
+  }
 }
 function validatePortableSkillDirectory(name, skillPath) {
   const normalizedName = normalizePortableSkillName(name);
@@ -40400,10 +40438,10 @@ function validatePortableSkillDirectory(name, skillPath) {
   const issues = [...base2.issues];
   const warnings = [...base2.warnings];
   let manifest;
-  if (existsSync7(skillPath)) {
-    const skillJsonPath = join7(skillPath, "skill.json");
-    const skillMdPath = join7(skillPath, "SKILL.md");
-    if (!existsSync7(skillJsonPath) && !existsSync7(skillMdPath)) {
+  if (existsSync8(skillPath)) {
+    const skillJsonPath = join8(skillPath, "skill.json");
+    const skillMdPath = join8(skillPath, "SKILL.md");
+    if (!existsSync8(skillJsonPath) && !existsSync8(skillMdPath)) {
       add4(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
     try {
@@ -40422,7 +40460,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add4(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync7(join7(skillPath, "skill.json")),
+        strict: existsSync8(join8(skillPath, "skill.json")),
         skillPath
       });
       for (const issue of contractIssues)
@@ -40458,10 +40496,10 @@ function validatePortableSkillDirectory(name, skillPath) {
               add4(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
               continue;
             }
-            const entryPath = join7(skillPath, command.entry);
-            if (!existsSync7(entryPath))
+            const entryPath = join8(skillPath, command.entry);
+            if (!existsSync8(entryPath))
               add4(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
-            else if (statSync5(entryPath).isDirectory())
+            else if (statSync6(entryPath).isDirectory())
               add4(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
           }
         }
@@ -40469,7 +40507,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error) {
       add4(issues, "portable.manifest_invalid", error.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync7(join7(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync8(join8(skillPath, "AGENTS.md"))) {
       add4(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -40501,7 +40539,7 @@ function summarizePortableSkill(skillPath, fallbackName) {
 }
 function safeIsDirectory(path) {
   try {
-    return statSync5(path).isDirectory();
+    return statSync6(path).isDirectory();
   } catch {
     return false;
   }
@@ -40522,6 +40560,7 @@ var LEGACY_CUSTOM_DIRNAME = "custom", OFFICIAL_SKILL_NAMES;
 var init_portable_skills = __esm(() => {
   init_config();
   init_registry_data();
+  init_hosted_skill_set();
   init_skill_validation();
   init_skill_contract();
   init_portable_skills_files();
@@ -40737,8 +40776,8 @@ __export(exports_registry, {
   CATEGORIES: () => CATEGORIES,
   BASIC_SKILL_NAMES: () => BASIC_SKILL_NAMES
 });
-import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync6 } from "fs";
+import { join as join9 } from "path";
 function isBasicSkillName(name) {
   return BASIC_SKILL_NAMES.includes(name);
 }
@@ -40774,20 +40813,20 @@ function parseSkillMdFrontmatter(content) {
   return Object.keys(result2).length > 0 ? result2 : null;
 }
 function discoverSkillsInDir(dir, source = "custom") {
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     return [];
   const result2 = [];
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join8(dir, entry.name, "SKILL.md");
-      if (!existsSync8(skillMdPath))
+      const skillMdPath = join9(dir, entry.name, "SKILL.md");
+      if (!existsSync9(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync6(skillMdPath, "utf-8");
+        content = readFileSync7(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -40802,6 +40841,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
+        ...isHostedMetadataSkillDir(join9(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -40810,20 +40850,20 @@ function discoverSkillsInDir(dir, source = "custom") {
 }
 function findExtensionSkillPath(name) {
   const config = loadConfig();
-  if (!config.extensionsDir || !existsSync8(config.extensionsDir))
+  if (!config.extensionsDir || !existsSync9(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 = join8(config.extensionsDir, entry.name);
-      const skillMdPath = join8(skillDir, "SKILL.md");
-      if (!existsSync8(skillMdPath))
+      const skillDir = join9(config.extensionsDir, entry.name);
+      const skillMdPath = join9(skillDir, "SKILL.md");
+      if (!existsSync9(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync6(skillMdPath, "utf-8");
+        content = readFileSync7(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -40852,7 +40892,7 @@ function loadRegistry(cwd2) {
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
   const extensions = config.extensionsDir ? discoverSkillsInDir(config.extensionsDir, "extension") : [];
   const portableCustom = listPortableSkillMetas();
-  const legacyCustom = discoverSkillsInDir(join8(dataDir, "custom"));
+  const legacyCustom = discoverSkillsInDir(join9(dataDir, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now3;
@@ -40902,6 +40942,7 @@ var registryCache = null, registryCacheTime = 0, registryCacheKey = null, REGIST
 var init_registry = __esm(() => {
   init_config();
   init_portable_skills();
+  init_hosted_skill_set();
   init_registry_merge();
   init_skill_aliases();
   init_registry_data();
@@ -42550,33 +42591,33 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/home-migration.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readdirSync as readdirSync6, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync7, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join10 } from "path";
 function layoutMigrationRecordPath(appDir) {
-  return join9(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
+  return join10(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
 }
 function resolveCorpusRoot(options = {}) {
   return getPortableSkillsRoot(options);
 }
 function migrationAppDir(homeDir) {
-  return homeDir ? join9(homeDir, ".hasna", "skills") : getDataDir();
+  return homeDir ? join10(homeDir, ".hasna", "skills") : getDataDir();
 }
 function looksLikeSkillDirectory2(path) {
   try {
-    if (!statSync6(path).isDirectory())
+    if (!statSync7(path).isDirectory())
       return false;
   } catch {
     return false;
   }
-  return existsSync9(join9(path, "SKILL.md")) || existsSync9(join9(path, "skill.json")) || existsSync9(join9(path, "package.json"));
+  return existsSync10(join10(path, "SKILL.md")) || existsSync10(join10(path, "skill.json")) || existsSync10(join10(path, "package.json"));
 }
 function listLegacyFlatSkillDirs(appDir) {
   const legacy = [];
-  if (!existsSync9(appDir))
+  if (!existsSync10(appDir))
     return legacy;
   let entries = [];
   try {
-    entries = readdirSync6(appDir);
+    entries = readdirSync7(appDir);
   } catch {
     return legacy;
   }
@@ -42586,15 +42627,15 @@ function listLegacyFlatSkillDirs(appDir) {
     if (entry === SKILLS_CACHE_DIRNAME || entry === INSTALLED_SKILLS_DIRNAME || entry === LEGACY_CUSTOM_DIRNAME2 || entry === LOGS_DIRNAME || entry === OUTPUTS_DIRNAME) {
       continue;
     }
-    if (looksLikeSkillDirectory2(join9(appDir, entry)))
+    if (looksLikeSkillDirectory2(join10(appDir, entry)))
       legacy.push(entry);
   }
   return legacy;
 }
 function createLazyDirs(appDir, created) {
   for (const name of [LOGS_DIRNAME, OUTPUTS_DIRNAME]) {
-    const dir = join9(appDir, name);
-    if (!existsSync9(dir)) {
+    const dir = join10(appDir, name);
+    if (!existsSync10(dir)) {
       mkdirSync4(dir, { recursive: true });
       created.push(dir);
     }
@@ -42602,17 +42643,17 @@ function createLazyDirs(appDir, created) {
 }
 function migrateOwnerLayout(options = {}) {
   const appDir = migrationAppDir(options.homeDir);
-  const cache3 = join9(appDir, SKILLS_CACHE_DIRNAME);
-  const installed = join9(appDir, INSTALLED_SKILLS_DIRNAME);
+  const cache3 = join10(appDir, SKILLS_CACHE_DIRNAME);
+  const installed = join10(appDir, INSTALLED_SKILLS_DIRNAME);
   const moved = [];
   const created = [];
   if (isOwnerLayoutMigrated(appDir)) {
     return { status: "already-migrated", moved, created };
   }
-  if (existsSync9(cache3)) {
+  if (existsSync10(cache3)) {
     let entries = [];
     try {
-      entries = readdirSync6(cache3);
+      entries = readdirSync7(cache3);
     } catch {}
     if (entries.length > 0) {
       return {
@@ -42623,7 +42664,7 @@ function migrateOwnerLayout(options = {}) {
       };
     }
   }
-  const installedPresent = existsSync9(installed);
+  const installedPresent = existsSync10(installed);
   const legacy = listLegacyFlatSkillDirs(appDir);
   const planned = [...installedPresent ? [INSTALLED_SKILLS_DIRNAME] : [], ...legacy];
   if (!installedPresent && legacy.length === 0) {
@@ -42636,10 +42677,10 @@ function migrateOwnerLayout(options = {}) {
   }
   const collisionNames = new Set;
   for (const dir of [cache3, ...installedPresent ? [installed] : []]) {
-    if (!existsSync9(dir))
+    if (!existsSync10(dir))
       continue;
     try {
-      for (const entry of readdirSync6(dir))
+      for (const entry of readdirSync7(dir))
         collisionNames.add(entry);
     } catch {}
   }
@@ -42653,7 +42694,7 @@ function migrateOwnerLayout(options = {}) {
       };
     }
   }
-  if (existsSync9(cache3)) {
+  if (existsSync10(cache3)) {
     rmSync2(cache3, { recursive: true, force: true });
   }
   if (installedPresent) {
@@ -42663,7 +42704,7 @@ function migrateOwnerLayout(options = {}) {
     mkdirSync4(cache3, { recursive: true });
   }
   for (const name of legacy) {
-    renameSync2(join9(appDir, name), join9(cache3, name));
+    renameSync2(join10(appDir, name), join10(cache3, name));
     moved.push(name);
   }
   createLazyDirs(appDir, created);
@@ -42687,18 +42728,18 @@ var init_home_migration = __esm(() => {
 // src/lib/agent-sync.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync5,
-  mkdtempSync,
-  readFileSync as readFileSync7,
-  readdirSync as readdirSync7,
+  mkdtempSync as mkdtempSync2,
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync8,
   renameSync as renameSync3,
   rmSync as rmSync3,
-  statSync as statSync7,
+  statSync as statSync8,
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename3, dirname as dirname4, join as join10 } from "path";
+import { basename as basename3, dirname as dirname4, join as join11 } from "path";
 function isSyncAgent(value) {
   return SYNC_AGENTS.includes(value);
 }
@@ -42713,9 +42754,9 @@ function resolveSyncAgents(arg) {
 function agentGlobalSkillsDir(agent, homeDir = homedir3()) {
   switch (agent) {
     case "opencode":
-      return join10(homeDir, ".config", "opencode", "skills");
+      return join11(homeDir, ".config", "opencode", "skills");
     default:
-      return join10(homeDir, `.${agent}`, "skills");
+      return join11(homeDir, `.${agent}`, "skills");
   }
 }
 function adaptSkillMdForAgent(skillMd, agent) {
@@ -42773,8 +42814,8 @@ function resolveSyncCorpus(options = {}) {
 function packageSourceRoots(source) {
   const roots = [];
   for (const sub of ["skills"]) {
-    const candidate = join10(source, sub);
-    if (existsSync10(candidate) && isDirectory(candidate))
+    const candidate = join11(source, sub);
+    if (existsSync11(candidate) && isDirectory(candidate))
       roots.push(candidate);
   }
   if (roots.length > 0)
@@ -42784,20 +42825,20 @@ function packageSourceRoots(source) {
 function containsSkillDirectories(path) {
   let entries;
   try {
-    entries = readdirSync7(path);
+    entries = readdirSync8(path);
   } catch {
     return false;
   }
   return entries.some((entry) => {
-    const candidate = join10(path, entry);
+    const candidate = join11(path, entry);
     if (!isDirectory(candidate))
       return false;
-    return existsSync10(join10(candidate, "SKILL.md")) || existsSync10(join10(candidate, "skill.json")) || existsSync10(join10(candidate, "package.json"));
+    return existsSync11(join11(candidate, "SKILL.md")) || existsSync11(join11(candidate, "skill.json")) || existsSync11(join11(candidate, "package.json"));
   });
 }
 function isDirectory(path) {
   try {
-    return statSync7(path).isDirectory();
+    return statSync8(path).isDirectory();
   } catch {
     return false;
   }
@@ -42831,7 +42872,7 @@ function syncSkillsToAgents(options = {}) {
         actions.push({
           skill: name,
           agent,
-          path: join10(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
+          path: join11(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
           action: "skip",
           reason: "not found in this machine's corpus"
         });
@@ -42841,7 +42882,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);
@@ -42861,7 +42902,7 @@ function syncSkillsToAgents(options = {}) {
 }
 function writeManagedAgentSkill(params) {
   const homeDir = params.homeDir ?? homedir3();
-  const dir = join10(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
+  const dir = join11(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
   const result2 = writeManagedSkillDir(dir, params.skillMd, {
     skill: params.skill,
     source: params.source,
@@ -42878,11 +42919,11 @@ function writeManagedAgentSkill(params) {
   };
 }
 function writeManagedSkillDir(dir, skillMd, options) {
-  const skillMdPath = join10(dir, "SKILL.md");
-  const markerPath = join10(dir, SYNC_MARKER_FILE);
-  const dirExists = existsSync10(dir);
-  const managed = existsSync10(markerPath);
-  const hasSkillMd = existsSync10(skillMdPath);
+  const skillMdPath = join11(dir, "SKILL.md");
+  const markerPath = join11(dir, SYNC_MARKER_FILE);
+  const dirExists = existsSync11(dir);
+  const managed = existsSync11(markerPath);
+  const hasSkillMd = existsSync11(skillMdPath);
   if (dirExists && !managed && !hasSkillMd) {
     return {
       action: "skip",
@@ -42900,7 +42941,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
   if (dirExists && managed && hasSkillMd && !options.force && isPointerSkillMd(skillMd)) {
     let existingIsStub = false;
     try {
-      existingIsStub = isPointerSkillMd(readFileSync7(skillMdPath, "utf-8"));
+      existingIsStub = isPointerSkillMd(readFileSync8(skillMdPath, "utf-8"));
     } catch {
       existingIsStub = false;
     }
@@ -42917,11 +42958,11 @@ function writeManagedSkillDir(dir, skillMd, options) {
     return { action, path: skillMdPath };
   const parentDir = dirname4(dir);
   mkdirSync5(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync(join10(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
-  const candidateDir = join10(transactionDir, "candidate");
-  const backupDir = join10(transactionDir, "backup");
-  const candidateSkillMdPath = join10(candidateDir, "SKILL.md");
-  const candidateMarkerPath = join10(candidateDir, SYNC_MARKER_FILE);
+  const transactionDir = mkdtempSync2(join11(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
+  const candidateDir = join11(transactionDir, "candidate");
+  const backupDir = join11(transactionDir, "backup");
+  const candidateSkillMdPath = join11(candidateDir, "SKILL.md");
+  const candidateMarkerPath = join11(candidateDir, SYNC_MARKER_FILE);
   const marker = {
     managedBy: SYNC_MARKER_MANAGED_BY,
     skill: options.skill,
@@ -42948,9 +42989,9 @@ function writeManagedSkillDir(dir, skillMd, options) {
     }
     renameDirectory(candidateDir, dir);
   } catch (error) {
-    if (originalMoved && existsSync10(backupDir)) {
+    if (originalMoved && existsSync11(backupDir)) {
       try {
-        if (existsSync10(dir))
+        if (existsSync11(dir))
           rmSync3(dir, { recursive: true, force: true });
         renameDirectory(backupDir, dir);
         originalMoved = false;
@@ -42970,10 +43011,10 @@ function writeManagedSkillDir(dir, skillMd, options) {
   return { action, path: skillMdPath };
 }
 function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = false) {
-  if (kind === "instruction" || preferBundledDocs) {
-    const skillMdPath = join10(skillPath, "SKILL.md");
-    if (existsSync10(skillMdPath))
-      return readFileSync7(skillMdPath, "utf-8");
+  if (kind === undefined || kind === "instruction" || preferBundledDocs) {
+    const skillMdPath = join11(skillPath, "SKILL.md");
+    if (existsSync11(skillMdPath))
+      return readFileSync8(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -43009,20 +43050,20 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join12 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join11(targetDir, SKILLS_PROJECT_DIR);
+  return join12(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join11(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join12(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync8(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync9(path, "utf-8")));
   } catch {
     return null;
   }
@@ -43176,44 +43217,44 @@ __export(exports_installer, {
   AGENT_TARGETS: () => AGENT_TARGETS,
   AGENT_LABELS: () => AGENT_LABELS
 });
-import { existsSync as existsSync12, readFileSync as readFileSync9, rmSync as rmSync4 } from "fs";
-import { dirname as dirname5, join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync10, rmSync as rmSync4 } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
 import { homedir as homedir4 } from "os";
 import { fileURLToPath } from "url";
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join12(dir, "skills");
-    if (existsSync12(candidate) && !dir.includes(".skills"))
+    const candidate = join13(dir, "skills");
+    if (existsSync13(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname5(dir);
   }
-  return join12(__dirname2, "..", "skills");
+  return join13(__dirname2, "..", "skills");
 }
 function getSkillPath(name) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join12(getDataDir(), "custom", skillName);
-  if (existsSync12(legacyCustomPath))
+  const legacyCustomPath = join13(getDataDir(), "custom", skillName);
+  if (existsSync13(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join12(SKILLS_DIR, skillName);
+  return join13(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
 }
 function skillExists(name) {
-  return existsSync12(getSkillPath(name));
+  return existsSync13(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync12(getSkillPath(name))) {
+  if (!existsSync13(getSkillPath(name))) {
     const knownOfficial = Boolean(getSkill(name));
     return {
       skill: canonicalName,
@@ -43263,7 +43304,7 @@ function installRemoteSkill(skill, options = {}) {
 }
 function installSkillSource(name, _options = {}) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync12(getSkillPath(name))) {
+  if (!existsSync13(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found`, mode: "source" };
   }
   return {
@@ -43284,12 +43325,12 @@ function installSkillManifest(manifest, _options = {}) {
 }
 function createLocalSkillManifest(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync12(sourcePath))
+  if (!existsSync13(sourcePath))
     return null;
   let skillMd = "";
-  const skillMdPath = join12(sourcePath, "SKILL.md");
-  if (existsSync12(skillMdPath)) {
-    skillMd = readFileSync9(skillMdPath, "utf-8");
+  const skillMdPath = join13(sourcePath, "SKILL.md");
+  if (existsSync13(skillMdPath)) {
+    skillMd = readFileSync10(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -43369,20 +43410,20 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base2 = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join12(base2, ".pi", "skills") : join12(homedir4(), ".pi", "agent", "skills");
+      return scope === "project" ? join13(base2, ".pi", "skills") : join13(homedir4(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join12(base2, ".opencode", "skills") : join12(homedir4(), ".config", "opencode", "skills");
+      return scope === "project" ? join13(base2, ".opencode", "skills") : join13(homedir4(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join12(base2, `.${agent}`, "skills") : join12(homedir4(), `.${agent}`, "skills");
+      return scope === "project" ? join13(base2, `.${agent}`, "skills") : join13(homedir4(), `.${agent}`, "skills");
   }
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
-  return join12(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join13(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync12(getSkillPath(name))) {
+  if (!existsSync13(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found` };
   }
   const scope = options.scope ?? "global";
@@ -43406,16 +43447,16 @@ function removeSkillForAgent(name, options) {
   const canonicalName = getCanonicalSkillName(name);
   const scope = options.scope ?? "global";
   const dir = getAgentSkillPath(canonicalName, options.agent, scope, options.projectDir);
-  if (!existsSync12(join12(dir, SYNC_MARKER_FILE)))
+  if (!existsSync13(join13(dir, SYNC_MARKER_FILE)))
     return false;
   rmSync4(dir, { recursive: true, force: true });
   return true;
 }
 function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  const skillMdPath = join12(sourcePath, "SKILL.md");
-  if (existsSync12(skillMdPath))
-    return readFileSync9(skillMdPath, "utf-8");
+  const skillMdPath = join13(sourcePath, "SKILL.md");
+  if (existsSync13(skillMdPath))
+    return readFileSync10(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -43433,7 +43474,7 @@ function warnMissingDependencies(name, targetDir) {
 }
 function generateMinimalSkillMd(name) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync12(sourcePath))
+  if (!existsSync13(sourcePath))
     return null;
   const canonicalName = getCanonicalSkillName(name);
   const meta = getSkill(canonicalName);
@@ -43448,7 +43489,7 @@ function generateMinimalSkillMd(name) {
     "---",
     ""
   ].filter(Boolean);
-  const fallbackDoc = readFileIfExists(join12(sourcePath, "README.md")) || readFileIfExists(join12(sourcePath, "CLAUDE.md"));
+  const fallbackDoc = readFileIfExists(join13(sourcePath, "README.md")) || readFileIfExists(join13(sourcePath, "CLAUDE.md"));
   if (fallbackDoc)
     return `${frontmatter.join(`
 `)}${fallbackDoc.trim()}
@@ -43467,18 +43508,18 @@ skills run ${canonicalName}
 `;
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join12(getSkillPath(name), "package.json");
-  if (!existsSync12(pkgPath))
+  const pkgPath = join13(getSkillPath(name), "package.json");
+  if (!existsSync13(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync12(path) ? readFileSync9(path, "utf-8") : null;
+  return existsSync13(path) ? readFileSync10(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
@@ -47597,24 +47638,24 @@ __export(exports_auth_store, {
   getApiKey: () => getApiKey,
   clearAuthConfig: () => clearAuthConfig
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7, unlinkSync } from "fs";
-import { dirname as dirname6, join as join13 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7, unlinkSync } from "fs";
+import { dirname as dirname6, join as join14 } from "path";
 import { homedir as homedir5 } from "os";
 function getAuthFilePath() {
-  return join13(getDataDir(), "auth.json");
+  return join14(getDataDir(), "auth.json");
 }
 function getAuthFilePathReadOnly() {
-  return join13(getDataDirReadOnly(), "auth.json");
+  return join14(getDataDirReadOnly(), "auth.json");
 }
 function legacyAuthFilePath() {
-  return join13(process.env["HOME"] || process.env["USERPROFILE"] || homedir5(), ".skills", "auth.json");
+  return join14(process.env["HOME"] || process.env["USERPROFILE"] || homedir5(), ".skills", "auth.json");
 }
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const file = existsSync13(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
-    const raw = readFileSync10(file, "utf-8");
+    const file = existsSync14(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
+    const raw = readFileSync11(file, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiKey) {
       cachedConfig = null;
@@ -47652,8 +47693,8 @@ function getApiKey() {
 }
 function getAuthConfigReadOnly() {
   try {
-    const file = existsSync13(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
-    const raw = readFileSync10(file, "utf-8");
+    const file = existsSync14(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
+    const raw = readFileSync11(file, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiKey)
       return null;
@@ -48545,28 +48586,28 @@ __export(exports_skillinfo, {
   generateEnvExample: () => generateEnvExample,
   detectProjectSkills: () => detectProjectSkills
 });
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { join as join15 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join14(skillPath, "SKILL.md");
-  if (!existsSync14(skillMdPath))
+  const skillMdPath = join15(skillPath, "SKILL.md");
+  if (!existsSync15(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync11(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync12(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
 }
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync14(skillPath))
+  if (!existsSync15(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join14(skillPath, "SKILL.md")),
-    readme: readIfExists(join14(skillPath, "README.md")),
-    claudeMd: readIfExists(join14(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join15(skillPath, "SKILL.md")),
+    readme: readIfExists(join15(skillPath, "README.md")),
+    claudeMd: readIfExists(join15(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -48577,11 +48618,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync14(skillPath))
+  if (!existsSync15(skillPath))
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join14(skillPath, file));
+    const content = readIfExists(join15(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -48620,10 +48661,10 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join14(skillPath, "package.json");
-  if (existsSync14(pkgPath)) {
+  const pkgPath = join15(skillPath, "package.json");
+  if (existsSync15(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
     } catch {}
   }
@@ -48640,9 +48681,9 @@ function isHostedPremiumSkill(skillName, meta) {
 function isPackageResolvable(pkgName, fromDir) {
   let dir = fromDir;
   while (true) {
-    if (existsSync14(join14(dir, "node_modules", pkgName, "package.json")))
+    if (existsSync15(join15(dir, "node_modules", pkgName, "package.json")))
       return true;
-    const parent = join14(dir, "..");
+    const parent = join15(dir, "..");
     if (parent === dir)
       return false;
     dir = parent;
@@ -48662,7 +48703,7 @@ async function runSkill(name, args, options = {}) {
   const meta = getSkill(name);
   const canonicalName = meta?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync14(skillPath)) {
+  if (!existsSync15(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
   if (isInstructionSkillDir(skillPath, meta)) {
@@ -48671,13 +48712,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 = join14(skillPath, "package.json");
-  if (!existsSync14(pkgPath)) {
+  const pkgPath = join15(skillPath, "package.json");
+  if (!existsSync15(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
   try {
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint = binValues[0];
@@ -48691,12 +48732,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join14(skillPath, entryPoint);
-  if (!existsSync14(entryPath)) {
+  const entryPath = join15(skillPath, entryPoint);
+  if (!existsSync15(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join14(skillPath, "node_modules");
-  if (!existsSync14(nodeModules)) {
+  const nodeModules = join15(skillPath, "node_modules");
+  if (!existsSync15(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -48723,15 +48764,15 @@ async function runSkill(name, args, options = {}) {
   return { exitCode };
 }
 function detectProjectSkills(cwd2 = process.cwd()) {
-  const pkgPath = join14(cwd2, "package.json");
-  if (!existsSync14(pkgPath)) {
+  const pkgPath = join15(cwd2, "package.json");
+  if (!existsSync15(pkgPath)) {
     const alwaysRecommend = ["market-research-report", "repo-onboarding-report", "blog-article"];
     const recommended2 = alwaysRecommend.map((name) => loadRegistry().find((s) => s.name === name)).filter((s) => s !== undefined);
     return { detected: [], recommended: recommended2 };
   }
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
   } catch {
     const alwaysRecommend = ["market-research-report", "repo-onboarding-report", "blog-article"];
     const recommended2 = alwaysRecommend.map((name) => loadRegistry().find((s) => s.name === name)).filter((s) => s !== undefined);
@@ -48851,7 +48892,7 @@ function generateSkillMd(name) {
   if (!meta)
     return null;
   const skillPath = getSkillPath(name);
-  if (!existsSync14(skillPath))
+  if (!existsSync15(skillPath))
     return null;
   const frontmatter = [
     "---",
@@ -48860,13 +48901,13 @@ function generateSkillMd(name) {
     "---"
   ].join(`
 `);
-  const readme = readIfExists(join14(skillPath, "README.md"));
-  const claudeMd = readIfExists(join14(skillPath, "CLAUDE.md"));
+  const readme = readIfExists(join15(skillPath, "README.md"));
+  const claudeMd = readIfExists(join15(skillPath, "CLAUDE.md"));
   let cliCommand = null;
-  const pkgPath = join14(skillPath, "package.json");
-  if (existsSync14(pkgPath)) {
+  const pkgPath = join15(skillPath, "package.json");
+  if (existsSync15(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -48939,8 +48980,8 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync14(path)) {
-      return readFileSync11(path, "utf-8");
+    if (existsSync15(path)) {
+      return readFileSync12(path, "utf-8");
     }
   } catch {}
   return null;
@@ -48975,8 +49016,8 @@ var exports_introspect = {};
 __export(exports_introspect, {
   registerIntrospect: () => registerIntrospect
 });
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
+import { join as join16 } from "path";
 import { execSync } from "child_process";
 function registerIntrospect(parent) {
   parent.command("info").argument("<skill>", "Skill name").option("--json", "Output as JSON", false).option("--brief", "Single line: name \u2014 description [category] (tags: ...)", false).option("--remote", "Use remote registry from SKILLS_API_URL or config apiUrl", false).description("Show details about a specific skill").action((name, options) => {
@@ -49197,36 +49238,36 @@ function handleDiff(name, options) {
   const bare = name;
   const normalized = normalizePortableSkillName(bare);
   const sourcePath = getSkillPath(bare);
-  const canonicalDir = join15(resolveCorpusRoot(), normalized);
-  const canonicalSkillMd = join15(canonicalDir, "SKILL.md");
+  const canonicalDir = join16(resolveCorpusRoot(), normalized);
+  const canonicalSkillMd = join16(canonicalDir, "SKILL.md");
   const canonical = {
-    present: existsSync15(canonicalSkillMd),
+    present: existsSync16(canonicalSkillMd),
     path: canonicalDir,
-    ...existsSync15(canonicalSkillMd) ? { hash: hashSkillMarkdownFile(canonicalSkillMd) } : {},
-    ...existsSync15(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync12(canonicalSkillMd, "utf-8")) } : {}
+    ...existsSync16(canonicalSkillMd) ? { hash: hashSkillMarkdownFile(canonicalSkillMd) } : {},
+    ...existsSync16(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync13(canonicalSkillMd, "utf-8")) } : {}
   };
   const pinned = getInstalledSkills().includes(bare);
   const installMeta = getInstallMeta();
   const installedVersion = installMeta.skills[bare]?.version ?? "unknown";
-  const registryPkgPath = join15(sourcePath, "package.json");
+  const registryPkgPath = join16(sourcePath, "package.json");
   let registryVersion = "unknown";
-  if (existsSync15(registryPkgPath)) {
+  if (existsSync16(registryPkgPath)) {
     try {
-      registryVersion = JSON.parse(readFileSync12(registryPkgPath, "utf-8")).version || "unknown";
+      registryVersion = JSON.parse(readFileSync13(registryPkgPath, "utf-8")).version || "unknown";
     } catch {}
   }
   const upToDate = installedVersion === registryVersion;
   const homes = [];
   for (const agent of SYNC_AGENTS) {
-    const dir = join15(agentGlobalSkillsDir(agent), normalized);
-    const present = existsSync15(dir);
-    const managed = existsSync15(join15(dir, SYNC_MARKER_FILE));
-    const skillMdPath = join15(dir, "SKILL.md");
-    const hash = present && existsSync15(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : undefined;
+    const dir = join16(agentGlobalSkillsDir(agent), normalized);
+    const present = existsSync16(dir);
+    const managed = existsSync16(join16(dir, SYNC_MARKER_FILE));
+    const skillMdPath = join16(dir, "SKILL.md");
+    const hash = present && existsSync16(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : undefined;
     let stub;
-    if (present && existsSync15(skillMdPath)) {
+    if (present && existsSync16(skillMdPath)) {
       try {
-        stub = isPointerSkillMd(readFileSync12(skillMdPath, "utf-8"));
+        stub = isPointerSkillMd(readFileSync13(skillMdPath, "utf-8"));
       } catch {
         stub = undefined;
       }
@@ -49759,8 +49800,8 @@ var exports_init = {};
 __export(exports_init, {
   registerSetup: () => registerSetup
 });
-import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync8, appendFileSync } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync14, writeFileSync as writeFileSync8, appendFileSync } from "fs";
+import { join as join17 } from "path";
 function registerSetup(parent) {
   parent.command("init").option("--json", "Output as JSON", false).option("--for <agent>", "Detect project type and show MCP registration guidance for agent").option("--scope <scope>", "Deprecated; agent skill-folder installs are disabled", "global").description("Initialize project for pinned skills (.env.example, .gitignore)").action((options) => handleInit(options));
   parent.command("export").option("--json", "Output as JSON (default behavior)", false).description("Export pinned skills to JSON for sharing or backup").action((_options) => handleExport());
@@ -49844,7 +49885,7 @@ Use: skills render`));
       lines.push(`# Used by: ${skills.join(", ")}`);
       lines.push(`${envVar}=`);
     }
-    writeFileSync8(join16(cwd2, ".env.example"), lines.join(`
+    writeFileSync8(join17(cwd2, ".env.example"), lines.join(`
 `) + `
 `);
     envVarCount = envMap.size;
@@ -49852,9 +49893,9 @@ Use: skills render`));
       console.log(source_default.green(`\u2713 Generated .env.example (${envVarCount} variables from ${installed.length} skills)`));
   } else if (!options.json)
     console.log(source_default.dim("  No environment variables detected across pinned skills"));
-  const gitignorePath = join16(cwd2, ".gitignore");
+  const gitignorePath = join17(cwd2, ".gitignore");
   const gitignoreEntries = [".skills/runs/", ".skills/exports/", ".skills/tmp/"];
-  let gitignoreContent = existsSync16(gitignorePath) ? readFileSync13(gitignorePath, "utf-8") : "";
+  let gitignoreContent = existsSync17(gitignorePath) ? readFileSync14(gitignorePath, "utf-8") : "";
   let gitignoreUpdated = false;
   const missingEntries = gitignoreEntries.filter((entry) => !gitignoreContent.includes(entry));
   if (missingEntries.length > 0) {
@@ -49900,7 +49941,7 @@ async function handleImport(file, options) {
     if (file === "-")
       raw = await new Response(process.stdin).text();
     else {
-      if (!existsSync16(file)) {
+      if (!existsSync17(file)) {
         const error = `File not found: ${file}`;
         if (options.json)
           console.log(JSON.stringify({ imported: 0, error }));
@@ -49909,7 +49950,7 @@ async function handleImport(file, options) {
         process.exitCode = 1;
         return;
       }
-      raw = readFileSync13(file, "utf-8");
+      raw = readFileSync14(file, "utf-8");
     }
   } catch (err) {
     const error = `Failed to read file: ${err.message}`;
@@ -50006,24 +50047,24 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readdirSync as readdirSync8, readFileSync as readFileSync14, rmSync as rmSync5, statSync as statSync8, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync15, rmSync as rmSync5, statSync as statSync9, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
   const byName = new Map;
-  if (!existsSync17(corpusRoot))
+  if (!existsSync18(corpusRoot))
     return byName;
   let entries = [];
   try {
-    entries = readdirSync8(corpusRoot);
+    entries = readdirSync9(corpusRoot);
   } catch {
     return byName;
   }
   for (const entry of entries.sort()) {
     if (entry.startsWith("."))
       continue;
-    const skillMd = join17(corpusRoot, entry, "SKILL.md");
-    if (!existsSync17(skillMd))
+    const skillMd = join18(corpusRoot, entry, "SKILL.md");
+    if (!existsSync18(skillMd))
       continue;
     try {
       byName.set(entry, hashSkillMarkdownFile(skillMd));
@@ -50039,33 +50080,33 @@ function scanUnmarkedHomes(options = {}) {
   const scan = { adoptable: [], conflicts: [], unknown: [], managed: 0 };
   for (const agent of agents) {
     const home = agentGlobalSkillsDir(agent, homeDir);
-    if (!existsSync17(home))
+    if (!existsSync18(home))
       continue;
     let entries = [];
     try {
-      entries = readdirSync8(home);
+      entries = readdirSync9(home);
     } catch {
       continue;
     }
     for (const skill of entries.sort()) {
       if (skill.startsWith("."))
         continue;
-      const dir = join17(home, skill);
+      const dir = join18(home, skill);
       try {
-        if (!statSync8(dir).isDirectory())
+        if (!statSync9(dir).isDirectory())
           continue;
       } catch {
         continue;
       }
-      if (existsSync17(join17(dir, SYNC_MARKER_FILE))) {
+      if (existsSync18(join18(dir, SYNC_MARKER_FILE))) {
         scan.managed += 1;
         continue;
       }
-      const skillMdPath = join17(dir, "SKILL.md");
-      if (!existsSync17(skillMdPath))
+      const skillMdPath = join18(dir, "SKILL.md");
+      if (!existsSync18(skillMdPath))
         continue;
       const hash = hashSkillMarkdownFile(skillMdPath);
-      const mtime = statSync8(skillMdPath).mtime.toISOString();
+      const mtime = statSync9(skillMdPath).mtime.toISOString();
       const entry = { agent, skill, home, path: dir, hash, mtime };
       const canonicalHash = index.get(skill);
       if (canonicalHash === undefined) {
@@ -50082,11 +50123,11 @@ function scanUnmarkedHomes(options = {}) {
 function appendConflictsLedger(appDir, conflicts) {
   if (conflicts.length === 0)
     return;
-  const ledgerPath = join17(appDir, CONFLICTS_LEDGER_FILE);
+  const ledgerPath = join18(appDir, CONFLICTS_LEDGER_FILE);
   let ledger = { version: 1, entries: [] };
-  if (existsSync17(ledgerPath)) {
+  if (existsSync18(ledgerPath)) {
     try {
-      const parsed = JSON.parse(readFileSync14(ledgerPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync15(ledgerPath, "utf-8"));
       if (parsed && typeof parsed === "object" && Array.isArray(parsed.entries)) {
         ledger = parsed;
       }
@@ -50102,9 +50143,9 @@ function appendConflictsLedger(appDir, conflicts) {
 `);
 }
 function writeRollbackRecord(mode, entries, appDir = getDataDir()) {
-  const dir = join17(appDir, ROLLBACK_DIRNAME);
+  const dir = join18(appDir, ROLLBACK_DIRNAME);
   mkdirSync8(dir, { recursive: true });
-  const file = join17(dir, `${mode}-${Date.now()}.json`);
+  const file = join18(dir, `${mode}-${Date.now()}.json`);
   const record = { version: 1, mode, timestamp: new Date().toISOString(), entries };
   writeFileSync9(file, `${JSON.stringify(record, null, 2)}
 `);
@@ -50115,7 +50156,7 @@ function adoptUnmarkedHomes(options = {}) {
   if (!options.apply) {
     return { ...scan, applied: false };
   }
-  const appDir = options.homeDir ? join17(options.homeDir, ".hasna", "skills") : getDataDir();
+  const appDir = options.homeDir ? join18(options.homeDir, ".hasna", "skills") : getDataDir();
   const markers = scan.adoptable.map((entry) => {
     const marker = {
       managedBy: SYNC_MARKER_MANAGED_BY,
@@ -50123,7 +50164,7 @@ function adoptUnmarkedHomes(options = {}) {
       source: "adopted",
       syncedAt: new Date().toISOString()
     };
-    writeFileSync9(join17(entry.path, SYNC_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+    writeFileSync9(join18(entry.path, SYNC_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
     return { agent: entry.agent, skill: entry.skill, path: entry.path, hash: entry.hash, marker };
   });
@@ -50142,47 +50183,47 @@ function pruneStrayHomes(options = {}) {
   const candidates = [];
   for (const agent of agents) {
     const home = agentGlobalSkillsDir(agent, homeDir);
-    if (!existsSync17(home))
+    if (!existsSync18(home))
       continue;
     let entries = [];
     try {
-      entries = readdirSync8(home);
+      entries = readdirSync9(home);
     } catch {
       continue;
     }
     for (const skill of entries.sort()) {
       if (skill.startsWith("."))
         continue;
-      const dir = join17(home, skill);
+      const dir = join18(home, skill);
       try {
-        if (!statSync8(dir).isDirectory())
+        if (!statSync9(dir).isDirectory())
           continue;
       } catch {
         continue;
       }
-      const markerPath = join17(dir, SYNC_MARKER_FILE);
-      if (!existsSync17(markerPath))
+      const markerPath = join18(dir, SYNC_MARKER_FILE);
+      if (!existsSync18(markerPath))
         continue;
       if (index.has(skill))
         continue;
       let marker;
       try {
-        const parsed = JSON.parse(readFileSync14(markerPath, "utf-8"));
+        const parsed = JSON.parse(readFileSync15(markerPath, "utf-8"));
         if (!parsed || typeof parsed !== "object" || typeof parsed.managedBy !== "string")
           continue;
         marker = parsed;
       } catch {
         continue;
       }
-      const skillMdPath = join17(dir, "SKILL.md");
-      const hash = existsSync17(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : "";
+      const skillMdPath = join18(dir, "SKILL.md");
+      const hash = existsSync18(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : "";
       candidates.push({ agent, skill, home, path: dir, hash, marker });
     }
   }
   if (!options.apply) {
     return { candidates, pruned: 0, dryRun: true };
   }
-  const appDir = options.homeDir ? join17(options.homeDir, ".hasna", "skills") : getDataDir();
+  const appDir = options.homeDir ? join18(options.homeDir, ".hasna", "skills") : getDataDir();
   const rollbackFile = writeRollbackRecord("prune", candidates.map(({ agent, skill, path, hash, marker }) => ({ agent, skill, path, hash, marker })), appDir);
   for (const candidate of candidates) {
     rmSync5(candidate.path, { recursive: true, force: true });
@@ -50198,9 +50239,9 @@ var init_home_adoption = __esm(() => {
 });
 
 // src/lib/home-census.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync9, statSync as statSync9 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync16, readdirSync as readdirSync10, statSync as statSync10 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function sortEntries(entries) {
   return entries.sort((a, b) => {
     const left = `${a.agent}/${a.skill}/${a.kind}`;
@@ -50219,29 +50260,29 @@ function censusHomeDrift(options = {}) {
   let homesChecked = 0;
   for (const agent of agents) {
     const home = agentGlobalSkillsDir(agent, homeDir);
-    if (!existsSync18(home))
+    if (!existsSync19(home))
       continue;
     homesChecked += 1;
     const present = new Set;
     let dirEntries = [];
     try {
-      dirEntries = readdirSync9(home);
+      dirEntries = readdirSync10(home);
     } catch {
       continue;
     }
     for (const skill of dirEntries.sort()) {
       if (skill.startsWith("."))
         continue;
-      const dir = join18(home, skill);
+      const dir = join19(home, skill);
       try {
-        if (!statSync9(dir).isDirectory())
+        if (!statSync10(dir).isDirectory())
           continue;
       } catch {
         continue;
       }
       present.add(skill);
-      const markerPath = join18(dir, SYNC_MARKER_FILE);
-      if (!existsSync18(markerPath)) {
+      const markerPath = join19(dir, SYNC_MARKER_FILE);
+      if (!existsSync19(markerPath)) {
         unmarked += 1;
         continue;
       }
@@ -50251,8 +50292,8 @@ function censusHomeDrift(options = {}) {
         entries.push({ agent, skill, kind: "stray-in-home", path: dir });
         continue;
       }
-      const skillMdPath = join18(dir, "SKILL.md");
-      if (!existsSync18(skillMdPath)) {
+      const skillMdPath = join19(dir, "SKILL.md");
+      if (!existsSync19(skillMdPath)) {
         entries.push({ agent, skill, kind: "diverged", path: dir, canonicalHash });
         continue;
       }
@@ -50260,14 +50301,14 @@ function censusHomeDrift(options = {}) {
       if (homeHash !== canonicalHash) {
         let homeStub;
         try {
-          homeStub = isPointerSkillMd(readFileSync15(skillMdPath, "utf-8"));
+          homeStub = isPointerSkillMd(readFileSync16(skillMdPath, "utf-8"));
         } catch {
           homeStub = undefined;
         }
         let canonicalStub;
-        const canonicalSkillMd = join18(corpusRoot, skill, "SKILL.md");
+        const canonicalSkillMd = join19(corpusRoot, skill, "SKILL.md");
         try {
-          canonicalStub = isPointerSkillMd(readFileSync15(canonicalSkillMd, "utf-8"));
+          canonicalStub = isPointerSkillMd(readFileSync16(canonicalSkillMd, "utf-8"));
         } catch {
           canonicalStub = undefined;
         }
@@ -50280,7 +50321,7 @@ function censusHomeDrift(options = {}) {
           agent,
           skill: name,
           kind: "missing-from-home",
-          path: join18(home, name),
+          path: join19(home, name),
           canonicalHash
         });
       }
@@ -50306,8 +50347,8 @@ var exports_diagnostic = {};
 __export(exports_diagnostic, {
   registerDiagnostic: () => registerDiagnostic
 });
-import { existsSync as existsSync19, readFileSync as readFileSync16, readdirSync as readdirSync10, statSync as statSync10, writeFileSync as writeFileSync10 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync17, readdirSync as readdirSync11, statSync as statSync11, writeFileSync as writeFileSync10 } from "fs";
+import { join as join20 } from "path";
 import { execSync as execSync2 } from "child_process";
 function registerDiagnostic(parent) {
   parent.command("doctor").option("--json", "Output as JSON", false).description("Check env vars, system deps, and readiness for pinned skills").action((options) => handleDoctor(options));
@@ -50423,7 +50464,7 @@ Skills Test (${results.length} skill${results.length === 1 ? "" : "s"}):
 }
 function handleAuth(name, options) {
   const cwd2 = process.cwd();
-  const envFilePath = join19(cwd2, ".env");
+  const envFilePath = join20(cwd2, ".env");
   if (options.set) {
     const eqIdx = options.set.indexOf("=");
     if (eqIdx === -1) {
@@ -50445,7 +50486,7 @@ function handleAuth(name, options) {
       process.exitCode = 1;
       return;
     }
-    let existing = existsSync19(envFilePath) ? readFileSync16(envFilePath, "utf-8") : "";
+    let existing = existsSync20(envFilePath) ? readFileSync17(envFilePath, "utf-8") : "";
     const keyPattern = new RegExp(`^${key}=.*$`, "m");
     const updated = keyPattern.test(existing) ? existing.replace(keyPattern, `${key}=${value}`) : existing.endsWith(`
 `) || existing === "" ? existing + `${key}=${value}
@@ -50511,11 +50552,11 @@ function handleWhoami(options) {
   const agentConfigs = [];
   for (const agent of AGENT_TARGETS) {
     const agentSkillsPath = getAgentSkillsDir(agent, "global");
-    const exists = existsSync19(agentSkillsPath);
+    const exists = existsSync20(agentSkillsPath);
     let skillCount = 0;
     if (exists)
       try {
-        skillCount = readdirSync10(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync10(join19(agentSkillsPath, f)).isDirectory()).length;
+        skillCount = readdirSync11(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync11(join20(agentSkillsPath, f)).isDirectory()).length;
       } catch {}
     agentConfigs.push({ agent, label: AGENT_LABELS[agent], path: agentSkillsPath, exists, skillCount });
   }
@@ -50549,11 +50590,11 @@ function handleOutdated(options) {
   for (const name of installed) {
     const installedVersion = meta.skills[name]?.version ?? "unknown";
     const registryPath = getSkillPath(name);
-    const registryPkgPath = join19(registryPath, "package.json");
+    const registryPkgPath = join20(registryPath, "package.json");
     let registryVersion = "unknown";
-    if (existsSync19(registryPkgPath))
+    if (existsSync20(registryPkgPath))
       try {
-        registryVersion = JSON.parse(readFileSync16(registryPkgPath, "utf-8")).version || "unknown";
+        registryVersion = JSON.parse(readFileSync17(registryPkgPath, "utf-8")).version || "unknown";
       } catch {}
     if (installedVersion !== registryVersion)
       pins.push({ skill: name, installedVersion, registryVersion });
@@ -50817,20 +50858,20 @@ var init_runs = __esm(() => {
 
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, readFileSync as readFileSync17, readdirSync as readdirSync11, statSync as statSync11, writeFileSync as writeFileSync11 } from "fs";
-import { extname, join as join20, relative as relative2 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync18, readdirSync as readdirSync12, statSync as statSync12, writeFileSync as writeFileSync11 } from "fs";
+import { extname, join as join21, relative as relative2 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now3 = new Date;
   const id = createRunId(now3);
   const day = now3.toISOString().slice(0, 10);
   const skillName = normalizeSkillName(params.skill);
   const root = getProjectStateDir(targetDir);
-  const runDir = join20(root, "runs", day, id);
-  const logsDir = join20(runDir, "logs");
-  const exportDir = join20(root, "exports", skillName, id);
+  const runDir = join21(root, "runs", day, id);
+  const logsDir = join21(runDir, "logs");
+  const exportDir = join21(root, "exports", skillName, id);
   mkdirSync9(logsDir, { recursive: true });
   mkdirSync9(exportDir, { recursive: true });
-  mkdirSync9(join20(root, "tmp"), { recursive: true });
+  mkdirSync9(join21(root, "tmp"), { recursive: true });
   const record = {
     id,
     skill: skillName,
@@ -50881,27 +50922,27 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync11(join20(context.logsDir, "stdout.log"), stdout);
-  writeFileSync11(join20(context.logsDir, "stderr.log"), stderr);
+  writeFileSync11(join21(context.logsDir, "stdout.log"), stdout);
+  writeFileSync11(join21(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join20(context.runDir, "events.ndjson");
-  const previous = existsSync20(path) ? readFileSync17(path, "utf-8") : "";
+  const path = join21(context.runDir, "events.ndjson");
+  const previous = existsSync21(path) ? readFileSync18(path, "utf-8") : "";
   writeFileSync11(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
-  const runsRoot = join20(getProjectStateDir(targetDir), "runs");
-  if (!existsSync20(runsRoot))
+  const runsRoot = join21(getProjectStateDir(targetDir), "runs");
+  if (!existsSync21(runsRoot))
     return [];
   const records = [];
-  for (const day of readdirSync11(runsRoot).sort().reverse()) {
-    const dayDir = join20(runsRoot, day);
-    if (!statSync11(dayDir).isDirectory())
+  for (const day of readdirSync12(runsRoot).sort().reverse()) {
+    const dayDir = join21(runsRoot, day);
+    if (!statSync12(dayDir).isDirectory())
       continue;
-    for (const runId of readdirSync11(dayDir).sort().reverse()) {
-      const record = readRunRecord(join20(dayDir, runId));
+    for (const runId of readdirSync12(dayDir).sort().reverse()) {
+      const record = readRunRecord(join21(dayDir, runId));
       if (record)
         records.push(record);
       if (records.length >= limit)
@@ -50911,11 +50952,11 @@ function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   return records;
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join20(getProjectStateDir(targetDir), "runs");
-  if (!existsSync20(runsRoot))
+  const runsRoot = join21(getProjectStateDir(targetDir), "runs");
+  if (!existsSync21(runsRoot))
     return null;
-  for (const day of readdirSync11(runsRoot)) {
-    const record = readRunRecord(join20(runsRoot, day, runId));
+  for (const day of readdirSync12(runsRoot)) {
+    const record = readRunRecord(join21(runsRoot, day, runId));
     if (record)
       return record;
   }
@@ -50932,23 +50973,23 @@ function skillRunEnv(context) {
   };
 }
 function getRunExportDir(runId, skill, targetDir = process.cwd()) {
-  return join20(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
+  return join21(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
 }
 function writeRunRecord(context) {
-  writeFileSync11(join20(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync11(join21(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync11(join20(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync11(join21(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
-  if (!existsSync20(context.exportDir))
+  if (!existsSync21(context.exportDir))
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
-    const stat = statSync11(path);
-    const bytes = readFileSync17(path);
+    const stat = statSync12(path);
+    const bytes = readFileSync18(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
@@ -50959,20 +51000,20 @@ function collectRunArtifacts(context) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join20(runDir, "run.json");
-  if (!existsSync20(path))
+  const path = join21(runDir, "run.json");
+  if (!existsSync21(path))
     return null;
   try {
-    return JSON.parse(readFileSync17(path, "utf-8"));
+    return JSON.parse(readFileSync18(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync11(dir)) {
-    const full = join20(dir, entry);
-    if (statSync11(full).isDirectory())
+  for (const entry of readdirSync12(dir)) {
+    const full = join21(dir, entry);
+    if (statSync12(full).isDirectory())
       files.push(...walkFiles(full));
     else
       files.push(full);
@@ -68186,6 +68227,43 @@ var init_discovery_tools = __esm(() => {
   init_helpers();
 });
 
+// src/lib/run-routing.ts
+var exports_run_routing = {};
+__export(exports_run_routing, {
+  resolveRunRouting: () => resolveRunRouting,
+  resolveConfiguredRunRouting: () => resolveConfiguredRunRouting,
+  isServerOwnedSkill: () => isServerOwnedSkill
+});
+function isServerOwnedSkill(skill) {
+  return skill.serverOwned === true;
+}
+function resolveRunRouting(skill, apiKey, apiUrl) {
+  if (!isServerOwnedSkill(skill))
+    return { route: "local" };
+  if (!apiUrl) {
+    return {
+      route: "error",
+      code: "REMOTE_REQUIRES_ORIGIN",
+      error: `${skill.name} is a server-owned skill. Point the CLI at a Skills API: ` + `skills setup --api-url <url> (or export SKILLS_API_URL)`
+    };
+  }
+  if (!apiKey) {
+    return {
+      route: "error",
+      code: "REMOTE_REQUIRES_CREDENTIAL",
+      error: `${skill.name} is a server-owned skill. Run: skills auth login`
+    };
+  }
+  return { route: "remote", apiKey };
+}
+function resolveConfiguredRunRouting(skill) {
+  return resolveRunRouting(skill, getApiKey(), resolveApiUrl());
+}
+var init_run_routing = __esm(() => {
+  init_api_url();
+  init_auth_store();
+});
+
 // src/lib/remote-client.ts
 var exports_remote_client = {};
 __export(exports_remote_client, {
@@ -68486,8 +68564,8 @@ var init_remote_client = __esm(() => {
 });
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync21, readdirSync as readdirSync12, statSync as statSync12 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync13, statSync as statSync13 } from "fs";
+import { join as join22 } from "path";
 function registerOperationTools(server) {
   server.registerTool("scaffold_skill", {
     title: "Scaffold Skill",
@@ -68695,7 +68773,6 @@ function registerOperationTools(server) {
     if (!skill) {
       return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
     }
-    const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_auth_store(), exports_auth_store));
     const {
       ARTICLE_GENERATION_SLUG: ARTICLE_GENERATION_SLUG2,
       validateBlogArticleRunOptions: validateBlogArticleRunOptions2
@@ -68709,24 +68786,24 @@ function registerOperationTools(server) {
         return mcpError("INVALID_BLOG_ARTICLE_OPTIONS", validation.errors.join(" "));
       }
     }
-    const apiKey = getApiKey2();
-    const hostedRuntime = false;
+    const routing = resolveConfiguredRunRouting(skill);
     const runContext = createSkillRun({
       skill: skillName,
       args: runArgs,
-      remote: hostedRuntime
+      remote: routing.route === "remote"
     });
-    if (hostedRuntime && !apiKey) {
-      const error2 = `${skillName} is a hosted skill. Run: skills auth login`;
+    if (routing.route === "error") {
+      const error2 = routing.error;
       writeRunLogs(runContext, "", error2 + `
 `);
       const run = completeSkillRun(runContext, { status: "failed", error: error2 });
-      return mcpError("AUTH_REQUIRED", `${error2}. Local run metadata: ${run.paths.runDir}/run.json`, ["skills auth login"]);
+      const suggestions = routing.code === "REMOTE_REQUIRES_ORIGIN" ? ["skills setup --api-url <url>", "skills auth login"] : ["skills auth login"];
+      return mcpError(routing.code, `${error2}. Local run metadata: ${run.paths.runDir}/run.json`, suggestions);
     }
-    if (hostedRuntime && apiKey) {
+    if (routing.route === "remote") {
       try {
         const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
-        const client = new RemoteSkillsClient2(apiKey);
+        const client = new RemoteSkillsClient2(routing.apiKey);
         const run = await client.submitRun(skillName, runInput, runArgs);
         if (run.error) {
           writeRunLogs(runContext, "", String(run.error) + `
@@ -68885,13 +68962,13 @@ function registerOperationTools(server) {
     const agents = [];
     for (const agent of AGENT_TARGETS) {
       const agentSkillsPath = getAgentSkillsDir(agent, "global");
-      const exists = existsSync21(agentSkillsPath);
+      const exists = existsSync22(agentSkillsPath);
       let skillCount = 0;
       if (exists) {
         try {
-          skillCount = readdirSync12(agentSkillsPath).filter((f) => {
-            const full = join21(agentSkillsPath, f);
-            return !f.startsWith(".") && statSync12(full).isDirectory();
+          skillCount = readdirSync13(agentSkillsPath).filter((f) => {
+            const full = join22(agentSkillsPath, f);
+            return !f.startsWith(".") && statSync13(full).isDirectory();
           }).length;
         } catch {}
       }
@@ -68943,19 +69020,20 @@ var init_operation_tools = __esm(() => {
   init_run_state();
   init_portable_skills();
   init_helpers();
+  init_run_routing();
 });
 
 // src/lib/feedback.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname7, join as join22 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname7, join as join23 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join22(getDataDir(), "skills.db");
+  return join23(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
   const dir = dirname7(dbPath);
-  if (!existsSync22(dir))
+  if (!existsSync23(dir))
     mkdirSync10(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
@@ -69129,24 +69207,24 @@ var init_resource_meta_tools = __esm(() => {
 });
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync23, readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync19, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
+import { join as join24 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join23(targetDir, ".skills", "schedules.json");
+  return join24(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  if (existsSync23(path)) {
+  if (existsSync24(path)) {
     try {
-      return JSON.parse(readFileSync18(path, "utf-8"));
+      return JSON.parse(readFileSync19(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join23(targetDir, ".skills");
-  if (!existsSync23(dir))
+  const dir = join24(targetDir, ".skills");
+  if (!existsSync24(dir))
     mkdirSync11(dir, { recursive: true });
   writeFileSync12(path, JSON.stringify(data, null, 2));
 }
@@ -69446,14 +69524,14 @@ var init_schedule_tools = __esm(() => {
 // src/lib/native-storage.ts
 import { createHash as createHash3, createHmac as createHmac2 } from "crypto";
 import {
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync19,
-  readdirSync as readdirSync13,
-  statSync as statSync13,
+  readFileSync as readFileSync20,
+  readdirSync as readdirSync14,
+  statSync as statSync14,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname8, join as join24, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
+import { dirname as dirname8, join as join25, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
 function resolveSkillsNativeStorageConfig(env3 = process.env) {
   assertNoRetiredModeEnvVars(env3, {
     app: SKILLS_ENV_NAMESPACE,
@@ -69494,7 +69572,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join24(getDataDir(), "skills.db")
+      feedbackDbPath: join25(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config2.databaseUrl),
@@ -69514,9 +69592,9 @@ function getStorageStatus(options = {}) {
 function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const projectStateDir = getProjectStateDir(targetDir);
   const files = [];
-  if (existsSync24(projectStateDir)) {
+  if (existsSync25(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync19(filePath);
+      const bytes = readFileSync20(filePath);
       const relativePath = toPosix(relative3(targetDir, filePath));
       files.push({
         path: relativePath,
@@ -69574,9 +69652,9 @@ function parsePositiveInteger(value) {
 }
 function walkFiles2(dir) {
   const files = [];
-  for (const entry of readdirSync13(dir)) {
-    const full = join24(dir, entry);
-    const stats = statSync13(full);
+  for (const entry of readdirSync14(dir)) {
+    const full = join25(dir, entry);
+    const stats = statSync14(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
     else
@@ -70119,9 +70197,9 @@ var init_mcp2 = __esm(() => {
 });
 
 // src/cli/commands/runtime-mcp.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname9, join as join25 } from "path";
+import { dirname as dirname9, join as join26 } from "path";
 async function handleMcp(options) {
   if (options.register) {
     let agents;
@@ -70163,24 +70241,24 @@ async function registerMcpForAgent(agent, command) {
     case "codex":
       return registerCodexMcp(command);
     case "gemini":
-      return registerJsonMcpServer(agent, join25(homedir8(), ".gemini", "settings.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join26(homedir8(), ".gemini", "settings.json"), "mcpServers", {
         command,
         args: []
       });
     case "pi":
-      return registerJsonMcpServer(agent, join25(homedir8(), ".pi", "agent", "mcp.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join26(homedir8(), ".pi", "agent", "mcp.json"), "mcpServers", {
         command,
         args: []
       });
     case "opencode":
       return registerOpenCodeMcp(command);
     case "cursor":
-      return registerJsonMcpServer(agent, join25(homedir8(), ".cursor", "mcp.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join26(homedir8(), ".cursor", "mcp.json"), "mcpServers", {
         command,
         args: []
       });
     case "windsurf":
-      return registerJsonMcpServer(agent, join25(homedir8(), ".windsurf", "mcp.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join26(homedir8(), ".windsurf", "mcp.json"), "mcpServers", {
         command,
         args: []
       });
@@ -70203,7 +70281,7 @@ async function registerClaudeMcp(command) {
     if (exitCode === 0) {
       return { agent: "claude", success: true, command: cliCommand };
     }
-    const fallback = registerJsonMcpServer("claude", join25(homedir8(), ".claude", ".mcp.json"), "mcpServers", {
+    const fallback = registerJsonMcpServer("claude", join26(homedir8(), ".claude", ".mcp.json"), "mcpServers", {
       command,
       args: []
     });
@@ -70213,7 +70291,7 @@ async function registerClaudeMcp(command) {
       error: fallback.success ? undefined : `claude exited with ${exitCode}: ${(stderr || stdout).trim()}`
     };
   } catch (err) {
-    const fallback = registerJsonMcpServer("claude", join25(homedir8(), ".claude", ".mcp.json"), "mcpServers", {
+    const fallback = registerJsonMcpServer("claude", join26(homedir8(), ".claude", ".mcp.json"), "mcpServers", {
       command,
       args: []
     });
@@ -70225,11 +70303,11 @@ async function registerClaudeMcp(command) {
   }
 }
 function registerCodexMcp(command) {
-  const path = join25(homedir8(), ".codex", "config.toml");
+  const path = join26(homedir8(), ".codex", "config.toml");
   const config2 = `[mcp_servers.${MCP_SERVER_NAME}]
 command = ${JSON.stringify(command)}`;
   try {
-    const current = existsSync25(path) ? readFileSync20(path, "utf-8") : "";
+    const current = existsSync26(path) ? readFileSync21(path, "utf-8") : "";
     writeTextFile(path, upsertTomlSection(current, `[mcp_servers.${MCP_SERVER_NAME}]`, `command = ${JSON.stringify(command)}`));
     return { agent: "codex", success: true, path, config: config2 };
   } catch (err) {
@@ -70237,7 +70315,7 @@ command = ${JSON.stringify(command)}`;
   }
 }
 function registerOpenCodeMcp(command) {
-  const path = join25(homedir8(), ".config", "opencode", "opencode.json");
+  const path = join26(homedir8(), ".config", "opencode", "opencode.json");
   const config2 = JSON.stringify({
     $schema: "https://opencode.ai/config.json",
     mcp: {
@@ -70279,9 +70357,9 @@ function registerJsonMcpServer(agent, path, containerKey, server2) {
   }
 }
 function readJsonObject2(path) {
-  if (!existsSync25(path))
+  if (!existsSync26(path))
     return {};
-  const raw = readFileSync20(path, "utf-8").trim();
+  const raw = readFileSync21(path, "utf-8").trim();
   if (!raw)
     return {};
   const parsed = JSON.parse(raw);
@@ -70325,8 +70403,8 @@ function findCommandOnPath(command) {
   for (const dir of pathValue.split(":")) {
     if (!dir)
       continue;
-    const candidate = join25(dir, command);
-    if (existsSync25(candidate))
+    const candidate = join26(dir, command);
+    if (existsSync26(candidate))
       return candidate;
   }
   return command;
@@ -70346,7 +70424,7 @@ __export(exports_runtime, {
   registerRuntime: () => registerRuntime
 });
 import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname10, join as join26 } from "path";
+import { dirname as dirname10, join as join27 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
   parent.command("run").argument("<skill>", "Skill name").argument("[args...]", "Arguments to pass to the skill").allowUnknownOption(true).passThroughOptions(true).option("--json", "Output result as JSON", false).option("--wait", "Poll remote runs until a terminal status", false).option("--poll-interval-ms <ms>", "Remote polling interval in milliseconds", "1000").option("--poll-timeout-ms <ms>", "Maximum time to wait for a remote run", "300000").description("Run a skill directly").action(async (name, args2, options) => handleRun(name, args2, options));
@@ -70493,31 +70571,29 @@ async function handleRun(name, args2, options) {
       return;
     }
   }
-  const isHostedRuntime = false;
+  const routing = resolveConfiguredRunRouting(skill);
   const runContext = createSkillRun({
     skill: skill.name,
     args: args2,
     prompt,
-    remote: isHostedRuntime
+    remote: routing.route === "remote"
   });
-  if (isHostedRuntime) {
-    const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_auth_store(), exports_auth_store));
-    const apiKey = getApiKey2();
-    if (!apiKey) {
-      const error2 = `${skill.name} is a hosted skill. Run: skills auth login`;
-      writeRunLogs(runContext, "", error2 + `
+  if (routing.route === "error") {
+    const error2 = routing.error;
+    writeRunLogs(runContext, "", error2 + `
 `);
-      const run = completeSkillRun(runContext, { status: "failed", error: error2 });
-      if (options.json)
-        console.log(JSON.stringify({ contractVersion: REMOTE_SKILL_RUN_CONTRACT_VERSION, skill: skill.name, args: args2, exitCode: 1, remote: true, error: error2, run }, null, 2));
-      else
-        console.error(source_default.red(error2));
-      process.exitCode = 1;
-      return;
-    }
+    const run = completeSkillRun(runContext, { status: "failed", error: error2 });
+    if (options.json)
+      console.log(JSON.stringify({ contractVersion: REMOTE_SKILL_RUN_CONTRACT_VERSION, skill: skill.name, args: args2, exitCode: 1, remote: true, error: error2, run }, null, 2));
+    else
+      console.error(source_default.red(error2));
+    process.exitCode = 1;
+    return;
+  }
+  if (routing.route === "remote") {
     try {
       const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
-      const client = new RemoteSkillsClient2(apiKey);
+      const client = new RemoteSkillsClient2(routing.apiKey);
       const run = await client.submitRun(skill.name, {}, args2);
       if (run.error) {
         writeRunLogs(runContext, "", String(run.error) + `
@@ -70830,7 +70906,7 @@ async function handleExportsDownload(runId, options) {
       if (!response.ok)
         throw new Error(`download failed for artifact ${artifactId}: ${response.status}`);
       const relativePath = safeArtifactRelativePath(typeof artifact.relativePath === "string" ? artifact.relativePath : artifact.fileName, String(artifact.fileName || artifactId));
-      const outputPath = join26(exportDir, relativePath);
+      const outputPath = join27(exportDir, relativePath);
       mkdirSync14(dirname10(outputPath), { recursive: true });
       const bytes = new Uint8Array(await response.arrayBuffer());
       writeFileSync15(outputPath, bytes);
@@ -71049,6 +71125,7 @@ var init_runtime = __esm(() => {
   init_runs();
   init_run_state();
   init_runtime_mcp();
+  init_run_routing();
 });
 
 // src/cli/commands/completion.ts
@@ -71195,8 +71272,8 @@ var exports_create_sync_config = {};
 __export(exports_create_sync_config, {
   registerCreateSync: () => registerCreateSync
 });
-import { existsSync as existsSync26, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync27, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15 } from "fs";
+import { join as join28 } from "path";
 function registerCreateSync(parent) {
   const configCmd = parent.command("config").description("Manage skills configuration");
   configCmd.command("show", { isDefault: true }).option("--json", "Output as JSON", false).description("Show current merged configuration").action((options) => {
@@ -71262,13 +71339,13 @@ function registerCreateSync(parent) {
     const pp = getConfigPath("project");
     if (options.json) {
       console.log(JSON.stringify({
-        global: { path: gp, exists: existsSync26(gp) },
-        project: { path: pp, exists: existsSync26(pp) }
+        global: { path: gp, exists: existsSync27(gp) },
+        project: { path: pp, exists: existsSync27(pp) }
       }, null, 2));
       return;
     }
-    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync26(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
-    console.log(`${source_default.cyan("project")}: ${pp}${existsSync26(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync27(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("project")}: ${pp}${existsSync27(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
   });
   parent.command("create").argument("<name>", "Skill name (e.g. my-tool)").option("--category <category>", "Skill category", "Development Tools").option("--description <description>", "Short description of what the skill does").option("--tags <tags>", "Comma-separated tags (e.g. api,testing,automation)").option("--global", "Deprecated; custom skills are always global", false).option("--json", "Output result as JSON", false).description("Scaffold a new custom skill directory").action((name, options) => handleCreate(name, options));
   parent.command("sync").alias("render").argument("[names...]", "Skills to sync (default: every skill in this machine's corpus)").option("--for <agent>", `Target one agent (${SYNC_AGENTS.join(", ")}, or all)`, "all").option("--all", "Sync every corpus skill (the default)", false).option("--source <path>", "Canonical corpus source: a directory of skill folders, or a package root with skills/ (overrides $SKILLS_SOURCE)").option("--dry-run", "Show what would be written without touching any agent folder", false).option("--force", "Adopt an unmanaged skill that already has SKILL.md; other unmarked directories are never overwritten", false).option("--check", "Home drift census (missing-from-home / stray-in-home / diverged); exits non-zero on drift, writes nothing", false).option("--adopt", "Unmarked-home adoption mode: hash unmarked home skills against the corpus; exact matches are marked (dry-run by default)", false).option("--prune", "Prune mode: list (or with --apply, remove) marked home skill dirs that have no canonical corpus entry", false).option("--apply", "Write adoption markers / conflicts ledger, or perform prune removals", false).option("--json", "Output as JSON", false).description("Write corpus skills into each coding agent's global skills folder, per-tool adapted").action((names, options) => handleSync(names, options));
@@ -71277,8 +71354,8 @@ function handleCreate(name, options) {
   const bare = name.trim();
   const dirName = bare;
   const baseDir = getPortableSkillsRoot();
-  const skillDir = join27(baseDir, dirName);
-  if (existsSync26(skillDir)) {
+  const skillDir = join28(baseDir, dirName);
+  if (existsSync27(skillDir)) {
     console.log(options.json ? JSON.stringify({ error: `Skill '${bare}' already exists at ${skillDir}` }) : source_default.red(`Skill '${bare}' already exists at ${skillDir}`));
     process.exitCode = 1;
     return;
@@ -71286,8 +71363,8 @@ function handleCreate(name, options) {
   const description = options.description || `${bare} skill`;
   const tags = options.tags ? options.tags.split(",").map((t) => t.trim()).filter(Boolean) : [bare];
   const displayName2 = bare.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-  mkdirSync15(join27(skillDir, "src"), { recursive: true });
-  writeFileSync16(join27(skillDir, "SKILL.md"), [
+  mkdirSync15(join28(skillDir, "src"), { recursive: true });
+  writeFileSync16(join28(skillDir, "SKILL.md"), [
     "---",
     `name: ${bare}`,
     `description: ${description}`,
@@ -71307,11 +71384,11 @@ function handleCreate(name, options) {
     ""
   ].join(`
 `));
-  writeFileSync16(join27(skillDir, "src", "index.ts"), [`#!/usr/bin/env bun`, `/**`, ` * ${displayName2} \u2014 ${description}`, ` */`, "", `console.log("${displayName2}");`, ""].join(`
+  writeFileSync16(join28(skillDir, "src", "index.ts"), [`#!/usr/bin/env bun`, `/**`, ` * ${displayName2} \u2014 ${description}`, ` */`, "", `console.log("${displayName2}");`, ""].join(`
 `));
-  writeFileSync16(join27(skillDir, "package.json"), JSON.stringify({ name: bare, version: "0.1.0", description, bin: { [bare]: "./src/index.ts" }, scripts: { dev: `bun src/index.ts` }, dependencies: {} }, null, 2) + `
+  writeFileSync16(join28(skillDir, "package.json"), JSON.stringify({ name: bare, version: "0.1.0", description, bin: { [bare]: "./src/index.ts" }, scripts: { dev: `bun src/index.ts` }, dependencies: {} }, null, 2) + `
 `);
-  writeFileSync16(join27(skillDir, "tsconfig.json"), JSON.stringify({ compilerOptions: { target: "ES2022", module: "ESNext", moduleResolution: "bundler", strict: true, outDir: "dist" }, include: ["src/**/*.ts"] }, null, 2) + `
+  writeFileSync16(join28(skillDir, "tsconfig.json"), JSON.stringify({ compilerOptions: { target: "ES2022", module: "ESNext", moduleResolution: "bundler", strict: true, outDir: "dist" }, include: ["src/**/*.ts"] }, null, 2) + `
 `);
   clearRegistryCache();
   if (options.json)
@@ -71320,8 +71397,8 @@ function handleCreate(name, options) {
     console.log(source_default.green(`\u2713 Created custom skill '${bare}' at ${skillDir}`));
     console.log(source_default.dim(`  Category: ${options.category}`));
     console.log(source_default.dim(`  Tags: ${tags.join(", ")}`));
-    console.log(`  ${source_default.cyan("Edit:")} ${join27(skillDir, "src", "index.ts")}`);
-    console.log(`  ${source_default.cyan("Run:")}  bun ${join27(skillDir, "src", "index.ts")}`);
+    console.log(`  ${source_default.cyan("Edit:")} ${join28(skillDir, "src", "index.ts")}`);
+    console.log(`  ${source_default.cyan("Run:")}  bun ${join28(skillDir, "src", "index.ts")}`);
   }
 }
 function handleSync(names, options) {
@@ -71783,6 +71860,14 @@ async function executeScheduledSkill(skillName, args2, options) {
   const skill = getSkill2(skillName);
   if (!skill)
     throw new Error(`Skill '${skillName}' not found`);
+  const { resolveConfiguredRunRouting: resolveConfiguredRunRouting2 } = await Promise.resolve().then(() => (init_run_routing(), exports_run_routing));
+  const routing = resolveConfiguredRunRouting2(skill);
+  if (routing.route === "error") {
+    throw new Error(`${routing.code}: ${routing.error}`);
+  }
+  if (routing.route === "remote") {
+    throw new Error(`${skill.name} is a server-owned skill. Scheduled hosted runs are not supported yet \u2014 ` + `run it with: skills run ${skill.name}`);
+  }
   const { runSkill: runSkill2 } = await Promise.resolve().then(() => (init_skillinfo(), exports_skillinfo));
   const result2 = await runSkill2(skill.name, args2);
   if (result2.exitCode !== 0) {
@@ -71920,8 +72005,8 @@ var init_revision = __esm(() => {
 
 // src/lib/skill-bundle.ts
 import { createHash as createHash5 } from "crypto";
-import { readFileSync as readFileSync21, readdirSync as readdirSync14, statSync as statSync14 } from "fs";
-import { join as join28, relative as relative5 } from "path";
+import { readFileSync as readFileSync22, readdirSync as readdirSync15, statSync as statSync15 } from "fs";
+import { join as join29, relative as relative5 } from "path";
 function isDotenvFile(lower) {
   if (lower === ".env" || lower.startsWith(".env."))
     return true;
@@ -71958,8 +72043,8 @@ function collectSkillBundleEntries(dir) {
   return entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
 }
 function walk(root, current, out) {
-  for (const entry of readdirSync14(current, { withFileTypes: true })) {
-    const absolute = join28(current, entry.name);
+  for (const entry of readdirSync15(current, { withFileTypes: true })) {
+    const absolute = join29(current, entry.name);
     const rel = relative5(root, absolute).split("\\").join("/");
     const isRootLevel = !rel.includes("/");
     if (ANY_SEGMENT_EXCLUDES.has(entry.name.toLowerCase()))
@@ -71980,10 +72065,10 @@ function walk(root, current, out) {
       continue;
     if (isCredentialFile(entry.name))
       continue;
-    const stats = statSync14(absolute);
+    const stats = statSync15(absolute);
     out.push({
       path: rel,
-      bytes: ownBytes(readFileSync21(absolute)),
+      bytes: ownBytes(readFileSync22(absolute)),
       mode: stats.mode & 64 ? 493 : 420
     });
   }
@@ -72269,8 +72354,8 @@ var init_skill_bundles = __esm(() => {
 });
 
 // src/lib/pull.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync2, readFileSync as readFileSync22, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname12, join as join29 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync3, readFileSync as readFileSync23, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname12, join as join30 } from "path";
 async function pullSkills(options = {}) {
   const client = options.client !== undefined ? options.client : createRemoteSkillsClient();
   if (!client) {
@@ -72315,7 +72400,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
       return reconcileTombstone(slug, corpusOptions);
     }
     if (bundleResponse.status === 404) {
-      const marker = readPullMarker(join29(getPortableSkillsRoot(corpusOptions), slug));
+      const marker = readPullMarker(join30(getPortableSkillsRoot(corpusOptions), slug));
       if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
         return { name: slug, success: true, purged: true, removed: false };
       }
@@ -72346,7 +72431,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(join29(getPortableSkillsRoot(corpusOptions), slug));
+    const marker = readPullMarker(join30(getPortableSkillsRoot(corpusOptions), slug));
     if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
       return { name: slug, success: true, purged: true, removed: false };
     }
@@ -72360,7 +72445,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
     }
     throw error2;
   }
-  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,
@@ -72403,8 +72488,8 @@ function provenRevision(meta, slug, bundle) {
   return declared;
 }
 function reconcileTombstone(slug, corpusOptions) {
-  const target = join29(getPortableSkillsRoot(corpusOptions), slug);
-  if (!existsSync27(join29(target, PULL_MARKER_FILE))) {
+  const target = join30(getPortableSkillsRoot(corpusOptions), slug);
+  if (!existsSync28(join30(target, PULL_MARKER_FILE))) {
     return { name: slug, success: true, tombstoned: true, removed: false, leftInPlace: true };
   }
   rmSync6(target, { recursive: true, force: true });
@@ -72412,7 +72497,7 @@ function reconcileTombstone(slug, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync22(join29(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync23(join30(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -72533,14 +72618,14 @@ function verifyBundleResponseBytes(buffer, response, verify = {}) {
 function installBundleAtomically(name, entries, options = {}, marker = {}) {
   const root = getPortableSkillsRoot(options);
   mkdirSync17(root, { recursive: true });
-  const target = join29(root, name);
-  const created = !existsSync27(target);
-  const staging = mkdtempSync2(join29(root, `.pull-${name}-`));
+  const target = join30(root, name);
+  const created = !existsSync28(target);
+  const staging = mkdtempSync3(join30(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
     for (const entry of entries) {
-      const destination = join29(staging, entry.path);
+      const destination = join30(staging, entry.path);
       mkdirSync17(dirname12(destination), { recursive: true });
       writeFileSync18(destination, entry.bytes, { mode: entry.mode });
     }
@@ -72552,9 +72637,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       ...marker.signature ? { signature: marker.signature } : {},
       ...marker.revisionId ? { revisionId: marker.revisionId } : {}
     });
-    if (existsSync27(target)) {
-      backup = mkdtempSync2(join29(root, `.pull-backup-${name}-`));
-      renameSync4(target, join29(backup, name));
+    if (existsSync28(target)) {
+      backup = mkdtempSync3(join30(root, `.pull-backup-${name}-`));
+      renameSync4(target, join30(backup, name));
       moved = true;
     }
     renameSync4(staging, target);
@@ -72562,9 +72647,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       rmSync6(backup, { recursive: true, force: true });
   } catch (error2) {
     rmSync6(staging, { recursive: true, force: true });
-    if (moved && backup && existsSync27(join29(backup, name))) {
+    if (moved && backup && existsSync28(join30(backup, name))) {
       try {
-        renameSync4(join29(backup, name), target);
+        renameSync4(join30(backup, name), target);
       } catch {}
     }
     throw error2;
@@ -72583,7 +72668,7 @@ function writePullMarker(dir, record3) {
     ...record3.revisionId ? { revisionId: record3.revisionId } : {},
     syncedAt: new Date().toISOString()
   };
-  writeFileSync18(join29(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+  writeFileSync18(join30(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function safeMeta(client, slug) {
@@ -72754,8 +72839,8 @@ __export(exports_publish, {
   pushSkill: () => pushSkill,
   PushSkillError: () => PushSkillError
 });
-import { existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
+import { join as join31 } from "path";
 function registerPublish(parent) {
   parent.command("push").argument("<name>", "Name of a skill in the local corpus (~/.hasna/skills/installed or the migrated ~/.hasna/skills/skills)").option("--version <version>", "Override the version recorded on the instance").option("--dry-run", "Pack and validate without uploading", false).option("--json", "Output result as JSON", false).description("Publish a local skill to the configured skills instance").action(async (name, options) => {
     try {
@@ -72796,8 +72881,8 @@ async function pushSkill(name, options = {}) {
   }
   const manifest = readPortableSkillManifest(skill.path, skill.name);
   const packed = packSkillBundle(skill.path, { maxUnpackedBytes: MAX_UNPACKED_BYTES });
-  const skillMdPath = join30(skill.path, "SKILL.md");
-  const skillMd = existsSync28(skillMdPath) ? readFileSync23(skillMdPath, "utf-8") : undefined;
+  const skillMdPath = join31(skill.path, "SKILL.md");
+  const skillMd = existsSync29(skillMdPath) ? readFileSync24(skillMdPath, "utf-8") : undefined;
   const base2 = {
     slug: skill.name,
     path: skill.path,
@@ -72823,7 +72908,7 @@ async function pushSkill(name, options = {}) {
     description: manifest.description,
     category: manifest.category ?? "Development Tools",
     tags: manifest.tags ?? [],
-    kind: manifest.kind ?? "executable",
+    kind: manifest.kind ?? "instruction",
     version: options.version ?? manifest.version,
     source: "custom",
     bundleSha256: packed.sha256,
@@ -73568,11 +73653,11 @@ var init_storage = __esm(() => {
 });
 
 // src/lib/registry-reconcile.ts
-import { existsSync as existsSync29, readFileSync as readFileSync24, statSync as statSync15, writeFileSync as writeFileSync19 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync25, statSync as statSync16, writeFileSync as writeFileSync19 } from "fs";
+import { join as join32 } from "path";
 function isDirectory2(path) {
   try {
-    return statSync15(path).isDirectory();
+    return statSync16(path).isDirectory();
   } catch {
     return false;
   }
@@ -73580,15 +73665,15 @@ function isDirectory2(path) {
 function migrationNeeded(options) {
   if (options.rootDir)
     return false;
-  const appDir = options.homeDir ? join31(options.homeDir, ".hasna", "skills") : getDataDir();
-  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join31(appDir, SKILLS_CACHE_DIRNAME)));
+  const appDir = options.homeDir ? join32(options.homeDir, ".hasna", "skills") : getDataDir();
+  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join32(appDir, SKILLS_CACHE_DIRNAME)));
 }
 function readBaseline(skillDir) {
-  const markerPath = join31(skillDir, PULL_MARKER_FILE);
-  if (!existsSync29(markerPath))
+  const markerPath = join32(skillDir, PULL_MARKER_FILE);
+  if (!existsSync30(markerPath))
     return;
   try {
-    const marker = JSON.parse(readFileSync24(markerPath, "utf-8"));
+    const marker = JSON.parse(readFileSync25(markerPath, "utf-8"));
     return {
       ...typeof marker.contentHash === "string" && marker.contentHash ? { contentHash: marker.contentHash } : {},
       ...typeof marker.version === "string" && marker.version ? { version: marker.version } : {}
@@ -73598,11 +73683,11 @@ function readBaseline(skillDir) {
   }
 }
 function readCursor(root) {
-  const path = join31(root, SYNC_CURSOR_FILE);
-  if (!existsSync29(path))
+  const path = join32(root, SYNC_CURSOR_FILE);
+  if (!existsSync30(path))
     return { runCount: 0 };
   try {
-    const cursor = JSON.parse(readFileSync24(path, "utf-8"));
+    const cursor = JSON.parse(readFileSync25(path, "utf-8"));
     return { runCount: typeof cursor.runCount === "number" ? cursor.runCount : 0 };
   } catch {
     return { runCount: 0 };
@@ -73611,12 +73696,12 @@ function readCursor(root) {
 function resolveCorpusRootReadOnly(options) {
   if (options.rootDir)
     return { root: options.rootDir, migrationPending: false };
-  const appDir = options.homeDir ? join31(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
-  const cache3 = join31(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join32(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
+  const cache3 = join32(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && isDirectory2(cache3)) {
     return { root: cache3, migrationPending: false };
   }
-  return { root: join31(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
+  return { root: join32(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
 }
 function remoteRowToSkill(record3) {
   const slug = typeof record3.slug === "string" ? record3.slug : typeof record3.name === "string" ? record3.name : undefined;
@@ -73630,7 +73715,7 @@ function remoteRowToSkill(record3) {
 }
 function recheckLocalSide(plannedLocal, localDir, ops = {
   pack: (dir) => packSkillBundle(dir).sha256,
-  exists: existsSync29
+  exists: existsSync30
 }) {
   let localNow;
   try {
@@ -73748,7 +73833,7 @@ async function reconcileRegistry(options = {}) {
   for (const slug of allSlugs) {
     const local = locals.get(slug);
     const remote = remotes.get(slug);
-    const baseline = local ? readBaseline(join31(root, slug)) : undefined;
+    const baseline = local ? readBaseline(join32(root, slug)) : undefined;
     const { state, reason } = classifySkill(local, remote, baseline);
     let { action, reason: actionReason } = resolveAction(state, direction, conflict);
     if (state === "remote-only" && isDigestless(remote)) {
@@ -73807,7 +73892,7 @@ async function reconcileRegistry(options = {}) {
       try {
         await pushSkill(slug, { rootDir: root, client });
         const pushed = locals.get(slug);
-        writePullMarker(join31(root, slug), {
+        writePullMarker(join32(root, slug), {
           skill: slug,
           ...pushed?.version ? { version: pushed.version } : {},
           ...pushed?.sha256 ? { contentHash: pushed.sha256 } : {},
@@ -73879,7 +73964,7 @@ async function reconcileRegistry(options = {}) {
         runCount: readCursor(root).runCount + 1,
         summary
       };
-      writeFileSync19(join31(root, SYNC_CURSOR_FILE), `${JSON.stringify(cursor, null, 2)}
+      writeFileSync19(join32(root, SYNC_CURSOR_FILE), `${JSON.stringify(cursor, null, 2)}
 `);
       return {
         corpusRoot: root,