@hasna/skills 0.1.64 → 0.1.66

package/bin/mcp.js

@@ -6905,24 +6905,24 @@ __export(exports_auth_store, {
   getApiKey: () => getApiKey,
   clearAuthConfig: () => clearAuthConfig
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6, unlinkSync } from "fs";
-import { dirname as dirname5, join as join11 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, unlinkSync } from "fs";
+import { dirname as dirname5, join as join12 } from "path";
 import { homedir as homedir3 } from "os";
 function getAuthFilePath() {
-  return join11(getDataDir(), "auth.json");
+  return join12(getDataDir(), "auth.json");
 }
 function getAuthFilePathReadOnly() {
-  return join11(getDataDirReadOnly(), "auth.json");
+  return join12(getDataDirReadOnly(), "auth.json");
 }
 function legacyAuthFilePath() {
-  return join11(process.env["HOME"] || process.env["USERPROFILE"] || homedir3(), ".skills", "auth.json");
+  return join12(process.env["HOME"] || process.env["USERPROFILE"] || homedir3(), ".skills", "auth.json");
 }
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const file = existsSync11(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
-    const raw = readFileSync10(file, "utf-8");
+    const file = existsSync12(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
+    const raw = readFileSync11(file, "utf-8");
     const config2 = JSON.parse(raw);
     if (!config2.apiKey) {
       cachedConfig = null;
@@ -6960,8 +6960,8 @@ function getApiKey() {
 }
 function getAuthConfigReadOnly() {
   try {
-    const file = existsSync11(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
-    const raw = readFileSync10(file, "utf-8");
+    const file = existsSync12(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
+    const raw = readFileSync11(file, "utf-8");
     const config2 = JSON.parse(raw);
     if (!config2.apiKey)
       return null;
@@ -12943,7 +12943,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.64",
+  version: "0.1.66",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -20879,22 +20879,23 @@ var EMPTY_COMPLETION_RESULT = {
 
 // src/lib/registry.ts
 init_config();
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync6 } from "fs";
+import { join as join7 } from "path";
 
 // src/lib/portable-skills.ts
 init_config();
 import {
   cpSync as cpSync2,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
-  readdirSync as readdirSync4,
+  mkdtempSync,
+  readdirSync as readdirSync5,
   renameSync,
   rmSync,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, normalize as normalize2 } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join6, normalize as normalize2 } from "path";
 
 // src/lib/registry-data/development-tools.ts
 var DEVELOPMENT_TOOLS_SKILLS = [
@@ -21605,11 +21606,9 @@ var SKILLS = [
   ...EVENT_MANAGEMENT_SKILLS
 ];
 
-// src/lib/skill-validation.ts
-import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { isAbsolute, join as join2, normalize } from "path";
-
 // src/lib/hosted-skill-set.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
 var HOSTED_RUNTIMES = new Set(["hosted"]);
 var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
 function normalizeMarker(value) {
@@ -21621,6 +21620,16 @@ function isHostedMetadataPackage(pkg) {
     return false;
   return HOSTED_RUNTIMES.has(normalizeMarker(skills.runtime)) || HOSTED_SOURCES.has(normalizeMarker(skills.source));
 }
+function isHostedMetadataSkillDir(skillDir) {
+  const pkgPath = join2(skillDir, "package.json");
+  if (!existsSync2(pkgPath))
+    return false;
+  try {
+    return isHostedMetadataPackage(JSON.parse(readFileSync2(pkgPath, "utf8")));
+  } catch {
+    return false;
+  }
+}
 var HOSTED_METADATA_SET_EMPTY_ERROR = [
   "The hosted metadata skill set is empty, but the packaging guards that depend on it",
   "only mean anything while it is non-empty: an empty set makes every one of them pass",
@@ -21637,6 +21646,8 @@ var BRACE_SOURCE_EXCLUSION = new RegExp(`^!skills/\\{(${SLUG}(?:,${SLUG})+)\\}/s
 var SINGLE_SOURCE_EXCLUSION = new RegExp(`^!skills/(${SLUG})/src$`);
 
 // src/lib/skill-validation.ts
+import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join3, normalize } from "path";
 var VALID_SKILL_KINDS = ["executable", "instruction"];
 var DOC_FILES = ["SKILL.md", "README.md", "CLAUDE.md"];
 var RESERVED_SKILL_ENTRIES = new Set([
@@ -21690,7 +21701,7 @@ function add(target, code, message) {
   target.push({ code, message });
 }
 function readJsonFile(path) {
-  return JSON.parse(readFileSync2(path, "utf-8"));
+  return JSON.parse(readFileSync3(path, "utf-8"));
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -21774,7 +21785,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     binCommands: [],
     docFiles: []
   };
-  if (!existsSync2(skillPath)) {
+  if (!existsSync3(skillPath)) {
     add(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
     return {
       name: bareName,
@@ -21788,8 +21799,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   if (!VALID_BIN_COMMAND.test(bareName)) {
     add(issues, "skill.name_invalid", `Skill name '${bareName}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
   }
-  for (const entry of readdirSync2(skillPath).sort()) {
-    const entryPath = join2(skillPath, entry);
+  for (const entry of readdirSync3(skillPath).sort()) {
+    const entryPath = join3(skillPath, entry);
     if (RESERVED_SKILL_ENTRIES.has(entry)) {
       add(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
     }
@@ -21801,15 +21812,15 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync2(join2(skillPath, docFile)))
+    if (existsSync3(join3(skillPath, docFile)))
       metadata.docFiles.push(docFile);
   }
   if (metadata.docFiles.length === 0) {
     add(issues, "skill.docs_missing", "Missing documentation file: expected SKILL.md, README.md, or CLAUDE.md");
   }
-  const skillMdPath = join2(skillPath, "SKILL.md");
-  if (existsSync2(skillMdPath)) {
-    const frontmatter = parseSkillFrontmatter(readFileSync2(skillMdPath, "utf-8"));
+  const skillMdPath = join3(skillPath, "SKILL.md");
+  if (existsSync3(skillMdPath)) {
+    const frontmatter = parseSkillFrontmatter(readFileSync3(skillMdPath, "utf-8"));
     if (!frontmatter) {
       add(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
     } else {
@@ -21851,8 +21862,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join2(skillPath, "package.json");
-  if (!existsSync2(pkgPath)) {
+  const pkgPath = join3(skillPath, "package.json");
+  if (!existsSync3(pkgPath)) {
     if (!isInstruction)
       add(issues, "package.missing", "Missing package.json");
   } else {
@@ -21910,10 +21921,10 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
               add(issues, "package.bin_target_unsafe", `package.json bin '${command}' target '${target}' must stay inside the skill directory`);
               continue;
             }
-            const targetPath = join2(skillPath, target);
-            if (!existsSync2(targetPath)) {
+            const targetPath = join3(skillPath, target);
+            if (!existsSync3(targetPath)) {
               add(warnings, "package.bin_target_missing", `package.json bin '${command}' target '${target}' is not present before build`);
-            } else if (statSync2(targetPath).isDirectory()) {
+            } else if (statSync3(targetPath).isDirectory()) {
               add(issues, "package.bin_target_directory", `package.json bin '${command}' target '${target}' must point to a file, not a directory`);
             }
           }
@@ -21928,18 +21939,18 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join2(skillPath, "src");
+    const srcDir = join3(skillPath, "src");
     if (hostedMetadata) {
-      if (existsSync2(srcDir)) {
+      if (existsSync3(srcDir)) {
         add(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
       }
-    } else if (!existsSync2(srcDir)) {
+    } else if (!existsSync3(srcDir)) {
       add(issues, "skill.src_missing", "Missing src/ directory");
-    } else if (!existsSync2(join2(srcDir, "index.ts")) && !existsSync2(join2(srcDir, "index.js"))) {
+    } else if (!existsSync3(join3(srcDir, "index.ts")) && !existsSync3(join3(srcDir, "index.js"))) {
       add(issues, "skill.src_index_missing", "Missing src/index.ts or src/index.js");
     } else {
-      const indexPath = existsSync2(join2(srcDir, "index.ts")) ? join2(srcDir, "index.ts") : join2(srcDir, "index.js");
-      const size = statSync2(indexPath).size;
+      const indexPath = existsSync3(join3(srcDir, "index.ts")) ? join3(srcDir, "index.ts") : join3(srcDir, "index.js");
+      const size = statSync3(indexPath).size;
       if (size < 50)
         add(warnings, "skill.src_index_minimal", `Source entry point is very small (${size}B)`);
     }
@@ -21956,8 +21967,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
 
 // src/lib/skill-hash.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { join as join3, sep } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { join as join4, sep } from "path";
 var CONTENT_HASH_ALGORITHM = "sha256";
 var HASH_EXCLUDE_DIRS = new Set([".git", "node_modules", "dist", "build", ".turbo"]);
 var HASH_COVERAGE = [
@@ -22016,10 +22027,10 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join3(skillPath, entry);
-    if (!existsSync3(absolute))
+    const absolute = join4(skillPath, entry);
+    if (!existsSync4(absolute))
       continue;
-    if (statSync3(absolute).isDirectory())
+    if (statSync4(absolute).isDirectory())
       collectDirectory(files, absolute, entry);
     else
       collectFile(files, absolute, entry);
@@ -22027,14 +22038,14 @@ function collectBundleFiles(skillPath) {
   return files.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
 }
 function collectDirectory(files, dir, rel) {
-  for (const entry of readdirSync3(dir).sort()) {
+  for (const entry of readdirSync4(dir).sort()) {
     if (entry.startsWith("."))
       continue;
-    const absolute = join3(dir, entry);
+    const absolute = join4(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
-      stats = statSync3(absolute);
+      stats = statSync4(absolute);
     } catch {
       continue;
     }
@@ -22050,7 +22061,7 @@ function collectDirectory(files, dir, rel) {
   }
 }
 function collectFile(files, absolute, rel) {
-  const buffer = readFileSync3(absolute);
+  const buffer = readFileSync4(absolute);
   if (rel === "skill.json") {
     files.push({ rel: rel.split(sep).join("/"), content: new TextEncoder().encode(canonicalizeManifest(new TextDecoder().decode(buffer))) });
     return;
@@ -22250,14 +22261,14 @@ function validateRuntimeContract(manifest, issues, strict) {
 // src/lib/portable-skills-files.ts
 import {
   cpSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   realpathSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join4, relative } from "path";
+import { basename, dirname as dirname2, join as join5, relative } from "path";
 var ANY_SEGMENT_COPY_EXCLUDES = new Set([
   ".git",
   ".DS_Store",
@@ -22300,12 +22311,12 @@ function normalizePortableSkillName(name) {
   return normalized;
 }
 function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
-  const skillJsonPath = join4(skillPath, "skill.json");
-  const skillMdPath = join4(skillPath, "SKILL.md");
-  const pkgPath = join4(skillPath, "package.json");
-  const jsonManifest = existsSync4(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync4(skillMdPath) ? parseSkillFrontmatter(readFileSync4(skillMdPath, "utf-8")) ?? undefined : undefined;
-  const pkg = existsSync4(pkgPath) ? readJsonObject(pkgPath) : undefined;
+  const skillJsonPath = join5(skillPath, "skill.json");
+  const skillMdPath = join5(skillPath, "SKILL.md");
+  const pkgPath = join5(skillPath, "package.json");
+  const jsonManifest = existsSync5(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
+  const frontmatter = existsSync5(skillMdPath) ? parseSkillFrontmatter(readFileSync5(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const pkg = existsSync5(pkgPath) ? readJsonObject(pkgPath) : undefined;
   const name = normalizePortableSkillName(stringField(jsonManifest, "name") ?? frontmatter?.name ?? stringValue(pkg?.name) ?? fallbackName);
   const description = stringField(jsonManifest, "description") ?? frontmatter?.description ?? stringValue(pkg?.description) ?? `${name} skill`;
   const version2 = stringField(jsonManifest, "version") ?? frontmatter?.version ?? stringValue(pkg?.version) ?? PORTABLE_SKILL_DEFAULT_VERSION;
@@ -22351,7 +22362,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join4(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join5(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -22400,12 +22411,12 @@ function createPortableManifest(name, options) {
   };
 }
 function writePortableSkillTemplate(skillPath, manifest) {
-  mkdirSync2(join4(skillPath, "src"), { recursive: true });
-  writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync2(join4(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync2(join4(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync2(join4(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync2(join4(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+  mkdirSync2(join5(skillPath, "src"), { recursive: true });
+  writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync2(join5(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync2(join5(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -22430,7 +22441,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join4(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash = computeContentHash(skillPath);
   const withHash = {
@@ -22440,16 +22451,16 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join4(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
 `);
   return withHash;
 }
 function readExistingSkillJson(skillPath) {
-  const path = join4(skillPath, "skill.json");
-  if (!existsSync4(path))
+  const path = join5(skillPath, "skill.json");
+  if (!existsSync5(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
     return isRecord2(parsed) ? parsed : {};
   } catch {
     return {};
@@ -22479,28 +22490,28 @@ function ensurePortableSkillFiles(skillPath, manifest) {
     tags: next.tags?.length ? next.tags : ["custom", next.name]
   };
   const entry = next.commands[0]?.entry ?? "src/index.ts";
-  if (entry && !existsSync4(join4(skillPath, entry))) {
-    mkdirSync2(dirname2(join4(skillPath, entry)), { recursive: true });
-    writeFileSync2(join4(skillPath, entry), renderEntrypoint(next));
+  if (entry && !existsSync5(join5(skillPath, entry))) {
+    mkdirSync2(dirname2(join5(skillPath, entry)), { recursive: true });
+    writeFileSync2(join5(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync4(join4(skillPath, "SKILL.md")))
-    writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync5(join5(skillPath, "SKILL.md")))
+    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync2(join4(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync4(join4(skillPath, "SKILL.md"), "utf-8"), next));
-  if (!existsSync4(join4(skillPath, "AGENTS.md")))
-    writeFileSync2(join4(skillPath, "AGENTS.md"), renderAgentsMd(next));
+    writeFileSync2(join5(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync5(join5(skillPath, "SKILL.md"), "utf-8"), next));
+  if (!existsSync5(join5(skillPath, "AGENTS.md")))
+    writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
-  if (!existsSync4(join4(skillPath, "tsconfig.json")))
-    writeFileSync2(join4(skillPath, "tsconfig.json"), renderTsconfig());
+  if (!existsSync5(join5(skillPath, "tsconfig.json")))
+    writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
 function ensurePackageJson(skillPath, manifest) {
-  const pkgPath = join4(skillPath, "package.json");
+  const pkgPath = join5(skillPath, "package.json");
   const first = manifest.commands[0] ?? { name: manifest.name, entry: "src/index.ts" };
   const commandName = normalizePortableSkillName(first.name || manifest.name);
   const entry = (first.entry ?? "src/index.ts").replace(/^\.\//, "");
-  if (!existsSync4(pkgPath)) {
+  if (!existsSync5(pkgPath)) {
     writeFileSync2(pkgPath, renderPackageJson(manifest));
     return;
   }
@@ -22543,8 +22554,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync4(join4(skillPath, "SKILL.md"))) {
-    writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync5(join5(skillPath, "SKILL.md"))) {
+    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
   }
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
@@ -22795,7 +22806,7 @@ function inferPackageCommands(pkg, fallbackName) {
   return;
 }
 function readJsonObject(path) {
-  const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+  const parsed = JSON.parse(readFileSync5(path, "utf-8"));
   if (!isRecord2(parsed))
     throw new Error(`${basename(path)} must contain a JSON object`);
   return parsed;
@@ -22827,36 +22838,36 @@ var LEGACY_CUSTOM_DIRNAME = "custom";
 function getPortableSkillsRoot(options = {}) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join5(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache = join5(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join6(options.homeDir, ".hasna", "skills") : getDataDir();
+  const cache = join6(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
     return cache;
-  const installed = join5(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join6(appDir, INSTALLED_SKILLS_DIRNAME);
   migrateLegacySkillLayout(appDir, installed);
   return installed;
 }
 function looksLikeSkillDirectory(path) {
   if (!safeIsDirectory(path))
     return false;
-  return existsSync5(join5(path, "SKILL.md")) || existsSync5(join5(path, "skill.json")) || existsSync5(join5(path, "package.json"));
+  return existsSync6(join6(path, "SKILL.md")) || existsSync6(join6(path, "skill.json")) || existsSync6(join6(path, "package.json"));
 }
 function migrateLegacySkillLayout(appDir, installed) {
   if (!safeIsDirectory(appDir))
     return;
   const candidates = [];
   try {
-    for (const entry of readdirSync4(appDir)) {
+    for (const entry of readdirSync5(appDir)) {
       if (entry.startsWith(".") || entry === INSTALLED_SKILLS_DIRNAME)
         continue;
-      const path = join5(appDir, entry);
+      const path = join6(appDir, entry);
       if (entry === LEGACY_CUSTOM_DIRNAME) {
         if (!safeIsDirectory(path))
           continue;
         try {
-          for (const nested of readdirSync4(path)) {
+          for (const nested of readdirSync5(path)) {
             if (nested.startsWith("."))
               continue;
-            const nestedPath = join5(path, nested);
+            const nestedPath = join6(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -22870,10 +22881,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join5(installed, name);
-    if (existsSync5(target))
+    const target = join6(installed, name);
+    if (existsSync6(target))
       continue;
-    const staging = join5(installed, `.migrating-${name}-${process.pid}`);
+    const staging = join6(installed, `.migrating-${name}-${process.pid}`);
     try {
       rmSync(staging, { recursive: true, force: true });
       cpSync2(from, staging, { recursive: true, errorOnExist: false });
@@ -22886,7 +22897,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join5(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join6(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -22896,7 +22907,7 @@ function findPortableSkill(name, options = {}) {
     return null;
   }
   const path = getPortableSkillPath(normalized, options);
-  if (!existsSync5(path) || !statSync5(path).isDirectory())
+  if (!existsSync6(path) || !statSync6(path).isDirectory())
     return null;
   try {
     return summarizePortableSkill(path, normalized);
@@ -22909,10 +22920,10 @@ function listPortableSkills(options = {}) {
   if (!safeIsDirectory(root))
     return [];
   const skills = [];
-  for (const entry of readdirSync4(root).sort()) {
+  for (const entry of readdirSync5(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join5(root, entry);
+    const path = join6(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -22934,7 +22945,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 } : {}
     };
   });
 }
@@ -22945,8 +22957,8 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizePortableSkillName(name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join5(root, skillName);
-  if (existsSync5(skillPath)) {
+  const skillPath = join6(root, skillName);
+  if (existsSync6(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
     rmSync(skillPath, { recursive: true, force: true });
@@ -22964,7 +22976,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize2(sourcePath);
-  if (!existsSync5(absoluteSource) || !statSync5(absoluteSource).isDirectory()) {
+  if (!existsSync6(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Skill source directory not found: ${sourcePath}`);
   }
   const inferred = readPortableSkillManifest(absoluteSource, basename2(absoluteSource));
@@ -22976,8 +22988,8 @@ function portPortableSkill(sourcePath, options = {}) {
     throw new Error(`${via} Importing it would shadow the official '${skillName}'. ` + `Pass --name to choose a different name, or --allow-shadow to override deliberately.`);
   }
   const root = getPortableSkillsRoot(options);
-  const destination = join5(root, skillName);
-  if (existsSync5(destination)) {
+  const destination = join6(root, skillName);
+  if (existsSync6(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync(destination, { recursive: true, force: true });
@@ -23005,10 +23017,10 @@ function validatePortableSkillDirectory(name, skillPath) {
   const issues = [...base.issues];
   const warnings = [...base.warnings];
   let manifest;
-  if (existsSync5(skillPath)) {
-    const skillJsonPath = join5(skillPath, "skill.json");
-    const skillMdPath = join5(skillPath, "SKILL.md");
-    if (!existsSync5(skillJsonPath) && !existsSync5(skillMdPath)) {
+  if (existsSync6(skillPath)) {
+    const skillJsonPath = join6(skillPath, "skill.json");
+    const skillMdPath = join6(skillPath, "SKILL.md");
+    if (!existsSync6(skillJsonPath) && !existsSync6(skillMdPath)) {
       add3(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
     try {
@@ -23027,7 +23039,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add3(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync5(join5(skillPath, "skill.json")),
+        strict: existsSync6(join6(skillPath, "skill.json")),
         skillPath
       });
       for (const issue2 of contractIssues)
@@ -23063,10 +23075,10 @@ function validatePortableSkillDirectory(name, skillPath) {
               add3(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
               continue;
             }
-            const entryPath = join5(skillPath, command.entry);
-            if (!existsSync5(entryPath))
+            const entryPath = join6(skillPath, command.entry);
+            if (!existsSync6(entryPath))
               add3(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
-            else if (statSync5(entryPath).isDirectory())
+            else if (statSync6(entryPath).isDirectory())
               add3(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
           }
         }
@@ -23074,7 +23086,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error2) {
       add3(issues, "portable.manifest_invalid", error2.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync5(join5(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync6(join6(skillPath, "AGENTS.md"))) {
       add3(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -23106,7 +23118,7 @@ function summarizePortableSkill(skillPath, fallbackName) {
 }
 function safeIsDirectory(path) {
   try {
-    return statSync5(path).isDirectory();
+    return statSync6(path).isDirectory();
   } catch {
     return false;
   }
@@ -23332,20 +23344,20 @@ function parseSkillMdFrontmatter(content) {
   return Object.keys(result).length > 0 ? result : null;
 }
 function discoverSkillsInDir(dir, source = "custom") {
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return [];
   const result = [];
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join6(dir, entry.name, "SKILL.md");
-      if (!existsSync6(skillMdPath))
+      const skillMdPath = join7(dir, entry.name, "SKILL.md");
+      if (!existsSync7(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync5(skillMdPath, "utf-8");
+        content = readFileSync6(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -23360,6 +23372,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
+        ...isHostedMetadataSkillDir(join7(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -23368,20 +23381,20 @@ function discoverSkillsInDir(dir, source = "custom") {
 }
 function findExtensionSkillPath(name) {
   const config2 = loadConfig();
-  if (!config2.extensionsDir || !existsSync6(config2.extensionsDir))
+  if (!config2.extensionsDir || !existsSync7(config2.extensionsDir))
     return null;
   try {
-    const entries = readdirSync5(config2.extensionsDir, { withFileTypes: true });
+    const entries = readdirSync6(config2.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join6(config2.extensionsDir, entry.name);
-      const skillMdPath = join6(skillDir, "SKILL.md");
-      if (!existsSync6(skillMdPath))
+      const skillDir = join7(config2.extensionsDir, entry.name);
+      const skillMdPath = join7(skillDir, "SKILL.md");
+      if (!existsSync7(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync5(skillMdPath, "utf-8");
+        content = readFileSync6(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -23414,7 +23427,7 @@ function loadRegistry(cwd) {
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
   const extensions = config2.extensionsDir ? discoverSkillsInDir(config2.extensionsDir, "extension") : [];
   const portableCustom = listPortableSkillMetas();
-  const legacyCustom = discoverSkillsInDir(join6(dataDir, "custom"));
+  const legacyCustom = discoverSkillsInDir(join7(dataDir, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now;
@@ -23450,8 +23463,8 @@ function mergeCustomSkills(skills) {
 }
 
 // src/lib/installer.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, rmSync as rmSync2 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, rmSync as rmSync2 } from "fs";
+import { dirname as dirname4, join as join9 } from "path";
 import { homedir as homedir2 } from "os";
 import { fileURLToPath } from "url";
 
@@ -23468,8 +23481,8 @@ function normalizeSkillName(name) {
 init_config();
 
 // src/lib/project-state.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
   "custom",
@@ -23484,17 +23497,17 @@ var SKILLS_PROJECT_DIR = ".skills";
 var PROJECT_CONFIG_FILE = "project.json";
 var DEFAULT_EXPORT_DIR = ".skills/exports";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join7(targetDir, SKILLS_PROJECT_DIR);
+  return join8(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join7(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join8(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync6(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync7(path, "utf-8")));
   } catch {
     return null;
   }
@@ -23593,12 +23606,12 @@ var __dirname2 = dirname4(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join8(dir, "skills");
-    if (existsSync8(candidate) && !dir.includes(".skills"))
+    const candidate = join9(dir, "skills");
+    if (existsSync9(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname4(dir);
   }
-  return join8(__dirname2, "..", "skills");
+  return join9(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
@@ -23606,13 +23619,13 @@ function getSkillPath(name) {
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join8(getDataDir(), "custom", skillName);
-  if (existsSync8(legacyCustomPath))
+  const legacyCustomPath = join9(getDataDir(), "custom", skillName);
+  if (existsSync9(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join8(SKILLS_DIR, skillName);
+  return join9(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
@@ -23621,7 +23634,7 @@ function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync8(getSkillPath(name))) {
+  if (!existsSync9(getSkillPath(name))) {
     const knownOfficial = Boolean(getSkill(name));
     return {
       skill: canonicalName,
@@ -23676,11 +23689,11 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join8(base, ".pi", "skills") : join8(homedir2(), ".pi", "agent", "skills");
+      return scope === "project" ? join9(base, ".pi", "skills") : join9(homedir2(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join8(base, ".opencode", "skills") : join8(homedir2(), ".config", "opencode", "skills");
+      return scope === "project" ? join9(base, ".opencode", "skills") : join9(homedir2(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join8(base, `.${agent}`, "skills") : join8(homedir2(), `.${agent}`, "skills");
+      return scope === "project" ? join9(base, `.${agent}`, "skills") : join9(homedir2(), `.${agent}`, "skills");
   }
 }
 function warnMissingDependencies(name, targetDir) {
@@ -23695,11 +23708,11 @@ function warnMissingDependencies(name, targetDir) {
   }
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join8(getSkillPath(name), "package.json");
-  if (!existsSync8(pkgPath))
+  const pkgPath = join9(getSkillPath(name), "package.json");
+  if (!existsSync9(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
@@ -23707,16 +23720,16 @@ function readBundledSkillVersion(name) {
 }
 
 // src/lib/skillinfo.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join as join10 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join9(skillPath, "SKILL.md");
-  if (!existsSync9(skillMdPath))
+  const skillMdPath = join10(skillPath, "SKILL.md");
+  if (!existsSync10(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync8(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync9(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -23739,12 +23752,12 @@ var HOSTED_PROVIDER_ENV_PREFIXES = [
 ];
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync9(skillPath))
+  if (!existsSync10(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join9(skillPath, "SKILL.md")),
-    readme: readIfExists(join9(skillPath, "README.md")),
-    claudeMd: readIfExists(join9(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join10(skillPath, "SKILL.md")),
+    readme: readIfExists(join10(skillPath, "README.md")),
+    claudeMd: readIfExists(join10(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -23755,11 +23768,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync9(skillPath))
+  if (!existsSync10(skillPath))
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join9(skillPath, file));
+    const content = readIfExists(join10(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -23798,10 +23811,10 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join9(skillPath, "package.json");
-  if (existsSync9(pkgPath)) {
+  const pkgPath = join10(skillPath, "package.json");
+  if (existsSync10(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
     } catch {}
   }
@@ -23819,7 +23832,7 @@ async function runSkill(name, args, options = {}) {
   const meta = getSkill(name);
   const canonicalName = meta?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync9(skillPath)) {
+  if (!existsSync10(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
   if (isInstructionSkillDir(skillPath, meta)) {
@@ -23828,13 +23841,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 = join9(skillPath, "package.json");
-  if (!existsSync9(pkgPath)) {
+  const pkgPath = join10(skillPath, "package.json");
+  if (!existsSync10(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
   try {
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint = binValues[0];
@@ -23848,12 +23861,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join9(skillPath, entryPoint);
-  if (!existsSync9(entryPath)) {
+  const entryPath = join10(skillPath, entryPoint);
+  if (!existsSync10(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join9(skillPath, "node_modules");
-  if (!existsSync9(nodeModules)) {
+  const nodeModules = join10(skillPath, "node_modules");
+  if (!existsSync10(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -23880,15 +23893,15 @@ async function runSkill(name, args, options = {}) {
   return { exitCode };
 }
 function detectProjectSkills(cwd = process.cwd()) {
-  const pkgPath = join9(cwd, "package.json");
-  if (!existsSync9(pkgPath)) {
+  const pkgPath = join10(cwd, "package.json");
+  if (!existsSync10(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(readFileSync8(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync9(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);
@@ -23977,8 +23990,8 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync9(path)) {
-      return readFileSync8(path, "utf-8");
+    if (existsSync10(path)) {
+      return readFileSync9(path, "utf-8");
     }
   } catch {}
   return null;
@@ -25560,25 +25573,25 @@ function registerDiscoveryTools(server) {
 }
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7, statSync as statSync7 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync8, statSync as statSync8 } from "fs";
+import { join as join13 } from "path";
 
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync9, readdirSync as readdirSync6, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
-import { extname, join as join10, relative as relative2 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, readdirSync as readdirSync7, statSync as statSync7, writeFileSync as writeFileSync5 } from "fs";
+import { extname, join as join11, relative as relative2 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now = new Date;
   const id = createRunId(now);
   const day = now.toISOString().slice(0, 10);
   const skillName = normalizeSkillName(params.skill);
   const root = getProjectStateDir(targetDir);
-  const runDir = join10(root, "runs", day, id);
-  const logsDir = join10(runDir, "logs");
-  const exportDir = join10(root, "exports", skillName, id);
+  const runDir = join11(root, "runs", day, id);
+  const logsDir = join11(runDir, "logs");
+  const exportDir = join11(root, "exports", skillName, id);
   mkdirSync5(logsDir, { recursive: true });
   mkdirSync5(exportDir, { recursive: true });
-  mkdirSync5(join10(root, "tmp"), { recursive: true });
+  mkdirSync5(join11(root, "tmp"), { recursive: true });
   const record3 = {
     id,
     skill: skillName,
@@ -25629,22 +25642,22 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync5(join10(context.logsDir, "stdout.log"), stdout);
-  writeFileSync5(join10(context.logsDir, "stderr.log"), stderr);
+  writeFileSync5(join11(context.logsDir, "stdout.log"), stdout);
+  writeFileSync5(join11(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join10(context.runDir, "events.ndjson");
-  const previous = existsSync10(path) ? readFileSync9(path, "utf-8") : "";
+  const path = join11(context.runDir, "events.ndjson");
+  const previous = existsSync11(path) ? readFileSync10(path, "utf-8") : "";
   writeFileSync5(path, previous + line);
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join10(getProjectStateDir(targetDir), "runs");
-  if (!existsSync10(runsRoot))
+  const runsRoot = join11(getProjectStateDir(targetDir), "runs");
+  if (!existsSync11(runsRoot))
     return null;
-  for (const day of readdirSync6(runsRoot)) {
-    const record3 = readRunRecord(join10(runsRoot, day, runId));
+  for (const day of readdirSync7(runsRoot)) {
+    const record3 = readRunRecord(join11(runsRoot, day, runId));
     if (record3)
       return record3;
   }
@@ -25661,20 +25674,20 @@ function skillRunEnv(context) {
   };
 }
 function writeRunRecord(context) {
-  writeFileSync5(join10(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync5(join11(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync5(join10(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync5(join11(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
-  if (!existsSync10(context.exportDir))
+  if (!existsSync11(context.exportDir))
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
-    const stat = statSync6(path);
-    const bytes = readFileSync9(path);
+    const stat = statSync7(path);
+    const bytes = readFileSync10(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
@@ -25685,20 +25698,20 @@ function collectRunArtifacts(context) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join10(runDir, "run.json");
-  if (!existsSync10(path))
+  const path = join11(runDir, "run.json");
+  if (!existsSync11(path))
     return null;
   try {
-    return JSON.parse(readFileSync9(path, "utf-8"));
+    return JSON.parse(readFileSync10(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync6(dir)) {
-    const full = join10(dir, entry);
-    if (statSync6(full).isDirectory())
+  for (const entry of readdirSync7(dir)) {
+    const full = join11(dir, entry);
+    if (statSync7(full).isDirectory())
       files.push(...walkFiles(full));
     else
       files.push(full);
@@ -25742,6 +25755,34 @@ function mimeForPath(path) {
       return "application/octet-stream";
   }
 }
+// src/lib/run-routing.ts
+init_api_url();
+init_auth_store();
+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());
+}
 
 // src/mcp/operation-tools.ts
 function registerOperationTools(server) {
@@ -25951,7 +25992,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
@@ -25965,24 +26005,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) + `
@@ -26141,13 +26181,13 @@ function registerOperationTools(server) {
     const agents = [];
     for (const agent of AGENT_TARGETS) {
       const agentSkillsPath = getAgentSkillsDir(agent, "global");
-      const exists = existsSync12(agentSkillsPath);
+      const exists = existsSync13(agentSkillsPath);
       let skillCount = 0;
       if (exists) {
         try {
-          skillCount = readdirSync7(agentSkillsPath).filter((f) => {
-            const full = join12(agentSkillsPath, f);
-            return !f.startsWith(".") && statSync7(full).isDirectory();
+          skillCount = readdirSync8(agentSkillsPath).filter((f) => {
+            const full = join13(agentSkillsPath, f);
+            return !f.startsWith(".") && statSync8(full).isDirectory();
           }).length;
         } catch {}
       }
@@ -26193,16 +26233,16 @@ function compactRunToolPayload(payload, detailHint) {
 
 // src/lib/feedback.ts
 init_config();
-import { existsSync as existsSync13, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname6, join as join13 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname6, join as join14 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join13(getDataDir(), "skills.db");
+  return join14(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
   const dir = dirname6(dbPath);
-  if (!existsSync13(dir))
+  if (!existsSync14(dir))
     mkdirSync7(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
@@ -26361,24 +26401,24 @@ function registerResourceMetaTools(server) {
 }
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8 } from "fs";
+import { join as join15 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join14(targetDir, ".skills", "schedules.json");
+  return join15(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  if (existsSync14(path)) {
+  if (existsSync15(path)) {
     try {
-      return JSON.parse(readFileSync11(path, "utf-8"));
+      return JSON.parse(readFileSync12(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join14(targetDir, ".skills");
-  if (!existsSync14(dir))
+  const dir = join15(targetDir, ".skills");
+  if (!existsSync15(dir))
     mkdirSync8(dir, { recursive: true });
   writeFileSync7(path, JSON.stringify(data, null, 2));
 }
@@ -26641,14 +26681,14 @@ function registerScheduleTools(server) {
 init_config();
 import { createHash as createHash3, createHmac } from "crypto";
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync12,
-  readdirSync as readdirSync8,
-  statSync as statSync8,
+  readFileSync as readFileSync13,
+  readdirSync as readdirSync9,
+  statSync as statSync9,
   writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname7, join as join15, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
+import { dirname as dirname7, join as join16, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
 init_retired_settings();
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
@@ -26725,7 +26765,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join15(getDataDir(), "skills.db")
+      feedbackDbPath: join16(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config2.databaseUrl),
@@ -26745,9 +26785,9 @@ function getStorageStatus(options = {}) {
 function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const projectStateDir = getProjectStateDir(targetDir);
   const files = [];
-  if (existsSync15(projectStateDir)) {
+  if (existsSync16(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync12(filePath);
+      const bytes = readFileSync13(filePath);
       const relativePath = toPosix(relative3(targetDir, filePath));
       files.push({
         path: relativePath,
@@ -26828,9 +26868,9 @@ function parsePositiveInteger(value) {
 }
 function walkFiles2(dir) {
   const files = [];
-  for (const entry of readdirSync8(dir)) {
-    const full = join15(dir, entry);
-    const stats = statSync8(full);
+  for (const entry of readdirSync9(dir)) {
+    const full = join16(dir, entry);
+    const stats = statSync9(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
     else