@hasna/skills 0.1.63 → 0.1.66

package/bin/mcp.js

@@ -6727,6 +6727,9 @@ function normalizeConfigValue(key, value) {
     return value.trim() ? value : undefined;
   return;
 }
+function isOwnerLayoutMigrated(appDir) {
+  return existsSync(join(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+}
 function getDataDir() {
   const override = process.env[DATA_DIR_ENV];
   if (override) {
@@ -6750,6 +6753,33 @@ function getDataDir() {
   }
   return newDir;
 }
+function getDataDirReadOnly() {
+  const override = process.env[DATA_DIR_ENV];
+  if (override)
+    return override;
+  return join(process.env["HOME"] || process.env["USERPROFILE"] || homedir(), ".hasna", "skills");
+}
+function getConfigPathReadOnly(scope) {
+  if (scope === "global")
+    return join(getDataDirReadOnly(), "config.json");
+  return join(process.cwd(), "skills.config.json");
+}
+function loadConfigReadOnly() {
+  const canonicalConfigPath = getConfigPathReadOnly("global");
+  let globalConfig2;
+  if (existsSync(canonicalConfigPath)) {
+    globalConfig2 = readConfigFile(canonicalConfigPath);
+  } else if (process.env[DATA_DIR_ENV] !== undefined) {
+    globalConfig2 = {};
+  } else {
+    globalConfig2 = readConfigFile(legacyConfigFilePath());
+  }
+  const projectConfig = readConfigFile(getConfigPathReadOnly("project"));
+  return { ...globalConfig2, ...projectConfig };
+}
+function legacyConfigFilePath() {
+  return join(process.env["HOME"] || process.env["USERPROFILE"] || homedir(), ".skillsrc");
+}
 function getConfigPath(scope) {
   if (scope === "global") {
     return join(getDataDir(), "config.json");
@@ -6781,7 +6811,7 @@ function loadConfig() {
   const projectConfig = readConfigFile(getConfigPath("project"));
   return { ...globalConfig2, ...projectConfig };
 }
-var ENUM_KEYS, STRING_KEYS, DATA_DIR_ENV = "HASNA_SKILLS_DIR", INSTALLED_SKILLS_DIRNAME = "installed";
+var ENUM_KEYS, STRING_KEYS, DATA_DIR_ENV = "HASNA_SKILLS_DIR", INSTALLED_SKILLS_DIRNAME = "installed", SKILLS_CACHE_DIRNAME = "skills", LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
 var init_config = __esm(() => {
   init_retired_settings();
   ENUM_KEYS = {
@@ -6866,19 +6896,33 @@ var exports_auth_store = {};
 __export(exports_auth_store, {
   saveAuthConfig: () => saveAuthConfig,
   normalizeSkillsApiOrigin: () => normalizeSkillsApiOrigin,
+  getAuthFilePathReadOnly: () => getAuthFilePathReadOnly,
+  getAuthFilePath: () => getAuthFilePath,
+  getAuthConfigReadOnly: () => getAuthConfigReadOnly,
   getAuthConfig: () => getAuthConfig,
   getApiUrl: () => getApiUrl,
+  getApiKeyReadOnly: () => getApiKeyReadOnly,
   getApiKey: () => getApiKey,
   clearAuthConfig: () => clearAuthConfig
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6, unlinkSync } from "fs";
-import { 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 join12(getDataDir(), "auth.json");
+}
+function getAuthFilePathReadOnly() {
+  return join12(getDataDirReadOnly(), "auth.json");
+}
+function legacyAuthFilePath() {
+  return join12(process.env["HOME"] || process.env["USERPROFILE"] || homedir3(), ".skills", "auth.json");
+}
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const raw = readFileSync10(existsSync11(AUTH_FILE) ? AUTH_FILE : LEGACY_AUTH_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;
@@ -6892,19 +6936,20 @@ function getAuthConfig() {
   }
 }
 function saveAuthConfig(config2) {
-  mkdirSync6(AUTH_DIR, { recursive: true, mode: 448 });
-  writeFileSync6(AUTH_FILE, JSON.stringify(config2, null, 2) + `
+  const file = getAuthFilePath();
+  mkdirSync6(dirname5(file), { recursive: true, mode: 448 });
+  writeFileSync6(file, JSON.stringify(config2, null, 2) + `
 `, { mode: 384 });
   cachedConfig = config2;
 }
 function clearAuthConfig() {
   try {
-    unlinkSync(AUTH_FILE);
+    unlinkSync(getAuthFilePath());
   } catch {}
   try {
-    unlinkSync(LEGACY_AUTH_FILE);
+    unlinkSync(legacyAuthFilePath());
   } catch {}
-  cachedConfig = null;
+  cachedConfig = undefined;
 }
 function getApiKey() {
   if (process.env.SKILLS_API_KEY)
@@ -6913,6 +6958,25 @@ function getApiKey() {
     return process.env.SKILL_API_KEY;
   return getAuthConfig()?.apiKey || null;
 }
+function getAuthConfigReadOnly() {
+  try {
+    const file = existsSync12(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
+    const raw = readFileSync11(file, "utf-8");
+    const config2 = JSON.parse(raw);
+    if (!config2.apiKey)
+      return null;
+    return config2;
+  } catch {
+    return null;
+  }
+}
+function getApiKeyReadOnly() {
+  if (process.env.SKILLS_API_KEY)
+    return process.env.SKILLS_API_KEY;
+  if (process.env.SKILL_API_KEY)
+    return process.env.SKILL_API_KEY;
+  return getAuthConfigReadOnly()?.apiKey || null;
+}
 function normalizeSkillsApiOrigin(apiUrl) {
   const url = new URL(apiUrl);
   const pathname = url.pathname.replace(/\/+$/, "");
@@ -6928,12 +6992,10 @@ function normalizeSkillsApiOrigin(apiUrl) {
 function getApiUrl(action) {
   return normalizeSkillsApiOrigin(requireApiUrl(action));
 }
-var AUTH_DIR, AUTH_FILE, LEGACY_AUTH_FILE, cachedConfig;
+var cachedConfig;
 var init_auth_store = __esm(() => {
   init_api_url();
-  AUTH_DIR = join11(homedir3(), ".hasna", "skills");
-  AUTH_FILE = join11(AUTH_DIR, "auth.json");
-  LEGACY_AUTH_FILE = join11(homedir3(), ".skills", "auth.json");
+  init_config();
 });
 
 // src/lib/blog-article.ts
@@ -7069,8 +7131,11 @@ var init_blog_article = __esm(() => {
 // src/lib/remote-client.ts
 var exports_remote_client = {};
 __export(exports_remote_client, {
+  createRemoteSkillsClientReadOnly: () => createRemoteSkillsClientReadOnly,
   createRemoteSkillsClient: () => createRemoteSkillsClient,
-  RemoteSkillsClient: () => RemoteSkillsClient
+  RemoteSkillsClient: () => RemoteSkillsClient,
+  RemoteRouteUnsupportedError: () => RemoteRouteUnsupportedError,
+  RemoteRequestError: () => RemoteRequestError
 });
 
 class RemoteSkillsClient {
@@ -7090,6 +7155,20 @@ class RemoteSkillsClient {
       }
     });
   }
+  async requestNewRoute(path, options, opts = {}) {
+    const response = await this.request(path, options);
+    const routePath = path.split("?")[0];
+    if (response.status === 404 || response.status === 405) {
+      if (response.status === 404 && opts.domainNotFoundCodes?.length && await responseBodyCarriesCode(response, opts.domainNotFoundCodes)) {
+        return response;
+      }
+      throw new RemoteRouteUnsupportedError(routePath, response.status, this.apiUrl);
+    }
+    if (!response.ok) {
+      throw new RemoteRequestError(routePath, response.status, response.statusText);
+    }
+    return response;
+  }
   async listSkills() {
     const res = await this.request("/api/v1/skills");
     return res.json();
@@ -7106,6 +7185,14 @@ class RemoteSkillsClient {
       return null;
     return res.json();
   }
+  async getSkillStatus(slug) {
+    const res = await this.request(`/api/v1/skills/${encodeURIComponent(slug)}`, { method: "GET" });
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {}
+    return { status: res.status, body };
+  }
   async submitRun(slug, input, args) {
     const res = await this.request(`/api/v1/runs/${slug}`, {
       method: "POST",
@@ -7139,15 +7226,18 @@ class RemoteSkillsClient {
       method: "GET"
     });
   }
-  async publishSkill(manifest, bundle) {
+  async publishSkill(manifest, bundle, ifMatch) {
     const form = new FormData;
     form.set("manifest", JSON.stringify(manifest));
     if (bundle) {
       form.set("bundle", new Blob([bundle], { type: "application/gzip" }), `${String(manifest.slug ?? "skill")}.tar.gz`);
     }
+    const headers = { Authorization: `Bearer ${this.apiKey}` };
+    if (ifMatch)
+      headers["If-Match"] = ifMatch;
     return fetch(`${this.apiUrl}/api/v1/skills`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${this.apiKey}` },
+      headers,
       body: form
     });
   }
@@ -7163,6 +7253,135 @@ class RemoteSkillsClient {
       return null;
     return response;
   }
+  async listPins() {
+    const response = await this.requestNewRoute("/api/v1/pins");
+    return normalizePinList(await response.json());
+  }
+  async pin(slug, metadata) {
+    const path = `/api/v1/pins/${encodeURIComponent(slug)}`;
+    const response = await this.requestNewRoute(path, {
+      method: "PUT",
+      body: JSON.stringify({ ...metadata ? { metadata } : {} })
+    });
+    return normalizePin(await response.json());
+  }
+  async unpin(slug) {
+    const path = `/api/v1/pins/${encodeURIComponent(slug)}`;
+    const response = await this.requestNewRoute(path, { method: "DELETE" }, { domainNotFoundCodes: ["PIN_NOT_FOUND"] });
+    return response.status !== 404;
+  }
+  async listTags() {
+    const response = await this.requestNewRoute("/api/v1/tags");
+    const payload = await response.json();
+    if (!Array.isArray(payload)) {
+      throw new Error("Remote tags payload did not match the expected contract (expected an array of tag names)");
+    }
+    for (const tag of payload) {
+      if (typeof tag !== "string" || tag.trim().length === 0) {
+        throw new Error("Remote tags payload did not match the expected contract (every element must be a non-empty tag name)");
+      }
+    }
+    return payload;
+  }
+  async skillsByTag(tag) {
+    const path = `/api/v1/tags/${encodeURIComponent(tag)}/skills`;
+    const response = await this.requestNewRoute(path);
+    return normalizeSkillSummaryList(await response.json());
+  }
+  async listUpdatedSince(since, options = {}) {
+    const params = new URLSearchParams({ since });
+    if (options.cursor)
+      params.set("cursor", options.cursor);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    const response = await this.requestNewRoute(`/api/v1/skills/updated?${params.toString()}`);
+    return normalizeUpdatedSincePage(await response.json());
+  }
+}
+function requireOptionalString(record3, field) {
+  if (record3[field] === undefined)
+    return;
+  if (typeof record3[field] !== "string") {
+    throw new Error(`Remote payload did not match the expected contract (${field} must be a string when present)`);
+  }
+  return record3[field];
+}
+function normalizePin(entry) {
+  if (!entry || typeof entry !== "object") {
+    throw new Error("Remote pin payload did not match the expected contract (expected an object)");
+  }
+  const record3 = entry;
+  const slug = typeof record3.slug === "string" && record3.slug.trim() ? record3.slug.trim() : undefined;
+  if (!slug) {
+    throw new Error("Remote pin payload did not match the expected contract (missing slug)");
+  }
+  let metadata;
+  if (record3.metadata !== undefined) {
+    if (!record3.metadata || typeof record3.metadata !== "object" || Array.isArray(record3.metadata)) {
+      throw new Error("Remote pin payload did not match the expected contract (metadata must be a JSON object when present)");
+    }
+    metadata = record3.metadata;
+  }
+  const pinnedAt = requireOptionalString(record3, "pinnedAt");
+  return {
+    slug,
+    ...pinnedAt !== undefined ? { pinnedAt } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function normalizePinList(payload) {
+  if (!Array.isArray(payload)) {
+    throw new Error("Remote pins payload did not match the expected contract (expected an array of pins)");
+  }
+  return payload.map(normalizePin);
+}
+function normalizeSkillSummary(entry) {
+  if (!entry || typeof entry !== "object") {
+    throw new Error("Remote skill payload did not match the expected contract (expected an object)");
+  }
+  const record3 = entry;
+  const slug = typeof record3.slug === "string" && record3.slug.trim() ? record3.slug.trim() : undefined;
+  if (!slug) {
+    throw new Error("Remote skill payload did not match the expected contract (missing slug)");
+  }
+  return {
+    slug,
+    ...requireOptionalString(record3, "name") !== undefined ? { name: requireOptionalString(record3, "name") } : {},
+    ...requireOptionalString(record3, "version") !== undefined ? { version: requireOptionalString(record3, "version") } : {},
+    ...requireOptionalString(record3, "updatedAt") !== undefined ? { updatedAt: requireOptionalString(record3, "updatedAt") } : {}
+  };
+}
+function normalizeSkillSummaryList(payload) {
+  if (!Array.isArray(payload)) {
+    throw new Error("Remote skills payload did not match the expected contract (expected an array of skills)");
+  }
+  return payload.map(normalizeSkillSummary);
+}
+async function responseBodyCarriesCode(response, codes) {
+  try {
+    const payload = await response.clone().json();
+    if (!payload || typeof payload !== "object")
+      return false;
+    const code = payload.code;
+    return typeof code === "string" && codes.includes(code);
+  } catch {
+    return false;
+  }
+}
+function normalizeUpdatedSincePage(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("Updated-since payload did not match the expected contract (expected an object)");
+  }
+  const record3 = payload;
+  if (!Array.isArray(record3.skills)) {
+    throw new Error("Updated-since payload did not match the expected contract (missing skills array)");
+  }
+  const skills = record3.skills.map(normalizeSkillSummary);
+  const nextCursor = record3.nextCursor === undefined || record3.nextCursor === null ? null : record3.nextCursor;
+  if (nextCursor !== null && typeof nextCursor !== "string") {
+    throw new Error("Updated-since payload did not match the expected contract (nextCursor must be a string or absent)");
+  }
+  return { skills, nextCursor };
 }
 function createRemoteSkillsClient() {
   const apiKey = getApiKey();
@@ -7170,8 +7389,42 @@ function createRemoteSkillsClient() {
     return null;
   return new RemoteSkillsClient(apiKey);
 }
+function createRemoteSkillsClientReadOnly() {
+  const apiKey = getApiKeyReadOnly();
+  if (!apiKey)
+    return null;
+  const apiUrl = resolveApiUrl(loadConfigReadOnly(), process.env);
+  if (!apiUrl)
+    throw new MissingApiUrlError("the cloud group's sync verb (--dry-run)");
+  return new RemoteSkillsClient(apiKey, apiUrl);
+}
+var RemoteRouteUnsupportedError, RemoteRequestError;
 var init_remote_client = __esm(() => {
   init_auth_store();
+  init_api_url();
+  init_config();
+  RemoteRouteUnsupportedError = class RemoteRouteUnsupportedError extends Error {
+    path;
+    status;
+    instance;
+    constructor(path, status, instance) {
+      super(`The configured Skills instance does not support ${path} (HTTP ${status}). ` + `The instance at ${instance} predates this client feature \u2014 upgrade the server, or ` + `use a client version that matches it.`);
+      this.path = path;
+      this.status = status;
+      this.instance = instance;
+      this.name = "RemoteRouteUnsupportedError";
+    }
+  };
+  RemoteRequestError = class RemoteRequestError extends Error {
+    path;
+    status;
+    constructor(path, status, statusText) {
+      super(`Remote request to ${path} failed: HTTP ${status}${statusText ? ` ${statusText}` : ""}`);
+      this.path = path;
+      this.status = status;
+      this.name = "RemoteRequestError";
+    }
+  };
 });
 
 // ../../node_modules/.bun/content-type@1.0.5/node_modules/content-type/index.js
@@ -12690,7 +12943,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.63",
+  version: "0.1.66",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -12764,6 +13017,7 @@ var package_default = {
   license: "Apache-2.0",
   devDependencies: {
     "@types/bun": "latest",
+    "@types/node": "25.2.3",
     "@types/react": "^18.2.0",
     "bun-types": "1.3.14",
     "react-devtools-core": "^7.0.1",
@@ -12772,7 +13026,7 @@ var package_default = {
   dependencies: {
     "@aws-sdk/client-ecs": "^3.1079.0",
     "@aws-sdk/client-s3": "^3.1079.0",
-    "@hasna/events": "0.1.7",
+    "@hasna/events": "0.1.16",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -20625,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 = [
@@ -20800,7 +21055,7 @@ var DEVELOPMENT_TOOLS_SKILLS = [
   {
     name: "monitor",
     displayName: "Monitor",
-    description: "Operate the open-monitor MCP for machine health, processes, cron jobs, and cleanup workflows",
+    description: "Operate the monitor MCP for machine health, processes, cron jobs, and cleanup workflows",
     category: "Development Tools",
     tags: ["monitoring", "mcp", "processes", "operations"]
   },
@@ -20846,6 +21101,14 @@ var DEVELOPMENT_TOOLS_SKILLS = [
     description: "Validate configuration files for syntax and schema compliance",
     category: "Development Tools",
     tags: ["config", "validation", "schema", "linting"]
+  },
+  {
+    name: "session-inject-monitor",
+    displayName: "Session Inject Monitor",
+    description: "Set up a declarative monitor that injects a prompt into a live coding-agent session when a watched source (conversations, email, todos, knowledge, command output) has new content",
+    category: "Development Tools",
+    tags: ["monitor", "session", "injection", "automation", "wake"],
+    kind: "instruction"
   }
 ];
 
@@ -21233,7 +21496,7 @@ var DESIGN_BRANDING_SKILLS = [
     displayName: "Site Analyze",
     description: "Analyze any website's design system \u2014 detects shadcn/ui, Tailwind, extracts colors, typography, and components via Playwright + Claude Vision.",
     category: "Design & Branding",
-    tags: ["design", "shadcn", "tailwind", "colors", "typography", "playwright", "analysis", "open-styles"]
+    tags: ["design", "shadcn", "tailwind", "colors", "typography", "playwright", "analysis", "styles"]
   }
 ];
 
@@ -21343,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) {
@@ -21359,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",
@@ -21375,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([
@@ -21428,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;
@@ -21512,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,
@@ -21526,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`);
     }
@@ -21539,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 {
@@ -21589,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 {
@@ -21648,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`);
             }
           }
@@ -21666,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)`);
     }
@@ -21694,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 = [
@@ -21754,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);
@@ -21765,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;
     }
@@ -21788,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;
@@ -21988,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",
@@ -22038,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;
@@ -22089,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) {
@@ -22138,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) {
@@ -22168,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 = {
@@ -22178,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 {};
@@ -22217,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;
   }
@@ -22281,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);
@@ -22533,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;
@@ -22565,33 +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 installed = join5(appDir, INSTALLED_SKILLS_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 = 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 });
           }
@@ -22605,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 });
@@ -22621,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;
@@ -22631,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);
@@ -22644,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 {
@@ -22669,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 } : {}
     };
   });
 }
@@ -22680,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 });
@@ -22699,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));
@@ -22711,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 });
@@ -22740,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 {
@@ -22762,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)
@@ -22798,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`);
           }
         }
@@ -22809,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");
     }
   }
@@ -22841,7 +23118,7 @@ function summarizePortableSkill(skillPath, fallbackName) {
 }
 function safeIsDirectory(path) {
   try {
-    return statSync5(path).isDirectory();
+    return statSync6(path).isDirectory();
   } catch {
     return false;
   }
@@ -23067,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;
       }
@@ -23095,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
       });
     }
@@ -23103,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;
       }
@@ -23149,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;
@@ -23185,13 +23463,14 @@ 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";
 
 // src/lib/home-migration.ts
 init_config();
+init_config();
 
 // src/lib/utils.ts
 function normalizeSkillName(name) {
@@ -23202,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",
@@ -23218,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;
   }
@@ -23327,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) {
@@ -23340,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));
@@ -23355,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,
@@ -23410,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) {
@@ -23429,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";
@@ -23441,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;
   }
@@ -23473,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) {
@@ -23489,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);
   }
@@ -23532,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 {}
   }
@@ -23553,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)) {
@@ -23562,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];
@@ -23582,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",
@@ -23614,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);
@@ -23711,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;
@@ -25294,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,
@@ -25363,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;
   }
@@ -25395,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),
@@ -25419,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);
@@ -25476,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) {
@@ -25685,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
@@ -25699,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) + `
@@ -25875,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 {}
       }
@@ -25927,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 dirname5, 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 = dirname5(dbPath);
-  if (!existsSync13(dir))
+  const dir = dirname6(dbPath);
+  if (!existsSync14(dir))
     mkdirSync7(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
@@ -26095,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));
 }
@@ -26375,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 dirname6, 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",
@@ -26450,7 +26756,7 @@ function getSkillsNativeStorageStatus(options = {}) {
   const s3BucketEnv = readStorageEnv(env, "s3Bucket");
   const targetDir = options.targetDir ?? process.cwd();
   return {
-    package: "open-skills",
+    package: "skills",
     tables: [...SKILLS_STORAGE_TABLES],
     env: {
       databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
@@ -26459,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),
@@ -26479,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,
@@ -26562,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
@@ -26603,7 +26909,7 @@ function registerStorageTools(server) {
     const snapshot = exportSkillsLocalSnapshot(targetDir, { includeFileContents: false });
     const s3Plan = config2.s3Bucket ? planSkillsS3SnapshotUpload(snapshot, { prefix: config2.s3Prefix }) : [];
     return mcpJson({
-      package: "open-skills",
+      package: "skills",
       noNetwork: true,
       databaseConfigured: Boolean(config2.databaseUrl),
       s3Configured: Boolean(config2.s3Bucket),