@hasna/skills 0.1.43 → 0.1.44

package/bin/mcp.js

@@ -6509,6 +6509,100 @@ var require_dist = __commonJS((exports, module) => {
   exports.default = formatsPlugin;
 });
 
+// src/lib/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+function validKeys() {
+  return ["mode", ...Object.keys(ENUM_KEYS), ...STRING_KEYS];
+}
+function allowedValues(key) {
+  if (key === "mode")
+    return MODE_VALUES;
+  return ENUM_KEYS[key];
+}
+function normalizeConfigValue(key, value) {
+  if (typeof value !== "string")
+    return;
+  if (key === "mode")
+    return MODE_ALIASES[value.trim().toLowerCase()];
+  const allowed = allowedValues(key);
+  if (allowed)
+    return allowed.includes(value) ? value : undefined;
+  if (key === "apiUrl") {
+    try {
+      const url2 = new URL(value);
+      if (url2.protocol !== "http:" && url2.protocol !== "https:")
+        return;
+      return value.replace(/\/+$/, "");
+    } catch {
+      return;
+    }
+  }
+  return;
+}
+function getDataDir() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
+  const newDir = join(home, ".hasna", "skills");
+  const oldConfigFile = join(home, ".skillsrc");
+  if (existsSync(oldConfigFile) && !existsSync(join(newDir, "config.json"))) {
+    mkdirSync(newDir, { recursive: true });
+    try {
+      copyFileSync(oldConfigFile, join(newDir, "config.json"));
+    } catch {}
+  }
+  mkdirSync(newDir, { recursive: true });
+  return newDir;
+}
+function getConfigPath(scope) {
+  if (scope === "global") {
+    return join(getDataDir(), "config.json");
+  }
+  return join(process.cwd(), "skills.config.json");
+}
+function readConfigFile(path) {
+  if (!existsSync(path))
+    return {};
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return {};
+    const config2 = {};
+    for (const key of validKeys()) {
+      const value = normalizeConfigValue(key, parsed[key]);
+      if (value !== undefined)
+        config2[key] = value;
+    }
+    return config2;
+  } catch {
+    return {};
+  }
+}
+function loadConfig() {
+  const globalConfig2 = readConfigFile(getConfigPath("global"));
+  const projectConfig = readConfigFile(getConfigPath("project"));
+  return { ...globalConfig2, ...projectConfig };
+}
+var ENUM_KEYS, STRING_KEYS, MODE_VALUES, MODE_ALIASES;
+var init_config = __esm(() => {
+  ENUM_KEYS = {
+    defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
+    defaultScope: ["global", "project"],
+    format: ["compact", "json", "csv"]
+  };
+  STRING_KEYS = ["apiUrl"];
+  MODE_VALUES = ["local", "hosted"];
+  MODE_ALIASES = {
+    local: "local",
+    offline: "local",
+    hosted: "hosted",
+    remote: "hosted",
+    "skills.md": "hosted",
+    skillsmd: "hosted"
+  };
+});
+
 // src/lib/skill-aliases.ts
 function normalizeSkillSlug(name) {
   return name.trim();
@@ -7016,7 +7110,7 @@ var init_pricing = __esm(() => {
 
 // src/lib/remote-run-contract.ts
 function normalizeRemoteSkillRunContract(payload, fallbackSkill) {
-  const record3 = isRecord(payload) ? payload : {};
+  const record3 = isRecord2(payload) ? payload : {};
   return {
     contractVersion: REMOTE_SKILL_RUN_CONTRACT_VERSION,
     ...pickString(record3, "id"),
@@ -7044,7 +7138,7 @@ function normalizeRemoteSkillRunContract(payload, fallbackSkill) {
     ...pickNumber(record3, "balanceCents")
   };
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function hasOwn(record3, key) {
@@ -7063,104 +7157,10 @@ function pickNumber(record3, key) {
   return typeof value === "number" && Number.isFinite(value) ? { [key]: value } : {};
 }
 function pickPricing(record3) {
-  return isRecord(record3.pricing) ? { pricing: record3.pricing } : {};
+  return isRecord2(record3.pricing) ? { pricing: record3.pricing } : {};
 }
 var REMOTE_SKILL_RUN_CONTRACT_VERSION = 1;
 
-// src/lib/config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, copyFileSync } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
-import { homedir as homedir3 } from "os";
-function validKeys() {
-  return ["mode", ...Object.keys(ENUM_KEYS), ...STRING_KEYS];
-}
-function allowedValues(key) {
-  if (key === "mode")
-    return MODE_VALUES;
-  return ENUM_KEYS[key];
-}
-function normalizeConfigValue(key, value) {
-  if (typeof value !== "string")
-    return;
-  if (key === "mode")
-    return MODE_ALIASES[value.trim().toLowerCase()];
-  const allowed = allowedValues(key);
-  if (allowed)
-    return allowed.includes(value) ? value : undefined;
-  if (key === "apiUrl") {
-    try {
-      const url2 = new URL(value);
-      if (url2.protocol !== "http:" && url2.protocol !== "https:")
-        return;
-      return value.replace(/\/+$/, "");
-    } catch {
-      return;
-    }
-  }
-  return;
-}
-function getDataDir() {
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir3();
-  const newDir = join6(home, ".hasna", "skills");
-  const oldConfigFile = join6(home, ".skillsrc");
-  if (existsSync6(oldConfigFile) && !existsSync6(join6(newDir, "config.json"))) {
-    mkdirSync3(newDir, { recursive: true });
-    try {
-      copyFileSync(oldConfigFile, join6(newDir, "config.json"));
-    } catch {}
-  }
-  mkdirSync3(newDir, { recursive: true });
-  return newDir;
-}
-function getConfigPath(scope) {
-  if (scope === "global") {
-    return join6(getDataDir(), "config.json");
-  }
-  return join6(process.cwd(), "skills.config.json");
-}
-function readConfigFile(path) {
-  if (!existsSync6(path))
-    return {};
-  try {
-    const raw = readFileSync6(path, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-      return {};
-    const config2 = {};
-    for (const key of validKeys()) {
-      const value = normalizeConfigValue(key, parsed[key]);
-      if (value !== undefined)
-        config2[key] = value;
-    }
-    return config2;
-  } catch {
-    return {};
-  }
-}
-function loadConfig() {
-  const globalConfig2 = readConfigFile(getConfigPath("global"));
-  const projectConfig = readConfigFile(getConfigPath("project"));
-  return { ...globalConfig2, ...projectConfig };
-}
-var ENUM_KEYS, STRING_KEYS, MODE_VALUES, MODE_ALIASES;
-var init_config = __esm(() => {
-  ENUM_KEYS = {
-    defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
-    defaultScope: ["global", "project"],
-    format: ["compact", "json", "csv"]
-  };
-  STRING_KEYS = ["apiUrl"];
-  MODE_VALUES = ["local", "hosted"];
-  MODE_ALIASES = {
-    local: "local",
-    offline: "local",
-    hosted: "hosted",
-    remote: "hosted",
-    "skills.md": "hosted",
-    skillsmd: "hosted"
-  };
-});
-
 // src/lib/auth-store.ts
 var exports_auth_store = {};
 __export(exports_auth_store, {
@@ -7171,14 +7171,14 @@ __export(exports_auth_store, {
   getApiKey: () => getApiKey,
   clearAuthConfig: () => clearAuthConfig
 });
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4, unlinkSync } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync5, unlinkSync } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir3 } from "os";
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const raw = readFileSync7(existsSync7(AUTH_FILE) ? AUTH_FILE : LEGACY_AUTH_FILE, "utf-8");
+    const raw = readFileSync9(existsSync9(AUTH_FILE) ? AUTH_FILE : LEGACY_AUTH_FILE, "utf-8");
     const config2 = JSON.parse(raw);
     if (!config2.apiKey || !config2.email) {
       cachedConfig = null;
@@ -7192,8 +7192,8 @@ function getAuthConfig() {
   }
 }
 function saveAuthConfig(config2) {
-  mkdirSync4(AUTH_DIR, { recursive: true, mode: 448 });
-  writeFileSync4(AUTH_FILE, JSON.stringify(config2, null, 2) + `
+  mkdirSync5(AUTH_DIR, { recursive: true, mode: 448 });
+  writeFileSync5(AUTH_FILE, JSON.stringify(config2, null, 2) + `
 `, { mode: 384 });
   cachedConfig = config2;
 }
@@ -7231,9 +7231,9 @@ function getApiUrl() {
 var AUTH_DIR, AUTH_FILE, LEGACY_AUTH_FILE, cachedConfig;
 var init_auth_store = __esm(() => {
   init_config();
-  AUTH_DIR = join7(homedir4(), ".hasna", "skills");
-  AUTH_FILE = join7(AUTH_DIR, "auth.json");
-  LEGACY_AUTH_FILE = join7(homedir4(), ".skills", "auth.json");
+  AUTH_DIR = join9(homedir3(), ".hasna", "skills");
+  AUTH_FILE = join9(AUTH_DIR, "auth.json");
+  LEGACY_AUTH_FILE = join9(homedir3(), ".skills", "auth.json");
 });
 
 // src/lib/remote-client.ts
@@ -21797,7 +21797,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.43",
+  version: "0.1.44",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -21816,6 +21816,7 @@ var package_default = {
     "!dist/platform",
     "!dist/server",
     "bin/",
+    "docs/skill-standard.md",
     "skills/",
     "!skills/**/node_modules",
     "!skills/scaffold-project/my-app",
@@ -21860,7 +21861,6 @@ var package_default = {
     typescript: "^5"
   },
   dependencies: {
-    "@hasna/events": "^0.1.7",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -29473,98 +29473,990 @@ var EMPTY_COMPLETION_RESULT = {
 };
 
 // src/lib/registry.ts
-init_skill_aliases();
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+init_config();
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
+import { join as join4 } from "path";
 
-// src/lib/registry-data/development-tools.ts
-var DEVELOPMENT_TOOLS_SKILLS = [
-  {
-    name: "api-test-suite",
-    displayName: "API Test Suite",
-    description: "Generate and run API test suites with comprehensive endpoint coverage",
-    category: "Development Tools",
-    tags: ["api", "testing", "automation", "qa"]
-  },
-  {
-    name: "apidocs",
-    displayName: "API Docs",
-    description: "Agentic web crawler for API documentation indexing and semantic search",
-    category: "Development Tools",
-    tags: ["api", "documentation", "search", "indexing"]
-  },
-  {
-    name: "api-docs-portal",
-    displayName: "API Docs Portal",
-    description: "Generate premium static API documentation portals from OpenAPI specs, route lists, and endpoint examples",
-    category: "Development Tools",
-    tags: ["api", "documentation", "openapi", "portal", "premium", "remote"]
-  },
-  {
-    name: "sdk-generator",
-    displayName: "SDK Generator",
-    description: "Generate hosted TypeScript SDK scaffolds with client code, types, package files, tests, README, examples, and API summaries",
-    category: "Development Tools",
-    tags: ["sdk", "api", "typescript", "developer-tools", "premium", "remote"]
-  },
-  {
-    name: "repo-onboarding-report",
-    displayName: "Repo Onboarding Report",
-    description: "Generate hosted repository onboarding packages with architecture maps, setup guides, risk registers, and first-week plans",
-    category: "Development Tools",
-    tags: ["repository", "onboarding", "architecture", "developer-tools", "premium", "remote"]
-  },
-  {
-    name: "codefix",
-    displayName: "Code Fix",
-    description: "Code quality CLI for auto-linting, formatting, fixing, and style enforcement",
-    category: "Development Tools",
-    tags: ["code", "linting", "formatting", "quality"]
-  },
-  {
-    name: "commitpush",
-    displayName: "Commit Push",
-    description: "Create logical commits from repo changes and push directly to the main branch",
-    category: "Development Tools",
-    tags: ["git", "commit", "push", "automation"]
-  },
-  {
-    name: "commitpushpr",
-    displayName: "Commit Push PR",
-    description: "Create logical commits, push a feature branch, and open a GitHub pull request",
-    category: "Development Tools",
-    tags: ["git", "commit", "pull-request", "github", "automation"],
-    dependencies: ["commitpush"]
-  },
-  {
-    name: "consolelog",
-    displayName: "Console Log",
-    description: "Monitor console logs from web applications using Playwright headless browser",
-    category: "Development Tools",
-    tags: ["console", "monitoring", "debugging", "logs"]
-  },
-  {
-    name: "database-explorer",
-    displayName: "Database Explorer",
-    description: "Explore and query databases with an interactive interface",
-    category: "Development Tools",
-    tags: ["database", "explorer", "sql", "query"]
-  },
-  {
-    name: "deploy",
-    displayName: "Deploy",
-    description: "Deployment CLI for managing EC2 deployments with automated health checks",
-    category: "Development Tools",
-    tags: ["deployment", "ec2", "aws", "ci-cd"]
-  },
-  {
-    name: "diff-viewer",
-    displayName: "Diff Viewer",
-    description: "View and analyze file differences with visual diff representation",
-    category: "Development Tools",
-    tags: ["diff", "comparison", "files", "code-review"]
-  },
+// src/lib/portable-skills.ts
+init_config();
+import {
+  cpSync,
+  existsSync as existsSync3,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join3, normalize as normalize2, relative } from "path";
+
+// src/lib/skill-validation.ts
+init_pricing();
+import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { isAbsolute, join as join2, normalize } from "path";
+var DOC_FILES = ["SKILL.md", "README.md", "CLAUDE.md"];
+var RESERVED_SKILL_ENTRIES = new Set([
+  ".env",
+  ".npmrc",
+  ".pypirc",
+  ".netrc",
+  "id_rsa",
+  "id_ed25519"
+]);
+var KNOWN_TOP_LEVEL_ENTRIES = new Set([
+  ".claude",
+  ".env.example",
+  ".gitignore",
+  ".skills",
+  "CLAUDE.md",
+  "AGENTS.md",
+  "LICENSE",
+  "PROJECT_OVERVIEW.md",
+  "QUICKSTART.md",
+  "README.md",
+  "SKILL.md",
+  "api-docs-list.json",
+  "auth.ts",
+  "bun.lock",
+  "bunfig.toml",
+  "data",
+  "dist",
+  "examples",
+  "exports",
+  "http-client.ts",
+  "index.ts",
+  "install.sh",
+  "installer.ts",
+  "logs",
+  "node_modules",
+  "package.json",
+  "scripts",
+  "skill-install.ts",
+  "skill.json",
+  "src",
+  "tests",
+  "references",
+  "assets",
+  "tsconfig.json",
+  "vision.ts"
+]);
+var VALID_PROVENANCE_SOURCES = new Set(["official", "custom", "remote", "private", "private-hosted", "upstream"]);
+var VALID_BIN_COMMAND = /^[a-z0-9][a-z0-9._-]*$/;
+function add(target, code, message) {
+  target.push({ code, message });
+}
+function readJsonFile(path) {
+  return JSON.parse(readFileSync2(path, "utf-8"));
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function sortMessages(messages) {
+  return [...messages].sort((a, b) => a.code.localeCompare(b.code) || a.message.localeCompare(b.message));
+}
+function isSafeRelativePath(value) {
+  if (!value.trim() || isAbsolute(value))
+    return false;
+  const normalized = normalize(value).replace(/\\/g, "/");
+  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
+}
+function isHostedPackageMetadata(pkg) {
+  const skills = asRecord(pkg.skills);
+  if (!skills)
+    return false;
+  const runtime = typeof skills.runtime === "string" ? skills.runtime.trim().toLowerCase() : "";
+  const source = typeof skills.source === "string" ? skills.source.trim().toLowerCase() : "";
+  return runtime === "hosted" || source === "remote" || source === "private-hosted";
+}
+function isHostedMetadataSkill(skillName, frontmatter, registryMeta, packageDeclaresHosted) {
+  if (packageDeclaresHosted)
+    return true;
+  if (isPremiumSkill(skillName))
+    return true;
+  if (frontmatter?.source === "private-hosted")
+    return true;
+  if (frontmatter?.source === "remote" && !registryMeta?.tags.includes("local"))
+    return true;
+  return false;
+}
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match)
+    return null;
+  const result = {};
+  const lines = match[1].split(/\r?\n/);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const colon = line.indexOf(":");
+    if (colon === -1)
+      continue;
+    const key = line.slice(0, colon).trim();
+    const rawValue = line.slice(colon + 1).trim();
+    if (!key)
+      continue;
+    if (key === "tags" && rawValue === "") {
+      const tags = [];
+      while (i + 1 < lines.length && /^\s+-\s+/.test(lines[i + 1])) {
+        i++;
+        tags.push(lines[i].replace(/^\s+-\s+/, "").trim());
+      }
+      result.tags = tags;
+      continue;
+    }
+    const value = rawValue.replace(/^["']|["']$/g, "");
+    if (!value)
+      continue;
+    if (key === "name")
+      result.name = value;
+    else if (key === "description")
+      result.description = value;
+    else if (key === "displayName" || key === "display_name")
+      result.displayName = value;
+    else if (key === "category")
+      result.category = value;
+    else if (key === "version")
+      result.version = value;
+    else if (key === "source")
+      result.source = value;
+    else if (key === "tags") {
+      result.tags = value.replace(/[\[\]]/g, "").split(",").map((tag) => tag.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function validateSkillDirectory(name, skillPath, registryMeta) {
+  const bareName = name;
+  const issues = [];
+  const warnings = [];
+  let packageDeclaresHosted = false;
+  let packageSkillSource;
+  const metadata = {
+    binCommands: [],
+    docFiles: []
+  };
+  if (!existsSync2(skillPath)) {
+    add(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
+    return {
+      name: bareName,
+      path: skillPath,
+      valid: false,
+      issues: sortMessages(issues),
+      warnings: sortMessages(warnings),
+      metadata
+    };
+  }
+  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 readdirSync(skillPath).sort()) {
+    const entryPath = join2(skillPath, entry);
+    if (RESERVED_SKILL_ENTRIES.has(entry)) {
+      add(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
+    }
+    if (lstatSync(entryPath).isSymbolicLink()) {
+      add(issues, "skill.symlink_forbidden", `Symlink '${entry}' is not allowed in skill packages`);
+    }
+    if (!KNOWN_TOP_LEVEL_ENTRIES.has(entry)) {
+      add(warnings, "skill.file_unrecognized", `Unrecognized top-level skill entry '${entry}'`);
+    }
+  }
+  for (const docFile of DOC_FILES) {
+    if (existsSync2(join2(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"));
+    if (!frontmatter) {
+      add(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
+    } else {
+      metadata.skillMdFrontmatter = frontmatter;
+      metadata.provenance = {
+        ...metadata.provenance ?? { directoryName: bareName },
+        ...frontmatter.source ? { frontmatterSource: frontmatter.source } : {},
+        ...registryMeta?.source ? { registrySource: registryMeta.source } : {}
+      };
+      if (!frontmatter.name)
+        add(issues, "skill.frontmatter_name_missing", "SKILL.md frontmatter missing name");
+      if (!frontmatter.description)
+        add(issues, "skill.frontmatter_description_missing", "SKILL.md frontmatter missing description");
+      if (frontmatter.name && frontmatter.name !== bareName) {
+        add(issues, "skill.frontmatter_name_mismatch", `SKILL.md name '${frontmatter.name}' does not match '${bareName}'`);
+      }
+      if (frontmatter.source && !VALID_PROVENANCE_SOURCES.has(frontmatter.source)) {
+        add(issues, "skill.frontmatter_source_invalid", `SKILL.md source '${frontmatter.source}' is not one of: ${[...VALID_PROVENANCE_SOURCES].join(", ")}`);
+      }
+      if (frontmatter.tags && frontmatter.tags.some((tag) => !tag.trim())) {
+        add(issues, "skill.frontmatter_tags_invalid", "SKILL.md tags must be non-empty strings");
+      }
+      if (registryMeta?.description && frontmatter.description && frontmatter.description.length < 8) {
+        add(warnings, "skill.frontmatter_description_short", "SKILL.md description is very short");
+      }
+      if (registryMeta?.category && frontmatter.category && frontmatter.category !== registryMeta.category) {
+        add(warnings, "skill.frontmatter_category_mismatch", `SKILL.md category '${frontmatter.category}' does not match registry category '${registryMeta.category}'`);
+      }
+    }
+  } else {
+    add(warnings, "skill.skill_md_missing", "Missing SKILL.md; registry docs may need generated agent-facing instructions");
+  }
+  const pkgPath = join2(skillPath, "package.json");
+  if (!existsSync2(pkgPath)) {
+    add(issues, "package.missing", "Missing package.json");
+  } else {
+    try {
+      const pkg = readJsonFile(pkgPath);
+      const packageRecord = asRecord(pkg);
+      if (!packageRecord) {
+        add(issues, "package.invalid_shape", "package.json must be an object");
+      } else {
+        packageDeclaresHosted = isHostedPackageMetadata(pkg);
+        const skillsRecord = asRecord(pkg.skills);
+        if (skillsRecord && typeof skillsRecord.source === "string") {
+          packageSkillSource = skillsRecord.source;
+        }
+        const hostedMetadata2 = isHostedMetadataSkill(bareName, metadata.skillMdFrontmatter, registryMeta, packageDeclaresHosted);
+        metadata.runtime = hostedMetadata2 ? "hosted" : "local";
+        if (typeof pkg.name === "string") {
+          metadata.packageName = pkg.name;
+          if (pkg.name !== bareName) {
+            add(issues, "package.name_mismatch", `package.json name '${pkg.name}' does not match '${bareName}'`);
+          }
+        } else {
+          add(issues, "package.name_missing", "package.json missing string name");
+        }
+        if (typeof pkg.version === "string" && pkg.version.trim())
+          metadata.version = pkg.version;
+        else
+          add(warnings, "package.version_missing", "package.json missing string version");
+        metadata.provenance = {
+          ...metadata.provenance ?? { directoryName: bareName },
+          ...typeof pkg.name === "string" ? { packageName: pkg.name } : {},
+          ...typeof pkg.version === "string" && pkg.version.trim() ? { packageVersion: pkg.version } : {},
+          ...registryMeta?.source ? { registrySource: registryMeta.source } : {},
+          ...packageSkillSource ? { packageSkillSource } : {}
+        };
+        const binRecord = asRecord(pkg.bin);
+        if (!binRecord || Object.keys(binRecord).length === 0) {
+          if (!hostedMetadata2) {
+            add(issues, "package.bin_missing", "package.json missing non-empty bin object");
+          }
+        } else {
+          if (hostedMetadata2) {
+            add(issues, "package.hosted_bin_forbidden", "Hosted metadata packages must not expose a local bin entry");
+          }
+          for (const [command, target] of Object.entries(binRecord)) {
+            if (!VALID_BIN_COMMAND.test(command)) {
+              add(issues, "package.bin_command_invalid", `package.json bin command '${command}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
+            }
+            if (typeof target !== "string" || !target.trim()) {
+              add(issues, "package.bin_invalid", `package.json bin '${command}' must point to a file`);
+              continue;
+            }
+            metadata.binCommands.push(command);
+            if (!isSafeRelativePath(target)) {
+              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)) {
+              add(warnings, "package.bin_target_missing", `package.json bin '${command}' target '${target}' is not present before build`);
+            } else if (statSync(targetPath).isDirectory()) {
+              add(issues, "package.bin_target_directory", `package.json bin '${command}' target '${target}' must point to a file, not a directory`);
+            }
+          }
+        }
+      }
+    } catch (error48) {
+      add(issues, "package.invalid_json", `package.json is invalid JSON: ${error48.message}`);
+    }
+  }
+  const hostedMetadata = isHostedMetadataSkill(bareName, metadata.skillMdFrontmatter, registryMeta, packageDeclaresHosted);
+  metadata.runtime = hostedMetadata ? "hosted" : "local";
+  const srcDir = join2(skillPath, "src");
+  if (hostedMetadata) {
+    if (existsSync2(srcDir)) {
+      add(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
+    }
+  } else if (!existsSync2(srcDir)) {
+    add(issues, "skill.src_missing", "Missing src/ directory");
+  } else if (!existsSync2(join2(srcDir, "index.ts")) && !existsSync2(join2(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 = statSync(indexPath).size;
+    if (size < 50)
+      add(warnings, "skill.src_index_minimal", `Source entry point is very small (${size}B)`);
+  }
+  return {
+    name: bareName,
+    path: skillPath,
+    valid: issues.length === 0,
+    issues: sortMessages(issues),
+    warnings: sortMessages(warnings),
+    metadata
+  };
+}
+
+// src/lib/portable-skills.ts
+var PORTABLE_SKILL_STANDARD = "hasna.skill.v1";
+var PORTABLE_SKILL_SCHEMA = "https://hasna.dev/schemas/skill.v1.json";
+var PORTABLE_SKILL_DEFAULT_VERSION = "0.1.0";
+var DATA_DIR_NON_SKILL_ENTRIES = new Set([
+  "auth.json",
+  "config.json",
+  "custom",
+  "skills.db"
+]);
+var COPY_EXCLUDES = new Set([
+  ".git",
+  ".DS_Store",
+  "node_modules",
+  "dist",
+  "build",
+  ".turbo"
+]);
+var DEFAULT_INPUTS = [
+  {
+    name: "args",
+    type: "string[]",
+    required: false,
+    description: "Arguments passed after `skills run <name>`."
+  }
+];
+function normalizePortableSkillName(name) {
+  const normalized = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+  if (!normalized || !/^[a-z0-9][a-z0-9._-]*$/.test(normalized)) {
+    throw new Error(`Invalid skill name '${name}'. Use letters, numbers, dots, underscores, or hyphens.`);
+  }
+  return normalized;
+}
+function getPortableSkillsRoot(options = {}) {
+  if (options.rootDir)
+    return options.rootDir;
+  if (process.env["HASNA_SKILLS_DIR"])
+    return process.env["HASNA_SKILLS_DIR"];
+  if (options.homeDir)
+    return join3(options.homeDir, ".hasna", "skills");
+  return getDataDir();
+}
+function getPortableSkillPath(name, options = {}) {
+  return join3(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+}
+function findPortableSkill(name, options = {}) {
+  let normalized;
+  try {
+    normalized = normalizePortableSkillName(name);
+  } catch {
+    return null;
+  }
+  const path = getPortableSkillPath(normalized, options);
+  if (!existsSync3(path) || !statSync2(path).isDirectory())
+    return null;
+  try {
+    return summarizePortableSkill(path, normalized);
+  } catch {
+    return null;
+  }
+}
+function listPortableSkills(options = {}) {
+  const root = getPortableSkillsRoot(options);
+  if (!existsSync3(root))
+    return [];
+  const skills = [];
+  for (const entry of readdirSync2(root).sort()) {
+    if (entry.startsWith(".") || DATA_DIR_NON_SKILL_ENTRIES.has(entry))
+      continue;
+    const path = join3(root, entry);
+    if (!safeIsDirectory(path))
+      continue;
+    try {
+      skills.push(summarizePortableSkill(path, entry));
+    } catch {
+      continue;
+    }
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+function listPortableSkillMetas(options = {}) {
+  return listPortableSkills(options).map((skill) => ({
+    name: skill.name,
+    displayName: skill.displayName,
+    description: skill.description,
+    category: readPortableSkillManifest(skill.path).category || "Development Tools",
+    tags: readPortableSkillManifest(skill.path).tags || ["custom"],
+    version: skill.version,
+    source: "custom",
+    pricing: {
+      tier: "free",
+      billingUnit: "run",
+      costCents: 0,
+      formattedCost: "free",
+      estimated: false,
+      quoteDependsOnInput: false,
+      quoteRequired: false,
+      description: "Local portable skill"
+    }
+  }));
+}
+function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
+  const skillJsonPath = join3(skillPath, "skill.json");
+  const skillMdPath = join3(skillPath, "SKILL.md");
+  const pkgPath = join3(skillPath, "package.json");
+  const jsonManifest = existsSync3(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
+  const frontmatter = existsSync3(skillMdPath) ? parseSkillFrontmatter(readFileSync3(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const pkg = existsSync3(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;
+  const commands = parseManifestCommands(jsonManifest) ?? inferPackageCommands(pkg, name) ?? [];
+  return {
+    $schema: stringField(jsonManifest, "$schema") ?? PORTABLE_SKILL_SCHEMA,
+    standard: stringField(jsonManifest, "standard") ?? PORTABLE_SKILL_STANDARD,
+    name,
+    description,
+    version: version2,
+    displayName: stringField(jsonManifest, "displayName") ?? frontmatter?.displayName ?? displayName(name),
+    category: stringField(jsonManifest, "category") ?? frontmatter?.category ?? "Development Tools",
+    tags: stringArrayField(jsonManifest, "tags") ?? frontmatter?.tags ?? ["custom"],
+    inputs: parseManifestInputs(jsonManifest) ?? DEFAULT_INPUTS,
+    commands
+  };
+}
+function scaffoldPortableSkill(name, options = {}) {
+  const skillName = normalizePortableSkillName(name);
+  const root = getPortableSkillsRoot(options);
+  const skillPath = join3(root, skillName);
+  if (existsSync3(skillPath)) {
+    if (!options.overwrite)
+      throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
+    rmSync(skillPath, { recursive: true, force: true });
+  }
+  const manifest = createPortableManifest(skillName, {
+    description: options.description ?? `${displayName(skillName)} skill`
+  });
+  writePortableSkillTemplate(skillPath, manifest);
+  return { name: skillName, path: skillPath, manifest, created: true };
+}
+function portPortableSkill(sourcePath, options = {}) {
+  const absoluteSource = normalize2(sourcePath);
+  if (!existsSync3(absoluteSource) || !statSync2(absoluteSource).isDirectory()) {
+    throw new Error(`Skill source directory not found: ${sourcePath}`);
+  }
+  const inferred = readPortableSkillManifest(absoluteSource, basename(absoluteSource));
+  const skillName = normalizePortableSkillName(options.name ?? inferred.name);
+  const root = getPortableSkillsRoot(options);
+  const destination = join3(root, skillName);
+  if (existsSync3(destination)) {
+    if (!options.overwrite)
+      throw new Error(`Skill '${skillName}' already exists at ${destination}`);
+    rmSync(destination, { recursive: true, force: true });
+  }
+  mkdirSync2(dirname2(destination), { recursive: true });
+  copySkillDirectory(absoluteSource, destination);
+  const manifest = ensurePortableSkillFiles(destination, {
+    ...inferred,
+    name: skillName,
+    displayName: inferred.displayName ?? displayName(skillName)
+  });
+  return { name: skillName, path: destination, manifest, created: true };
+}
+function validatePortableSkillDirectory(name, skillPath) {
+  const normalizedName = normalizePortableSkillName(name);
+  const base = validateSkillDirectory(normalizedName, skillPath);
+  const issues = [...base.issues];
+  const warnings = [...base.warnings];
+  let manifest;
+  if (existsSync3(skillPath)) {
+    const skillJsonPath = join3(skillPath, "skill.json");
+    const skillMdPath = join3(skillPath, "SKILL.md");
+    if (!existsSync3(skillJsonPath) && !existsSync3(skillMdPath)) {
+      add2(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
+    }
+    try {
+      manifest = readPortableSkillManifest(skillPath, normalizedName);
+      if (manifest.name !== normalizedName) {
+        add2(issues, "portable.name_mismatch", `Portable manifest name '${manifest.name}' does not match '${normalizedName}'`);
+      }
+      if (manifest.standard !== PORTABLE_SKILL_STANDARD) {
+        add2(issues, "portable.standard_invalid", `Portable manifest standard must be '${PORTABLE_SKILL_STANDARD}'`);
+      }
+      if (!manifest.description.trim()) {
+        add2(issues, "portable.description_missing", "Portable manifest missing description");
+      }
+      if (!manifest.version.trim()) {
+        add2(issues, "portable.version_missing", "Portable manifest missing version");
+      }
+      if (!Array.isArray(manifest.inputs) || manifest.inputs.length === 0) {
+        add2(issues, "portable.inputs_missing", "Portable manifest must declare inputs");
+      }
+      if (!Array.isArray(manifest.commands) || manifest.commands.length === 0) {
+        add2(issues, "portable.commands_missing", "Portable manifest must declare at least one command");
+      } else {
+        for (const command of manifest.commands) {
+          if (!/^[a-z0-9][a-z0-9._-]*$/.test(command.name)) {
+            add2(issues, "portable.command_name_invalid", `Command '${command.name}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
+          }
+          if (!command.entry && !command.command) {
+            add2(issues, "portable.command_target_missing", `Command '${command.name}' must declare entry or command`);
+            continue;
+          }
+          if (command.entry) {
+            if (!isSafeRelativePath2(command.entry)) {
+              add2(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
+              continue;
+            }
+            const entryPath = join3(skillPath, command.entry);
+            if (!existsSync3(entryPath))
+              add2(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
+            else if (statSync2(entryPath).isDirectory())
+              add2(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
+          }
+        }
+      }
+    } catch (error48) {
+      add2(issues, "portable.manifest_invalid", error48.message);
+    }
+    if (!existsSync3(join3(skillPath, "AGENTS.md"))) {
+      add2(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
+    }
+  }
+  const sortedIssues = sortMessages2(issues);
+  const sortedWarnings = sortMessages2(warnings);
+  return {
+    ...base,
+    valid: sortedIssues.length === 0,
+    issues: sortedIssues,
+    warnings: sortedWarnings,
+    metadata: {
+      ...base.metadata,
+      portableManifest: manifest
+    }
+  };
+}
+function summarizePortableSkill(skillPath, fallbackName) {
+  const manifest = readPortableSkillManifest(skillPath, fallbackName);
+  return {
+    name: manifest.name,
+    displayName: manifest.displayName ?? displayName(manifest.name),
+    description: manifest.description,
+    version: manifest.version,
+    path: skillPath,
+    commands: manifest.commands,
+    source: "custom",
+    standard: manifest.standard
+  };
+}
+function createPortableManifest(name, options) {
+  return {
+    $schema: PORTABLE_SKILL_SCHEMA,
+    standard: PORTABLE_SKILL_STANDARD,
+    name,
+    description: options.description,
+    version: PORTABLE_SKILL_DEFAULT_VERSION,
+    displayName: displayName(name),
+    category: "Development Tools",
+    tags: ["custom", name],
+    inputs: DEFAULT_INPUTS,
+    commands: [{
+      name,
+      description: `Run ${displayName(name)}.`,
+      entry: "src/index.ts",
+      args: ["...args"]
+    }]
+  };
+}
+function writePortableSkillTemplate(skillPath, manifest) {
+  mkdirSync2(join3(skillPath, "src"), { recursive: true });
+  writeFileSync2(join3(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync2(join3(skillPath, "skill.json"), renderSkillJson(manifest));
+  writeFileSync2(join3(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync2(join3(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync2(join3(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync2(join3(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+}
+function ensurePortableSkillFiles(skillPath, manifest) {
+  let next = manifest;
+  if (!next.commands.length) {
+    next = {
+      ...next,
+      commands: [{
+        name: next.name,
+        description: `Run ${displayName(next.name)}.`,
+        entry: "src/index.ts",
+        args: ["...args"]
+      }]
+    };
+  }
+  if (!next.inputs.length)
+    next = { ...next, inputs: DEFAULT_INPUTS };
+  next = {
+    ...next,
+    standard: PORTABLE_SKILL_STANDARD,
+    $schema: next.$schema ?? PORTABLE_SKILL_SCHEMA,
+    displayName: next.displayName ?? displayName(next.name),
+    category: next.category ?? "Development Tools",
+    tags: next.tags?.length ? next.tags : ["custom", next.name]
+  };
+  const entry = next.commands[0]?.entry ?? "src/index.ts";
+  if (entry && !existsSync3(join3(skillPath, entry))) {
+    mkdirSync2(dirname2(join3(skillPath, entry)), { recursive: true });
+    writeFileSync2(join3(skillPath, entry), renderEntrypoint(next));
+  }
+  if (!existsSync3(join3(skillPath, "SKILL.md")))
+    writeFileSync2(join3(skillPath, "SKILL.md"), renderSkillMd(next));
+  else
+    writeFileSync2(join3(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync3(join3(skillPath, "SKILL.md"), "utf-8"), next));
+  if (!existsSync3(join3(skillPath, "skill.json")))
+    writeFileSync2(join3(skillPath, "skill.json"), renderSkillJson(next));
+  if (!existsSync3(join3(skillPath, "AGENTS.md")))
+    writeFileSync2(join3(skillPath, "AGENTS.md"), renderAgentsMd(next));
+  if (!existsSync3(join3(skillPath, "package.json")))
+    writeFileSync2(join3(skillPath, "package.json"), renderPackageJson(next));
+  if (!existsSync3(join3(skillPath, "tsconfig.json")))
+    writeFileSync2(join3(skillPath, "tsconfig.json"), renderTsconfig());
+  return readPortableSkillManifest(skillPath, next.name);
+}
+function copySkillDirectory(source, destination) {
+  mkdirSync2(destination, { recursive: true });
+  cpSync(source, destination, {
+    recursive: true,
+    filter: (src) => {
+      const rel = relative(source, src);
+      if (!rel)
+        return true;
+      const first = rel.split(/[\\/]/)[0];
+      if (COPY_EXCLUDES.has(first))
+        return false;
+      if (lstatSync2(src).isSymbolicLink())
+        return false;
+      return true;
+    }
+  });
+}
+function renderSkillMd(manifest) {
+  const tags = manifest.tags?.length ? `tags:
+${manifest.tags.map((tag) => `  - ${tag}`).join(`
+`)}
+` : "";
+  return `---
+name: ${manifest.name}
+description: ${manifest.description}
+version: ${manifest.version}
+source: custom
+category: ${manifest.category ?? "Development Tools"}
+${tags}---
+
+# ${manifest.displayName ?? displayName(manifest.name)}
+
+${manifest.description}
+
+## Usage
+
+\`\`\`bash
+skills run ${manifest.name} --help
+\`\`\`
+`;
+}
+function renderSkillJson(manifest) {
+  return `${JSON.stringify({
+    $schema: manifest.$schema ?? PORTABLE_SKILL_SCHEMA,
+    standard: PORTABLE_SKILL_STANDARD,
+    name: manifest.name,
+    description: manifest.description,
+    version: manifest.version,
+    displayName: manifest.displayName ?? displayName(manifest.name),
+    category: manifest.category ?? "Development Tools",
+    tags: manifest.tags ?? ["custom", manifest.name],
+    inputs: manifest.inputs,
+    commands: manifest.commands
+  }, null, 2)}
+`;
+}
+function renderPackageJson(manifest) {
+  const first = manifest.commands[0] ?? { name: manifest.name, entry: "src/index.ts" };
+  return `${JSON.stringify({
+    name: manifest.name,
+    version: manifest.version,
+    description: manifest.description,
+    type: "module",
+    bin: { [first.name]: first.entry ?? "src/index.ts" },
+    scripts: { dev: `bun run ${first.entry ?? "src/index.ts"}` },
+    dependencies: {}
+  }, null, 2)}
+`;
+}
+function renderTsconfig() {
+  return `${JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      outDir: "dist"
+    },
+    include: ["src/**/*.ts"]
+  }, null, 2)}
+`;
+}
+function renderEntrypoint(manifest) {
+  return `#!/usr/bin/env bun
+
+const args = process.argv.slice(2);
+
+if (args.includes("--help") || args.includes("-h")) {
+  console.log("${manifest.name}");
+  console.log("");
+  console.log("${escapeJsString(manifest.description)}");
+  console.log("");
+  console.log("Usage: skills run ${manifest.name} [args...]");
+  process.exit(0);
+}
+
+console.log(JSON.stringify({
+  skill: "${manifest.name}",
+  args,
+}, null, 2));
+`;
+}
+function renderAgentsMd(manifest) {
+  const command = manifest.commands[0];
+  const entry = command?.entry ?? "src/index.ts";
+  return `# Agent Build Instructions: ${manifest.name}
+
+This folder is a portable @hasna/skills skill. Build it in place and keep it valid against the portable skill standard.
+
+## Contract
+
+- Skill name: \`${manifest.name}\`
+- Description: ${manifest.description}
+- Manifest files: \`SKILL.md\` frontmatter and \`skill.json\`
+- Runtime entrypoint: \`${entry}\`
+- User command: \`skills run ${manifest.name} [args]\`
+
+## Build Rules
+
+1. Put executable logic in \`${entry}\` or files imported by it.
+2. Keep \`skill.json\` updated when inputs, commands, or version change.
+3. Keep \`SKILL.md\` concise and compatible with Codewith-style skill frontmatter: \`name\`, \`description\`, \`version\`, optional \`category\`, and optional \`tags\`.
+4. Add tests under \`tests/\` when behavior is non-trivial, then run \`bun test\` from this folder if tests exist.
+5. Verify with \`skills validate ${manifest.name}\` and smoke-test with \`skills run ${manifest.name} --help\`.
+6. Do not commit secrets, generated credentials, \`.env\`, \`node_modules\`, or build output.
+`;
+}
+function ensureSkillMdFrontmatter(content, manifest) {
+  const body = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").trimStart();
+  const generated = renderSkillMd(manifest);
+  const frontmatter = generated.match(/^---\r?\n[\s\S]*?\r?\n---/)?.[0] ?? "";
+  return `${frontmatter}
+
+${body || `# ${manifest.displayName ?? displayName(manifest.name)}
+
+${manifest.description}
+`}`;
+}
+function parseManifestCommands(value) {
+  const raw = value?.commands;
+  if (!Array.isArray(raw))
+    return;
+  const commands = raw.map((item) => {
+    if (!isRecord(item))
+      return null;
+    const name = stringValue(item.name);
+    if (!name)
+      return null;
+    return {
+      name: normalizePortableSkillName(name),
+      ...stringValue(item.description) ? { description: stringValue(item.description) } : {},
+      ...stringValue(item.entry) ? { entry: stringValue(item.entry) } : {},
+      ...stringValue(item.command) ? { command: stringValue(item.command) } : {},
+      ...Array.isArray(item.args) ? { args: item.args.filter((arg) => typeof arg === "string") } : {}
+    };
+  }).filter((item) => item !== null);
+  return commands.length ? commands : undefined;
+}
+function parseManifestInputs(value) {
+  const raw = value?.inputs;
+  if (!Array.isArray(raw))
+    return;
+  const inputs = raw.map((item) => {
+    if (!isRecord(item))
+      return null;
+    const name = stringValue(item.name);
+    const type = stringValue(item.type);
+    if (!name || !type)
+      return null;
+    return {
+      name,
+      type,
+      ...typeof item.required === "boolean" ? { required: item.required } : {},
+      ...stringValue(item.description) ? { description: stringValue(item.description) } : {}
+    };
+  }).filter((item) => item !== null);
+  return inputs.length ? inputs : undefined;
+}
+function inferPackageCommands(pkg, fallbackName) {
+  if (!pkg)
+    return;
+  if (isRecord(pkg.bin)) {
+    const commands = Object.entries(pkg.bin).filter((entry) => typeof entry[1] === "string" && entry[1].trim().length > 0).map(([name, entry]) => ({
+      name: normalizePortableSkillName(name),
+      entry: entry.replace(/^\.\//, ""),
+      description: `Run ${displayName(fallbackName)}.`
+    }));
+    if (commands.length)
+      return commands;
+  }
+  const scripts = isRecord(pkg.scripts) ? pkg.scripts : undefined;
+  const dev = stringValue(scripts?.dev);
+  const match = dev?.match(/(?:bun\s+run\s+|bun\s+)([^ ]+)/);
+  if (match?.[1]) {
+    return [{ name: fallbackName, entry: match[1].replace(/^\.\//, ""), description: `Run ${displayName(fallbackName)}.` }];
+  }
+  return;
+}
+function readJsonObject(path) {
+  const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+  if (!isRecord(parsed))
+    throw new Error(`${basename(path)} must contain a JSON object`);
+  return parsed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(value, key) {
+  return stringValue(value?.[key]);
+}
+function stringArrayField(value, key) {
+  const raw = value?.[key];
+  if (!Array.isArray(raw))
+    return;
+  const strings = raw.filter((item) => typeof item === "string" && item.trim().length > 0);
+  return strings.length ? strings : undefined;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function displayName(name) {
+  return name.replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function safeIsDirectory(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isSafeRelativePath2(value) {
+  if (!value.trim() || isAbsolute2(value))
+    return false;
+  const normalized = normalize2(value).replace(/\\/g, "/");
+  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
+}
+function add2(target, code, message) {
+  target.push({ code, message });
+}
+function sortMessages2(messages) {
+  return [...messages].sort((a, b) => a.code.localeCompare(b.code) || a.message.localeCompare(b.message));
+}
+function escapeJsString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\r?\n/g, " ");
+}
+
+// src/lib/registry.ts
+init_skill_aliases();
+
+// src/lib/registry-data/development-tools.ts
+var DEVELOPMENT_TOOLS_SKILLS = [
+  {
+    name: "api-test-suite",
+    displayName: "API Test Suite",
+    description: "Generate and run API test suites with comprehensive endpoint coverage",
+    category: "Development Tools",
+    tags: ["api", "testing", "automation", "qa"]
+  },
+  {
+    name: "apidocs",
+    displayName: "API Docs",
+    description: "Agentic web crawler for API documentation indexing and semantic search",
+    category: "Development Tools",
+    tags: ["api", "documentation", "search", "indexing"]
+  },
+  {
+    name: "api-docs-portal",
+    displayName: "API Docs Portal",
+    description: "Generate premium static API documentation portals from OpenAPI specs, route lists, and endpoint examples",
+    category: "Development Tools",
+    tags: ["api", "documentation", "openapi", "portal", "premium", "remote"]
+  },
+  {
+    name: "sdk-generator",
+    displayName: "SDK Generator",
+    description: "Generate hosted TypeScript SDK scaffolds with client code, types, package files, tests, README, examples, and API summaries",
+    category: "Development Tools",
+    tags: ["sdk", "api", "typescript", "developer-tools", "premium", "remote"]
+  },
+  {
+    name: "repo-onboarding-report",
+    displayName: "Repo Onboarding Report",
+    description: "Generate hosted repository onboarding packages with architecture maps, setup guides, risk registers, and first-week plans",
+    category: "Development Tools",
+    tags: ["repository", "onboarding", "architecture", "developer-tools", "premium", "remote"]
+  },
+  {
+    name: "codefix",
+    displayName: "Code Fix",
+    description: "Code quality CLI for auto-linting, formatting, fixing, and style enforcement",
+    category: "Development Tools",
+    tags: ["code", "linting", "formatting", "quality"]
+  },
+  {
+    name: "commitpush",
+    displayName: "Commit Push",
+    description: "Create logical commits from repo changes and push directly to the main branch",
+    category: "Development Tools",
+    tags: ["git", "commit", "push", "automation"]
+  },
+  {
+    name: "commitpushpr",
+    displayName: "Commit Push PR",
+    description: "Create logical commits, push a feature branch, and open a GitHub pull request",
+    category: "Development Tools",
+    tags: ["git", "commit", "pull-request", "github", "automation"],
+    dependencies: ["commitpush"]
+  },
+  {
+    name: "consolelog",
+    displayName: "Console Log",
+    description: "Monitor console logs from web applications using Playwright headless browser",
+    category: "Development Tools",
+    tags: ["console", "monitoring", "debugging", "logs"]
+  },
+  {
+    name: "database-explorer",
+    displayName: "Database Explorer",
+    description: "Explore and query databases with an interactive interface",
+    category: "Development Tools",
+    tags: ["database", "explorer", "sql", "query"]
+  },
+  {
+    name: "deploy",
+    displayName: "Deploy",
+    description: "Deployment CLI for managing EC2 deployments with automated health checks",
+    category: "Development Tools",
+    tags: ["deployment", "ec2", "aws", "ci-cd"]
+  },
+  {
+    name: "diff-viewer",
+    displayName: "Diff Viewer",
+    description: "View and analyze file differences with visual diff representation",
+    category: "Development Tools",
+    tags: ["diff", "comparison", "files", "code-review"]
+  },
   {
     name: "generate-api-client",
     displayName: "Generate API Client",
@@ -31446,20 +32338,20 @@ function parseSkillMdFrontmatter(content) {
   return Object.keys(result).length > 0 ? result : null;
 }
 function discoverSkillsInDir(dir) {
-  if (!existsSync(dir))
+  if (!existsSync4(dir))
     return [];
   const result = [];
   try {
-    const entries = readdirSync(dir, { withFileTypes: true });
+    const entries = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join(dir, entry.name, "SKILL.md");
-      if (!existsSync(skillMdPath))
+      const skillMdPath = join4(dir, entry.name, "SKILL.md");
+      if (!existsSync4(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync(skillMdPath, "utf-8");
+        content = readFileSync4(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -31488,7 +32380,10 @@ function loadRegistry(cwd) {
     return registryCache;
   }
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
-  const globalCustom = discoverSkillsInDir(join(homedir(), ".hasna", "skills", "custom"));
+  const dataDir = getDataDir();
+  const portableCustom = listPortableSkillMetas({ rootDir: dataDir });
+  const legacyCustom = discoverSkillsInDir(join4(dataDir, "custom"));
+  const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   const customNames = new Set(globalCustom.map((s) => s.name));
   const filtered = official.filter((s) => !customNames.has(s.name));
   registryCache = [...filtered, ...globalCustom];
@@ -31498,11 +32393,17 @@ function loadRegistry(cwd) {
 function loadBasicRegistry(cwd) {
   const registry2 = loadRegistry(cwd);
   const byName = new Map(registry2.map((skill) => [skill.name, skill]));
-  return BASIC_SKILL_NAMES.map((name) => byName.get(name)).filter((skill) => skill !== undefined);
+  const basic = BASIC_SKILL_NAMES.map((name) => byName.get(name)).filter((skill) => skill !== undefined);
+  const custom2 = registry2.filter((skill) => skill.source === "custom" && !BASIC_SKILL_NAMES.includes(skill.name));
+  return [...basic, ...custom2];
 }
 function loadRegistryProfile(profile = "basic", cwd) {
   return profile === "all" ? loadRegistry(cwd) : loadBasicRegistry(cwd);
 }
+function clearRegistryCache() {
+  registryCache = null;
+  registryCacheTime = 0;
+}
 function getSkillsByCategory(category) {
   return loadRegistry().filter((s) => s.category === category);
 }
@@ -31511,10 +32412,16 @@ function getSkill(name) {
   const slug = normalizeSkillSlug(name);
   return registry2.find((s) => s.name === slug) ?? registry2.find((s) => s.name === resolveSkillAlias(slug));
 }
+function mergeCustomSkills(skills) {
+  const byName = new Map;
+  for (const skill of skills)
+    byName.set(skill.name, skill);
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
 
 // src/lib/installer.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname, join as join3 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
 import { homedir as homedir2 } from "os";
 import { fileURLToPath } from "url";
 
@@ -31524,26 +32431,27 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/installer.ts
+init_config();
 init_skill_aliases();
 
 // src/lib/project-state.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
 var SKILLS_PROJECT_DIR = ".skills";
 var PROJECT_CONFIG_FILE = "project.json";
 var DEFAULT_EXPORT_DIR = ".skills/exports";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join2(targetDir, SKILLS_PROJECT_DIR);
+  return join5(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join2(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join5(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync2(path))
+  if (!existsSync5(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync2(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync5(path, "utf-8")));
   } catch {
     return null;
   }
@@ -31564,9 +32472,9 @@ function ensureProjectConfig(targetDir = process.cwd()) {
 }
 function saveProjectConfig(config2, targetDir = process.cwd()) {
   const dir = getProjectStateDir(targetDir);
-  mkdirSync(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   const normalized = normalizeProjectConfig({ ...config2, updatedAt: new Date().toISOString() });
-  writeFileSync(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
+  writeFileSync3(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
 `);
 }
 function pinProjectSkill(name, details = {}, targetDir = process.cwd()) {
@@ -31638,21 +32546,27 @@ function isPinSource(value) {
 }
 
 // src/lib/installer.ts
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var __dirname2 = dirname3(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join3(dir, "skills");
-    if (existsSync3(candidate) && !dir.includes(".skills"))
+    const candidate = join6(dir, "skills");
+    if (existsSync6(candidate) && !dir.includes(".skills"))
       return candidate;
-    dir = dirname(dir);
+    dir = dirname3(dir);
   }
-  return join3(__dirname2, "..", "skills");
+  return join6(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
-  return join3(SKILLS_DIR, skillName);
+  const portable = findPortableSkill(skillName);
+  if (portable)
+    return portable.path;
+  const legacyCustomPath = join6(getDataDir(), "custom", skillName);
+  if (existsSync6(legacyCustomPath))
+    return legacyCustomPath;
+  return join6(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
@@ -31661,7 +32575,7 @@ function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync3(getSkillPath(name))) {
+  if (!existsSync6(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found`, mode: "pin" };
   }
   const existing = new Set(listPinnedSkills(targetDir));
@@ -31710,11 +32624,11 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join3(base, ".pi", "skills") : join3(homedir2(), ".pi", "agent", "skills");
+      return scope === "project" ? join6(base, ".pi", "skills") : join6(homedir2(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join3(base, ".opencode", "skills") : join3(homedir2(), ".config", "opencode", "skills");
+      return scope === "project" ? join6(base, ".opencode", "skills") : join6(homedir2(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join3(base, `.${agent}`, "skills") : join3(homedir2(), `.${agent}`, "skills");
+      return scope === "project" ? join6(base, `.${agent}`, "skills") : join6(homedir2(), `.${agent}`, "skills");
   }
 }
 function warnMissingDependencies(name, targetDir) {
@@ -31729,11 +32643,11 @@ function warnMissingDependencies(name, targetDir) {
   }
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join3(getSkillPath(name), "package.json");
-  if (!existsSync3(pkgPath))
+  const pkgPath = join6(getSkillPath(name), "package.json");
+  if (!existsSync6(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
@@ -31741,8 +32655,8 @@ function readBundledSkillVersion(name) {
 }
 
 // src/lib/skillinfo.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { join as join7 } from "path";
 init_pricing();
 var HOSTED_PROVIDER_ENV_PREFIXES = [
   "OPENAI_",
@@ -31762,12 +32676,12 @@ var HOSTED_PROVIDER_ENV_PREFIXES = [
 ];
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync4(skillPath))
+  if (!existsSync7(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join4(skillPath, "SKILL.md")),
-    readme: readIfExists(join4(skillPath, "README.md")),
-    claudeMd: readIfExists(join4(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join7(skillPath, "SKILL.md")),
+    readme: readIfExists(join7(skillPath, "README.md")),
+    claudeMd: readIfExists(join7(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -31778,11 +32692,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync4(skillPath))
+  if (!existsSync7(skillPath))
     return null;
   const texts = [];
   for (const file2 of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join4(skillPath, file2));
+    const content = readIfExists(join7(skillPath, file2));
     if (content)
       texts.push(content);
   }
@@ -31821,10 +32735,10 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join4(skillPath, "package.json");
-  if (existsSync4(pkgPath)) {
+  const pkgPath = join7(skillPath, "package.json");
+  if (existsSync7(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
     } catch {}
   }
@@ -31841,16 +32755,16 @@ function isHostedPremiumSkill(skillName, meta3) {
 async function runSkill(name, args, options = {}) {
   const canonicalName = getSkill(name)?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync4(skillPath)) {
+  if (!existsSync7(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
-  const pkgPath = join4(skillPath, "package.json");
-  if (!existsSync4(pkgPath)) {
+  const pkgPath = join7(skillPath, "package.json");
+  if (!existsSync7(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
   try {
-    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint = binValues[0];
@@ -31864,12 +32778,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join4(skillPath, entryPoint);
-  if (!existsSync4(entryPath)) {
+  const entryPath = join7(skillPath, entryPoint);
+  if (!existsSync7(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join4(skillPath, "node_modules");
-  if (!existsSync4(nodeModules)) {
+  const nodeModules = join7(skillPath, "node_modules");
+  if (!existsSync7(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -31896,15 +32810,15 @@ async function runSkill(name, args, options = {}) {
   return { exitCode };
 }
 function detectProjectSkills(cwd = process.cwd()) {
-  const pkgPath = join4(cwd, "package.json");
-  if (!existsSync4(pkgPath)) {
+  const pkgPath = join7(cwd, "package.json");
+  if (!existsSync7(pkgPath)) {
     const alwaysRecommend = ["implementation-plan", "write", "deepresearch"];
     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(readFileSync4(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
   } catch {
     const alwaysRecommend = ["implementation-plan", "write", "deepresearch"];
     const recommended2 = alwaysRecommend.map((name) => loadRegistry().find((s) => s.name === name)).filter((s) => s !== undefined);
@@ -31997,8 +32911,8 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync4(path)) {
-      return readFileSync4(path, "utf-8");
+    if (existsSync7(path)) {
+      return readFileSync7(path, "utf-8");
     }
   } catch {}
   return null;
@@ -32106,6 +33020,48 @@ var runOutputSchema = objectSchema({
   })
 }, [], "Skill run result.");
 var toolContracts = [
+  {
+    name: "scaffold_skill",
+    title: "Scaffold Skill",
+    description: "Create a portable skill folder under ~/.hasna/skills/<name> from the standard template.",
+    params: ["name", "description?", "overwrite?"],
+    category: "scaffolding",
+    sideEffects: "filesystem",
+    stable: true,
+    inputSchema: objectSchema({
+      name: skillNameInput,
+      description: stringSchema("Short description for the new skill."),
+      overwrite: { type: "boolean", default: false }
+    }, ["name"]),
+    outputSchema: objectSchema({
+      name: stringSchema("Normalized skill name."),
+      path: stringSchema("Created skill directory."),
+      created: { type: "boolean" },
+      manifest: objectSchema({}, [], "Portable skill manifest.", true)
+    }, ["name", "path", "created", "manifest"])
+  },
+  {
+    name: "port_skill",
+    title: "Port Skill",
+    description: "Import an existing skill folder into the portable ~/.hasna/skills/<name> standard.",
+    params: ["path", "name?", "overwrite?"],
+    category: "scaffolding",
+    sideEffects: "filesystem",
+    stable: true,
+    inputSchema: objectSchema({
+      path: stringSchema("Existing skill folder to import."),
+      name: skillNameInput,
+      overwrite: { type: "boolean", default: false }
+    }, ["path"]),
+    outputSchema: objectSchema({
+      name: stringSchema("Normalized skill name."),
+      path: stringSchema("Imported skill directory."),
+      created: { type: "boolean" },
+      valid: { type: "boolean" },
+      issues: arraySchema(validationMessageSchema),
+      warnings: arraySchema(validationMessageSchema)
+    }, ["name", "path", "created", "valid"])
+  },
   {
     name: "list_skills",
     title: "List Skills",
@@ -32929,25 +33885,25 @@ function registerDiscoveryTools(server) {
 }
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { join as join10 } from "path";
 
 // src/lib/run-state.ts
 import { createHash, randomBytes } from "crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { extname, join as join5, relative } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, readdirSync as readdirSync4, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
+import { extname, join as join8, 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 = join5(root, "runs", day, id);
-  const logsDir = join5(runDir, "logs");
-  const exportDir = join5(root, "exports", skillName, id);
-  mkdirSync2(logsDir, { recursive: true });
-  mkdirSync2(exportDir, { recursive: true });
-  mkdirSync2(join5(root, "tmp"), { recursive: true });
+  const runDir = join8(root, "runs", day, id);
+  const logsDir = join8(runDir, "logs");
+  const exportDir = join8(root, "exports", skillName, id);
+  mkdirSync4(logsDir, { recursive: true });
+  mkdirSync4(exportDir, { recursive: true });
+  mkdirSync4(join8(root, "tmp"), { recursive: true });
   const record3 = {
     id,
     skill: skillName,
@@ -32994,42 +33950,42 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync2(join5(context.logsDir, "stdout.log"), stdout);
-  writeFileSync2(join5(context.logsDir, "stderr.log"), stderr);
+  writeFileSync4(join8(context.logsDir, "stdout.log"), stdout);
+  writeFileSync4(join8(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join5(context.runDir, "events.ndjson");
-  const previous = existsSync5(path) ? readFileSync5(path, "utf-8") : "";
-  writeFileSync2(path, previous + line);
+  const path = join8(context.runDir, "events.ndjson");
+  const previous = existsSync8(path) ? readFileSync8(path, "utf-8") : "";
+  writeFileSync4(path, previous + line);
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join5(getProjectStateDir(targetDir), "runs");
-  if (!existsSync5(runsRoot))
+  const runsRoot = join8(getProjectStateDir(targetDir), "runs");
+  if (!existsSync8(runsRoot))
     return null;
-  for (const day of readdirSync2(runsRoot)) {
-    const record3 = readRunRecord(join5(runsRoot, day, runId));
+  for (const day of readdirSync4(runsRoot)) {
+    const record3 = readRunRecord(join8(runsRoot, day, runId));
     if (record3)
       return record3;
   }
   return null;
 }
 function writeRunRecord(context) {
-  writeFileSync2(join5(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync4(join8(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync2(join5(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync4(join8(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
-  if (!existsSync5(context.exportDir))
+  if (!existsSync8(context.exportDir))
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
-    const stat = statSync(path);
-    const bytes = readFileSync5(path);
+    const stat = statSync3(path);
+    const bytes = readFileSync8(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
@@ -33040,20 +33996,20 @@ function collectRunArtifacts(context) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join5(runDir, "run.json");
-  if (!existsSync5(path))
+  const path = join8(runDir, "run.json");
+  if (!existsSync8(path))
     return null;
   try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync2(dir)) {
-    const full = join5(dir, entry);
-    if (statSync(full).isDirectory())
+  for (const entry of readdirSync4(dir)) {
+    const full = join8(dir, entry);
+    if (statSync3(full).isDirectory())
       files.push(...walkFiles(full));
     else
       files.push(full);
@@ -33064,7 +34020,7 @@ function createRunId(now) {
   return `run_${now.getTime().toString(36)}_${randomBytes(4).toString("hex")}`;
 }
 function toProjectRelative(targetDir, path) {
-  const rel = relative(targetDir, path).split(/[\\/]/).join("/");
+  const rel = relative2(targetDir, path).split(/[\\/]/).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 function mimeForPath(path) {
@@ -33100,6 +34056,46 @@ function mimeForPath(path) {
 
 // src/mcp/operation-tools.ts
 function registerOperationTools(server) {
+  server.registerTool("scaffold_skill", {
+    title: "Scaffold Skill",
+    description: "Create a portable skill folder under ~/.hasna/skills/<name> with SKILL.md, skill.json, AGENTS.md, package.json, and src/index.ts.",
+    inputSchema: {
+      name: exports_external.string(),
+      description: exports_external.string().optional(),
+      overwrite: exports_external.boolean().optional()
+    }
+  }, async ({ name, description, overwrite }) => {
+    try {
+      const result = scaffoldPortableSkill(name, { description, overwrite });
+      clearRegistryCache();
+      cacheClear();
+      return mcpJson(result);
+    } catch (err) {
+      return mcpError("SCAFFOLD_FAILED", err.message);
+    }
+  });
+  server.registerTool("port_skill", {
+    title: "Port Skill",
+    description: "Import an existing skill folder into the portable ~/.hasna/skills/<name> standard and add missing standard files.",
+    inputSchema: {
+      path: exports_external.string(),
+      name: exports_external.string().optional(),
+      overwrite: exports_external.boolean().optional()
+    }
+  }, async ({ path, name, overwrite }) => {
+    try {
+      const result = portPortableSkill(path, { name, overwrite });
+      const validation = validatePortableSkillDirectory(result.name, result.path);
+      clearRegistryCache();
+      cacheClear();
+      return {
+        content: [{ type: "text", text: JSON.stringify({ ...result, valid: validation.valid, issues: validation.issues, warnings: validation.warnings }, null, 2) }],
+        isError: !validation.valid
+      };
+    } catch (err) {
+      return mcpError("PORT_FAILED", err.message);
+    }
+  });
   server.registerTool("pin_skill", {
     title: "Pin Skill",
     description: "Pin a skill to .skills/project.json. Agent skill-folder installs are disabled; use skills mcp --register.",
@@ -33492,13 +34488,13 @@ function registerOperationTools(server) {
     const agents = [];
     for (const agent of AGENT_TARGETS) {
       const agentSkillsPath = getAgentSkillsDir(agent, "global");
-      const exists = existsSync8(agentSkillsPath);
+      const exists = existsSync10(agentSkillsPath);
       let skillCount = 0;
       if (exists) {
         try {
-          skillCount = readdirSync3(agentSkillsPath).filter((f) => {
-            const full = join8(agentSkillsPath, f);
-            return !f.startsWith(".") && statSync2(full).isDirectory();
+          skillCount = readdirSync5(agentSkillsPath).filter((f) => {
+            const full = join10(agentSkillsPath, f);
+            return !f.startsWith(".") && statSync4(full).isDirectory();
           }).length;
         } catch {}
       }
@@ -33518,18 +34514,18 @@ function registerOperationTools(server) {
 }
 
 // src/lib/feedback.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname3, join as join9 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join11 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join9(homedir5(), ".hasna", "skills", "skills.db");
+  return join11(homedir4(), ".hasna", "skills", "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname3(dbPath);
-  if (!existsSync9(dir))
-    mkdirSync5(dir, { recursive: true });
+  const dir = dirname4(dbPath);
+  if (!existsSync11(dir))
+    mkdirSync6(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec([
@@ -33620,544 +34616,238 @@ function registerResourceMetaTools(server) {
     title: "Describe Tools",
     description: "Get machine-readable contracts for specific tools by name.",
     inputSchema: { names: exports_external.array(exports_external.string()) }
-  }, async ({ names }) => {
-    return mcpJson({ schemaVersion: 1, tools: describeMcpToolContracts(names) });
-  });
-  server.registerTool("get_mcp_contracts", {
-    title: "Get MCP Contracts",
-    description: "Return the machine-readable MCP tool and resource contract manifest.",
-    inputSchema: {
-      names: exports_external.array(exports_external.string()).optional(),
-      includeResources: exports_external.boolean().optional()
-    }
-  }, async ({ names, includeResources }) => {
-    return mcpJson(createMcpContractManifest({
-      names,
-      includeResources: includeResources ?? false
-    }));
-  });
-  const _agentReg = new Map;
-  server.tool("register_agent", "Register this agent session. Returns agent_id for use in heartbeat/set_focus.", { name: exports_external.string(), session_id: exports_external.string().optional() }, async (a) => {
-    const existing = [..._agentReg.values()].find((x) => x.name === a.name);
-    if (existing) {
-      existing.last_seen_at = new Date().toISOString();
-      return mcpJson({ ...existing, registered: false });
-    }
-    const id = Math.random().toString(36).slice(2, 10);
-    const ag = { id, name: a.name, last_seen_at: new Date().toISOString() };
-    _agentReg.set(id, ag);
-    return mcpJson({ ...ag, registered: true });
-  });
-  server.tool("heartbeat", "Update last_seen_at to signal agent is active.", { agent_id: exports_external.string() }, async (a) => {
-    const ag = _agentReg.get(a.agent_id);
-    if (!ag)
-      return mcpError("AGENT_NOT_FOUND", `Agent not found: ${a.agent_id}`);
-    ag.last_seen_at = new Date().toISOString();
-    return mcpJson({ agent_id: a.agent_id, name: ag.name, active: true, last_seen_at: ag.last_seen_at });
-  });
-  server.tool("set_focus", "Set active project context for this agent session.", { agent_id: exports_external.string(), project_id: exports_external.string().optional() }, async (a) => {
-    const ag = _agentReg.get(a.agent_id);
-    if (!ag)
-      return mcpError("AGENT_NOT_FOUND", `Agent not found: ${a.agent_id}`);
-    ag.project_id = a.project_id;
-    return mcpJson({ agent_id: a.agent_id, project_id: a.project_id ?? null });
-  });
-  server.tool("list_agents", "List all registered agents.", {}, async () => {
-    const agents = [..._agentReg.values()];
-    return mcpJson({ agents, total: agents.length }, true);
-  });
-  server.tool("send_feedback", "Send feedback about this service", { message: exports_external.string(), email: exports_external.string().optional(), category: exports_external.enum(["bug", "feature", "general"]).optional() }, async (params) => {
-    try {
-      const result = saveFeedback({ ...params, version: package_default.version });
-      return mcpJson(result);
-    } catch (e) {
-      return mcpError("FEEDBACK_SAVE_FAILED", String(e));
-    }
-  });
-}
-
-// src/lib/scheduler.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
-import { join as join10 } from "path";
-function getSchedulesPath(targetDir = process.cwd()) {
-  return join10(targetDir, ".skills", "schedules.json");
-}
-function loadSchedules(targetDir = process.cwd()) {
-  const path = getSchedulesPath(targetDir);
-  if (existsSync10(path)) {
-    try {
-      return JSON.parse(readFileSync8(path, "utf-8"));
-    } catch {}
-  }
-  return { version: 1, schedules: [] };
-}
-function saveSchedules(data, targetDir = process.cwd()) {
-  const path = getSchedulesPath(targetDir);
-  const dir = join10(targetDir, ".skills");
-  if (!existsSync10(dir))
-    mkdirSync6(dir, { recursive: true });
-  writeFileSync5(path, JSON.stringify(data, null, 2));
-}
-function validateCronField(expr, min, max, label) {
-  for (const part of expr.split(",")) {
-    if (part === "*")
-      continue;
-    let valuePart = part;
-    if (part.includes("/")) {
-      const slashIdx = part.indexOf("/");
-      valuePart = part.slice(0, slashIdx);
-      const stepStr = part.slice(slashIdx + 1);
-      const step = parseInt(stepStr);
-      if (isNaN(step) || step < 1)
-        return { valid: false, error: `Invalid step value in "${part}" in ${label}` };
-    }
-    if (valuePart === "*")
-      continue;
-    if (valuePart.includes("-")) {
-      const rangeParts = valuePart.split("-");
-      if (rangeParts.length !== 2)
-        return { valid: false, error: `Invalid range expression "${valuePart}" in ${label}` };
-      const lo = parseInt(rangeParts[0]);
-      const hi = parseInt(rangeParts[1]);
-      if (isNaN(lo) || isNaN(hi))
-        return { valid: false, error: `Invalid range "${valuePart}" in ${label}` };
-      if (lo < min || hi > max || lo > hi) {
-        return { valid: false, error: `Range ${lo}-${hi} outside valid ${min}-${max} in ${label}` };
-      }
-      continue;
-    }
-    const n = parseInt(valuePart);
-    if (isNaN(n))
-      return { valid: false, error: `Invalid value "${valuePart}" in ${label}` };
-    if (n < min || n > max) {
-      return { valid: false, error: `Value ${n} outside valid ${min}-${max} in ${label}` };
-    }
-  }
-  return { valid: true };
-}
-function validateCron(expr) {
-  const fields = expr.trim().split(/\s+/);
-  if (fields.length !== 5) {
-    return { valid: false, error: `Expected 5 fields, got ${fields.length}. Format: "minute hour day-of-month month day-of-week"` };
-  }
-  const [minuteF, hourF, domF, monthF, dowF] = fields;
-  const checks4 = [
-    { expr: minuteF, min: 0, max: 59, label: "minute" },
-    { expr: hourF, min: 0, max: 23, label: "hour" },
-    { expr: domF, min: 1, max: 31, label: "day-of-month" },
-    { expr: monthF, min: 1, max: 12, label: "month" },
-    { expr: dowF, min: 0, max: 6, label: "day-of-week" }
-  ];
-  for (const { expr: f, min, max, label } of checks4) {
-    const result = validateCronField(f, min, max, label);
-    if (!result.valid)
-      return result;
-  }
-  return { valid: true };
-}
-function getNextRun(cron, from = new Date) {
-  const { valid } = validateCron(cron);
-  if (!valid)
-    return null;
-  const [minuteF, hourF, domF, monthF, dowF] = cron.trim().split(/\s+/);
-  function parseField(f, min, max) {
-    if (f === "*")
-      return Array.from({ length: max - min + 1 }, (_, i) => i + min);
-    if (f.startsWith("*/")) {
-      const step = parseInt(f.slice(2));
-      if (isNaN(step))
-        return [];
-      const vals = [];
-      for (let i = min;i <= max; i += step)
-        vals.push(i);
-      return vals;
-    }
-    return f.split(",").flatMap((part) => {
-      if (part.includes("-")) {
-        const [lo, hi] = part.split("-").map(Number);
-        return Array.from({ length: hi - lo + 1 }, (_, i) => i + lo);
-      }
-      const n = parseInt(part);
-      return isNaN(n) ? [] : [n];
-    });
-  }
-  const minutes = parseField(minuteF, 0, 59);
-  const hours = parseField(hourF, 0, 23);
-  const doms = parseField(domF, 1, 31);
-  const months = parseField(monthF, 1, 12);
-  const dows = parseField(dowF, 0, 6);
-  const candidate = new Date(from);
-  candidate.setSeconds(0, 0);
-  candidate.setMinutes(candidate.getMinutes() + 1);
-  const limit = new Date(from);
-  limit.setFullYear(limit.getFullYear() + 1);
-  while (candidate < limit) {
-    const month = candidate.getMonth() + 1;
-    const dom = candidate.getDate();
-    const dow = candidate.getDay();
-    const hour = candidate.getHours();
-    const minute = candidate.getMinutes();
-    if (!months.includes(month)) {
-      candidate.setMonth(candidate.getMonth() + 1, 1);
-      candidate.setHours(0, 0, 0, 0);
-      continue;
-    }
-    if (!doms.includes(dom) || !dows.includes(dow)) {
-      candidate.setDate(candidate.getDate() + 1);
-      candidate.setHours(0, 0, 0, 0);
-      continue;
+  }, async ({ names }) => {
+    return mcpJson({ schemaVersion: 1, tools: describeMcpToolContracts(names) });
+  });
+  server.registerTool("get_mcp_contracts", {
+    title: "Get MCP Contracts",
+    description: "Return the machine-readable MCP tool and resource contract manifest.",
+    inputSchema: {
+      names: exports_external.array(exports_external.string()).optional(),
+      includeResources: exports_external.boolean().optional()
     }
-    if (!hours.includes(hour)) {
-      candidate.setHours(candidate.getHours() + 1, 0, 0, 0);
-      continue;
+  }, async ({ names, includeResources }) => {
+    return mcpJson(createMcpContractManifest({
+      names,
+      includeResources: includeResources ?? false
+    }));
+  });
+  const _agentReg = new Map;
+  server.tool("register_agent", "Register this agent session. Returns agent_id for use in heartbeat/set_focus.", { name: exports_external.string(), session_id: exports_external.string().optional() }, async (a) => {
+    const existing = [..._agentReg.values()].find((x) => x.name === a.name);
+    if (existing) {
+      existing.last_seen_at = new Date().toISOString();
+      return mcpJson({ ...existing, registered: false });
     }
-    if (!minutes.includes(minute)) {
-      candidate.setMinutes(candidate.getMinutes() + 1, 0, 0);
-      continue;
+    const id = Math.random().toString(36).slice(2, 10);
+    const ag = { id, name: a.name, last_seen_at: new Date().toISOString() };
+    _agentReg.set(id, ag);
+    return mcpJson({ ...ag, registered: true });
+  });
+  server.tool("heartbeat", "Update last_seen_at to signal agent is active.", { agent_id: exports_external.string() }, async (a) => {
+    const ag = _agentReg.get(a.agent_id);
+    if (!ag)
+      return mcpError("AGENT_NOT_FOUND", `Agent not found: ${a.agent_id}`);
+    ag.last_seen_at = new Date().toISOString();
+    return mcpJson({ agent_id: a.agent_id, name: ag.name, active: true, last_seen_at: ag.last_seen_at });
+  });
+  server.tool("set_focus", "Set active project context for this agent session.", { agent_id: exports_external.string(), project_id: exports_external.string().optional() }, async (a) => {
+    const ag = _agentReg.get(a.agent_id);
+    if (!ag)
+      return mcpError("AGENT_NOT_FOUND", `Agent not found: ${a.agent_id}`);
+    ag.project_id = a.project_id;
+    return mcpJson({ agent_id: a.agent_id, project_id: a.project_id ?? null });
+  });
+  server.tool("list_agents", "List all registered agents.", {}, async () => {
+    const agents = [..._agentReg.values()];
+    return mcpJson({ agents, total: agents.length }, true);
+  });
+  server.tool("send_feedback", "Send feedback about this service", { message: exports_external.string(), email: exports_external.string().optional(), category: exports_external.enum(["bug", "feature", "general"]).optional() }, async (params) => {
+    try {
+      const result = saveFeedback({ ...params, version: package_default.version });
+      return mcpJson(result);
+    } catch (e) {
+      return mcpError("FEEDBACK_SAVE_FAILED", String(e));
     }
-    return new Date(candidate);
-  }
-  return null;
-}
-function addSchedule(skill, cron, options = {}) {
-  const { valid, error: error48 } = validateCron(cron);
-  if (!valid)
-    return { schedule: null, error: error48 };
-  const data = loadSchedules(options.targetDir);
-  const id = `${skill}-${Date.now()}`;
-  const now = new Date;
-  const nextRun = getNextRun(cron, now);
-  const schedule = {
-    id,
-    name: options.name || `${skill} (${cron})`,
-    skill,
-    cron,
-    args: options.args,
-    enabled: true,
-    createdAt: now.toISOString(),
-    nextRun: nextRun?.toISOString()
-  };
-  data.schedules.push(schedule);
-  saveSchedules(data, options.targetDir);
-  return { schedule };
-}
-function listSchedules(targetDir) {
-  return loadSchedules(targetDir).schedules;
-}
-function removeSchedule(idOrName, targetDir) {
-  const data = loadSchedules(targetDir);
-  const before = data.schedules.length;
-  data.schedules = data.schedules.filter((s) => s.id !== idOrName && s.name !== idOrName);
-  if (data.schedules.length === before)
-    return false;
-  saveSchedules(data, targetDir);
-  return true;
+  });
 }
 
-// src/lib/skill-validation.ts
-init_pricing();
-import { existsSync as existsSync11, lstatSync, readFileSync as readFileSync9, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
-import { isAbsolute, join as join11, normalize } from "path";
-var DOC_FILES = ["SKILL.md", "README.md", "CLAUDE.md"];
-var RESERVED_SKILL_ENTRIES = new Set([
-  ".env",
-  ".npmrc",
-  ".pypirc",
-  ".netrc",
-  "id_rsa",
-  "id_ed25519"
-]);
-var KNOWN_TOP_LEVEL_ENTRIES = new Set([
-  ".claude",
-  ".env.example",
-  ".gitignore",
-  ".skills",
-  "CLAUDE.md",
-  "LICENSE",
-  "PROJECT_OVERVIEW.md",
-  "QUICKSTART.md",
-  "README.md",
-  "SKILL.md",
-  "api-docs-list.json",
-  "auth.ts",
-  "bun.lock",
-  "bunfig.toml",
-  "data",
-  "dist",
-  "examples",
-  "exports",
-  "http-client.ts",
-  "index.ts",
-  "install.sh",
-  "installer.ts",
-  "logs",
-  "node_modules",
-  "package.json",
-  "scripts",
-  "skill-install.ts",
-  "src",
-  "tests",
-  "tsconfig.json",
-  "vision.ts"
-]);
-var VALID_PROVENANCE_SOURCES = new Set(["official", "custom", "remote", "private", "private-hosted", "upstream"]);
-var VALID_BIN_COMMAND = /^[a-z0-9][a-z0-9._-]*$/;
-function add(target, code, message) {
-  target.push({ code, message });
-}
-function readJsonFile(path) {
-  return JSON.parse(readFileSync9(path, "utf-8"));
-}
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
-}
-function sortMessages(messages) {
-  return [...messages].sort((a, b) => a.code.localeCompare(b.code) || a.message.localeCompare(b.message));
-}
-function isSafeRelativePath(value) {
-  if (!value.trim() || isAbsolute(value))
-    return false;
-  const normalized = normalize(value).replace(/\\/g, "/");
-  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
+// src/lib/scheduler.ts
+import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7 } from "fs";
+import { join as join12 } from "path";
+function getSchedulesPath(targetDir = process.cwd()) {
+  return join12(targetDir, ".skills", "schedules.json");
 }
-function isHostedPackageMetadata(pkg) {
-  const skills = asRecord(pkg.skills);
-  if (!skills)
-    return false;
-  const runtime = typeof skills.runtime === "string" ? skills.runtime.trim().toLowerCase() : "";
-  const source = typeof skills.source === "string" ? skills.source.trim().toLowerCase() : "";
-  return runtime === "hosted" || source === "remote" || source === "private-hosted";
+function loadSchedules(targetDir = process.cwd()) {
+  const path = getSchedulesPath(targetDir);
+  if (existsSync12(path)) {
+    try {
+      return JSON.parse(readFileSync10(path, "utf-8"));
+    } catch {}
+  }
+  return { version: 1, schedules: [] };
 }
-function isHostedMetadataSkill(skillName, frontmatter, registryMeta, packageDeclaresHosted) {
-  if (packageDeclaresHosted)
-    return true;
-  if (isPremiumSkill(skillName))
-    return true;
-  if (frontmatter?.source === "private-hosted")
-    return true;
-  if (frontmatter?.source === "remote" && !registryMeta?.tags.includes("local"))
-    return true;
-  return false;
+function saveSchedules(data, targetDir = process.cwd()) {
+  const path = getSchedulesPath(targetDir);
+  const dir = join12(targetDir, ".skills");
+  if (!existsSync12(dir))
+    mkdirSync7(dir, { recursive: true });
+  writeFileSync6(path, JSON.stringify(data, null, 2));
 }
-function parseSkillFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match)
-    return null;
-  const result = {};
-  const lines = match[1].split(/\r?\n/);
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const colon = line.indexOf(":");
-    if (colon === -1)
-      continue;
-    const key = line.slice(0, colon).trim();
-    const rawValue = line.slice(colon + 1).trim();
-    if (!key)
-      continue;
-    if (key === "tags" && rawValue === "") {
-      const tags = [];
-      while (i + 1 < lines.length && /^\s+-\s+/.test(lines[i + 1])) {
-        i++;
-        tags.push(lines[i].replace(/^\s+-\s+/, "").trim());
-      }
-      result.tags = tags;
-      continue;
-    }
-    const value = rawValue.replace(/^["']|["']$/g, "");
-    if (!value)
+function validateCronField(expr, min, max, label) {
+  for (const part of expr.split(",")) {
+    if (part === "*")
       continue;
-    if (key === "name")
-      result.name = value;
-    else if (key === "description")
-      result.description = value;
-    else if (key === "displayName" || key === "display_name")
-      result.displayName = value;
-    else if (key === "category")
-      result.category = value;
-    else if (key === "version")
-      result.version = value;
-    else if (key === "source")
-      result.source = value;
-    else if (key === "tags") {
-      result.tags = value.replace(/[\[\]]/g, "").split(",").map((tag) => tag.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
-    }
-  }
-  return Object.keys(result).length > 0 ? result : null;
-}
-function validateSkillDirectory(name, skillPath, registryMeta) {
-  const bareName = name;
-  const issues = [];
-  const warnings = [];
-  let packageDeclaresHosted = false;
-  let packageSkillSource;
-  const metadata = {
-    binCommands: [],
-    docFiles: []
-  };
-  if (!existsSync11(skillPath)) {
-    add(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
-    return {
-      name: bareName,
-      path: skillPath,
-      valid: false,
-      issues: sortMessages(issues),
-      warnings: sortMessages(warnings),
-      metadata
-    };
-  }
-  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 readdirSync4(skillPath).sort()) {
-    const entryPath = join11(skillPath, entry);
-    if (RESERVED_SKILL_ENTRIES.has(entry)) {
-      add(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
+    let valuePart = part;
+    if (part.includes("/")) {
+      const slashIdx = part.indexOf("/");
+      valuePart = part.slice(0, slashIdx);
+      const stepStr = part.slice(slashIdx + 1);
+      const step = parseInt(stepStr);
+      if (isNaN(step) || step < 1)
+        return { valid: false, error: `Invalid step value in "${part}" in ${label}` };
     }
-    if (lstatSync(entryPath).isSymbolicLink()) {
-      add(issues, "skill.symlink_forbidden", `Symlink '${entry}' is not allowed in skill packages`);
+    if (valuePart === "*")
+      continue;
+    if (valuePart.includes("-")) {
+      const rangeParts = valuePart.split("-");
+      if (rangeParts.length !== 2)
+        return { valid: false, error: `Invalid range expression "${valuePart}" in ${label}` };
+      const lo = parseInt(rangeParts[0]);
+      const hi = parseInt(rangeParts[1]);
+      if (isNaN(lo) || isNaN(hi))
+        return { valid: false, error: `Invalid range "${valuePart}" in ${label}` };
+      if (lo < min || hi > max || lo > hi) {
+        return { valid: false, error: `Range ${lo}-${hi} outside valid ${min}-${max} in ${label}` };
+      }
+      continue;
     }
-    if (!KNOWN_TOP_LEVEL_ENTRIES.has(entry)) {
-      add(warnings, "skill.file_unrecognized", `Unrecognized top-level skill entry '${entry}'`);
+    const n = parseInt(valuePart);
+    if (isNaN(n))
+      return { valid: false, error: `Invalid value "${valuePart}" in ${label}` };
+    if (n < min || n > max) {
+      return { valid: false, error: `Value ${n} outside valid ${min}-${max} in ${label}` };
     }
   }
-  for (const docFile of DOC_FILES) {
-    if (existsSync11(join11(skillPath, docFile)))
-      metadata.docFiles.push(docFile);
+  return { valid: true };
+}
+function validateCron(expr) {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    return { valid: false, error: `Expected 5 fields, got ${fields.length}. Format: "minute hour day-of-month month day-of-week"` };
   }
-  if (metadata.docFiles.length === 0) {
-    add(issues, "skill.docs_missing", "Missing documentation file: expected SKILL.md, README.md, or CLAUDE.md");
+  const [minuteF, hourF, domF, monthF, dowF] = fields;
+  const checks4 = [
+    { expr: minuteF, min: 0, max: 59, label: "minute" },
+    { expr: hourF, min: 0, max: 23, label: "hour" },
+    { expr: domF, min: 1, max: 31, label: "day-of-month" },
+    { expr: monthF, min: 1, max: 12, label: "month" },
+    { expr: dowF, min: 0, max: 6, label: "day-of-week" }
+  ];
+  for (const { expr: f, min, max, label } of checks4) {
+    const result = validateCronField(f, min, max, label);
+    if (!result.valid)
+      return result;
   }
-  const skillMdPath = join11(skillPath, "SKILL.md");
-  if (existsSync11(skillMdPath)) {
-    const frontmatter = parseSkillFrontmatter(readFileSync9(skillMdPath, "utf-8"));
-    if (!frontmatter) {
-      add(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
-    } else {
-      metadata.skillMdFrontmatter = frontmatter;
-      metadata.provenance = {
-        ...metadata.provenance ?? { directoryName: bareName },
-        ...frontmatter.source ? { frontmatterSource: frontmatter.source } : {},
-        ...registryMeta?.source ? { registrySource: registryMeta.source } : {}
-      };
-      if (!frontmatter.name)
-        add(issues, "skill.frontmatter_name_missing", "SKILL.md frontmatter missing name");
-      if (!frontmatter.description)
-        add(issues, "skill.frontmatter_description_missing", "SKILL.md frontmatter missing description");
-      if (frontmatter.name && frontmatter.name !== bareName) {
-        add(issues, "skill.frontmatter_name_mismatch", `SKILL.md name '${frontmatter.name}' does not match '${bareName}'`);
-      }
-      if (frontmatter.source && !VALID_PROVENANCE_SOURCES.has(frontmatter.source)) {
-        add(issues, "skill.frontmatter_source_invalid", `SKILL.md source '${frontmatter.source}' is not one of: ${[...VALID_PROVENANCE_SOURCES].join(", ")}`);
-      }
-      if (frontmatter.tags && frontmatter.tags.some((tag) => !tag.trim())) {
-        add(issues, "skill.frontmatter_tags_invalid", "SKILL.md tags must be non-empty strings");
-      }
-      if (registryMeta?.description && frontmatter.description && frontmatter.description.length < 8) {
-        add(warnings, "skill.frontmatter_description_short", "SKILL.md description is very short");
-      }
-      if (registryMeta?.category && frontmatter.category && frontmatter.category !== registryMeta.category) {
-        add(warnings, "skill.frontmatter_category_mismatch", `SKILL.md category '${frontmatter.category}' does not match registry category '${registryMeta.category}'`);
-      }
+  return { valid: true };
+}
+function getNextRun(cron, from = new Date) {
+  const { valid } = validateCron(cron);
+  if (!valid)
+    return null;
+  const [minuteF, hourF, domF, monthF, dowF] = cron.trim().split(/\s+/);
+  function parseField(f, min, max) {
+    if (f === "*")
+      return Array.from({ length: max - min + 1 }, (_, i) => i + min);
+    if (f.startsWith("*/")) {
+      const step = parseInt(f.slice(2));
+      if (isNaN(step))
+        return [];
+      const vals = [];
+      for (let i = min;i <= max; i += step)
+        vals.push(i);
+      return vals;
     }
-  } else {
-    add(warnings, "skill.skill_md_missing", "Missing SKILL.md; registry docs may need generated agent-facing instructions");
-  }
-  const pkgPath = join11(skillPath, "package.json");
-  if (!existsSync11(pkgPath)) {
-    add(issues, "package.missing", "Missing package.json");
-  } else {
-    try {
-      const pkg = readJsonFile(pkgPath);
-      const packageRecord = asRecord(pkg);
-      if (!packageRecord) {
-        add(issues, "package.invalid_shape", "package.json must be an object");
-      } else {
-        packageDeclaresHosted = isHostedPackageMetadata(pkg);
-        const skillsRecord = asRecord(pkg.skills);
-        if (skillsRecord && typeof skillsRecord.source === "string") {
-          packageSkillSource = skillsRecord.source;
-        }
-        const hostedMetadata2 = isHostedMetadataSkill(bareName, metadata.skillMdFrontmatter, registryMeta, packageDeclaresHosted);
-        metadata.runtime = hostedMetadata2 ? "hosted" : "local";
-        if (typeof pkg.name === "string") {
-          metadata.packageName = pkg.name;
-          if (pkg.name !== bareName) {
-            add(issues, "package.name_mismatch", `package.json name '${pkg.name}' does not match '${bareName}'`);
-          }
-        } else {
-          add(issues, "package.name_missing", "package.json missing string name");
-        }
-        if (typeof pkg.version === "string" && pkg.version.trim())
-          metadata.version = pkg.version;
-        else
-          add(warnings, "package.version_missing", "package.json missing string version");
-        metadata.provenance = {
-          ...metadata.provenance ?? { directoryName: bareName },
-          ...typeof pkg.name === "string" ? { packageName: pkg.name } : {},
-          ...typeof pkg.version === "string" && pkg.version.trim() ? { packageVersion: pkg.version } : {},
-          ...registryMeta?.source ? { registrySource: registryMeta.source } : {},
-          ...packageSkillSource ? { packageSkillSource } : {}
-        };
-        const binRecord = asRecord(pkg.bin);
-        if (!binRecord || Object.keys(binRecord).length === 0) {
-          if (!hostedMetadata2) {
-            add(issues, "package.bin_missing", "package.json missing non-empty bin object");
-          }
-        } else {
-          if (hostedMetadata2) {
-            add(issues, "package.hosted_bin_forbidden", "Hosted metadata packages must not expose a local bin entry");
-          }
-          for (const [command, target] of Object.entries(binRecord)) {
-            if (!VALID_BIN_COMMAND.test(command)) {
-              add(issues, "package.bin_command_invalid", `package.json bin command '${command}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
-            }
-            if (typeof target !== "string" || !target.trim()) {
-              add(issues, "package.bin_invalid", `package.json bin '${command}' must point to a file`);
-              continue;
-            }
-            metadata.binCommands.push(command);
-            if (!isSafeRelativePath(target)) {
-              add(issues, "package.bin_target_unsafe", `package.json bin '${command}' target '${target}' must stay inside the skill directory`);
-              continue;
-            }
-            const targetPath = join11(skillPath, target);
-            if (!existsSync11(targetPath)) {
-              add(warnings, "package.bin_target_missing", `package.json bin '${command}' target '${target}' is not present before build`);
-            } 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`);
-            }
-          }
-        }
+    return f.split(",").flatMap((part) => {
+      if (part.includes("-")) {
+        const [lo, hi] = part.split("-").map(Number);
+        return Array.from({ length: hi - lo + 1 }, (_, i) => i + lo);
       }
-    } catch (error48) {
-      add(issues, "package.invalid_json", `package.json is invalid JSON: ${error48.message}`);
-    }
+      const n = parseInt(part);
+      return isNaN(n) ? [] : [n];
+    });
   }
-  const hostedMetadata = isHostedMetadataSkill(bareName, metadata.skillMdFrontmatter, registryMeta, packageDeclaresHosted);
-  metadata.runtime = hostedMetadata ? "hosted" : "local";
-  const srcDir = join11(skillPath, "src");
-  if (hostedMetadata) {
-    if (existsSync11(srcDir)) {
-      add(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
+  const minutes = parseField(minuteF, 0, 59);
+  const hours = parseField(hourF, 0, 23);
+  const doms = parseField(domF, 1, 31);
+  const months = parseField(monthF, 1, 12);
+  const dows = parseField(dowF, 0, 6);
+  const candidate = new Date(from);
+  candidate.setSeconds(0, 0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+  const limit = new Date(from);
+  limit.setFullYear(limit.getFullYear() + 1);
+  while (candidate < limit) {
+    const month = candidate.getMonth() + 1;
+    const dom = candidate.getDate();
+    const dow = candidate.getDay();
+    const hour = candidate.getHours();
+    const minute = candidate.getMinutes();
+    if (!months.includes(month)) {
+      candidate.setMonth(candidate.getMonth() + 1, 1);
+      candidate.setHours(0, 0, 0, 0);
+      continue;
     }
-  } else if (!existsSync11(srcDir)) {
-    add(issues, "skill.src_missing", "Missing src/ directory");
-  } else if (!existsSync11(join11(srcDir, "index.ts")) && !existsSync11(join11(srcDir, "index.js"))) {
-    add(issues, "skill.src_index_missing", "Missing src/index.ts or src/index.js");
-  } else {
-    const indexPath = existsSync11(join11(srcDir, "index.ts")) ? join11(srcDir, "index.ts") : join11(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)`);
+    if (!doms.includes(dom) || !dows.includes(dow)) {
+      candidate.setDate(candidate.getDate() + 1);
+      candidate.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!hours.includes(hour)) {
+      candidate.setHours(candidate.getHours() + 1, 0, 0, 0);
+      continue;
+    }
+    if (!minutes.includes(minute)) {
+      candidate.setMinutes(candidate.getMinutes() + 1, 0, 0);
+      continue;
+    }
+    return new Date(candidate);
   }
-  return {
-    name: bareName,
-    path: skillPath,
-    valid: issues.length === 0,
-    issues: sortMessages(issues),
-    warnings: sortMessages(warnings),
-    metadata
+  return null;
+}
+function addSchedule(skill, cron, options = {}) {
+  const { valid, error: error48 } = validateCron(cron);
+  if (!valid)
+    return { schedule: null, error: error48 };
+  const data = loadSchedules(options.targetDir);
+  const id = `${skill}-${Date.now()}`;
+  const now = new Date;
+  const nextRun = getNextRun(cron, now);
+  const schedule = {
+    id,
+    name: options.name || `${skill} (${cron})`,
+    skill,
+    cron,
+    args: options.args,
+    enabled: true,
+    createdAt: now.toISOString(),
+    nextRun: nextRun?.toISOString()
   };
+  data.schedules.push(schedule);
+  saveSchedules(data, options.targetDir);
+  return { schedule };
+}
+function listSchedules(targetDir) {
+  return loadSchedules(targetDir).schedules;
+}
+function removeSchedule(idOrName, targetDir) {
+  const data = loadSchedules(targetDir);
+  const before = data.schedules.length;
+  data.schedules = data.schedules.filter((s) => s.id !== idOrName && s.name !== idOrName);
+  if (data.schedules.length === before)
+    return false;
+  saveSchedules(data, targetDir);
+  return true;
 }
 
 // src/mcp/schedule-tools.ts
@@ -34223,8 +34913,9 @@ function registerScheduleTools(server) {
       name: exports_external.string()
     }
   }, async ({ name }) => {
-    const skillPath = getSkillPath(name);
-    const result = validateSkillDirectory(name, skillPath, getSkill(name));
+    const portable = findPortableSkill(name);
+    const skillPath = portable?.path ?? getSkillPath(name);
+    const result = portable ? validatePortableSkillDirectory(portable.name, portable.path) : validateSkillDirectory(name, skillPath, getSkill(name));
     return {
       content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
       isError: !result.valid