@hasna/skills 0.1.43 → 0.1.45

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.45",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -21808,6 +21808,10 @@ var package_default = {
     ".": {
       import: "./dist/index.js",
       types: "./dist/index.d.ts"
+    },
+    "./storage": {
+      import: "./dist/storage.js",
+      types: "./dist/storage.d.ts"
     }
   },
   files: [
@@ -21816,6 +21820,7 @@ var package_default = {
     "!dist/platform",
     "!dist/server",
     "bin/",
+    "docs/skill-standard.md",
     "skills/",
     "!skills/**/node_modules",
     "!skills/scaffold-project/my-app",
@@ -21827,7 +21832,7 @@ var package_default = {
   types: "./dist/index.d.ts",
   scripts: {
     clean: "rm -rf bin/ dist/",
-    build: "bun run clean && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+    build: "bun run clean && bun build ./src/cli/index.tsx --outdir ./bin --target bun && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts ./src/storage.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
     test: "bun test",
     dev: "bun run ./src/cli/index.tsx",
     "dev:watch": "bun --watch run ./src/cli/index.tsx",
@@ -21857,10 +21862,11 @@ var package_default = {
   devDependencies: {
     "@types/bun": "latest",
     "@types/react": "^18.2.0",
+    "react-devtools-core": "^7.0.1",
     typescript: "^5"
   },
   dependencies: {
-    "@hasna/events": "^0.1.7",
+    "@hasna/events": "^0.1.3",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -29473,97 +29479,989 @@ 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",
@@ -31446,20 +32344,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 +32386,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 +32399,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 +32418,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 +32437,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 +32478,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 +32552,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 +32581,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 +32630,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 +32649,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 +32661,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 +32682,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 +32698,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 +32741,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 +32761,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 +32784,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 +32816,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 +32917,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 +33026,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",
@@ -32341,6 +33303,46 @@ var toolContracts = [
     inputSchema: objectSchema(),
     outputSchema: objectSchema({}, [], "Setup summary.", true)
   },
+  {
+    name: "storage_status",
+    title: "Storage Status",
+    description: "Show local-first storage paths and optional repo-owned Postgres/S3 readiness.",
+    params: ["directory?"],
+    category: "storage",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({ directory: stringSchema("Project directory.") }),
+    outputSchema: objectSchema({
+      package: stringSchema("Package name."),
+      mode: { type: "string", enum: ["local", "remote", "hybrid"] },
+      local: objectSchema({}, [], "Local storage paths.", true),
+      remote: objectSchema({}, [], "Remote storage readiness.", true)
+    }, ["package", "mode", "local", "remote"])
+  },
+  {
+    name: "storage_sync_plan",
+    title: "Storage Sync Plan",
+    description: "Plan .skills snapshot sync for optional Postgres/S3 storage without network access.",
+    params: ["directory?", "includeSchemaSql?"],
+    category: "storage",
+    sideEffects: "none",
+    stable: true,
+    inputSchema: objectSchema({
+      directory: stringSchema("Project directory."),
+      includeSchemaSql: { type: "boolean", default: false }
+    }),
+    outputSchema: objectSchema({
+      package: stringSchema("Package name."),
+      noNetwork: { type: "boolean", const: true },
+      mode: { type: "string", enum: ["local", "remote", "hybrid"] },
+      databaseConfigured: { type: "boolean" },
+      s3Configured: { type: "boolean" },
+      snapshotFileCount: { type: "number" },
+      s3ObjectCount: { type: "number" },
+      env: objectSchema({}, [], "Storage env var names.", true),
+      schemaSql: stringSchema("Optional Postgres schema SQL.")
+    }, ["package", "noNetwork", "mode", "databaseConfigured", "s3Configured"])
+  },
   {
     name: "schedule_skill",
     title: "Schedule Skill",
@@ -32929,25 +33931,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 +33996,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 +34042,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 +34066,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) {
@@ -33083,378 +34085,154 @@ function mimeForPath(path) {
     case ".pdf":
       return "application/pdf";
     case ".md":
-      return "text/markdown";
-    case ".txt":
-    case ".log":
-      return "text/plain";
-    case ".json":
-      return "application/json";
-    case ".mp4":
-      return "video/mp4";
-    case ".mov":
-      return "video/quicktime";
-    default:
-      return "application/octet-stream";
-  }
-}
-
-// src/mcp/operation-tools.ts
-function registerOperationTools(server) {
-  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.",
-    inputSchema: {
-      name: exports_external.string(),
-      for: exports_external.string().optional(),
-      scope: exports_external.string().optional()
-    }
-  }, async ({ name, for: agentArg, scope }) => {
-    if (agentArg) {
-      let agents;
-      try {
-        agents = resolveAgents(agentArg);
-      } catch (err) {
-        return mcpError("INVALID_AGENT", err.message, [...AGENT_TARGETS, "all"]);
-      }
-      const results = agents.map((a) => ({
-        skill: name,
-        success: false,
-        agent: a,
-        scope: scope || "global",
-        error: `Direct agent skill-folder installs are disabled. Register Skills MCP instead: skills mcp --register ${a}`
-      }));
-      return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-        isError: results.some((r) => !r.success)
-      };
-    }
-    const result = installSkill(name);
-    if (result.success)
-      cacheClear();
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-      isError: !result.success
-    };
-  });
-  server.registerTool("pin_category", {
-    title: "Pin Category",
-    description: "Pin all skills in a category. Agent skill-folder installs are disabled.",
-    inputSchema: {
-      category: exports_external.string(),
-      for: exports_external.string().optional(),
-      scope: exports_external.string().optional()
-    }
-  }, async ({ category, for: agentArg, scope }) => {
-    const matchedCategory = CATEGORIES.find((c) => c.toLowerCase() === category.toLowerCase());
-    if (!matchedCategory) {
-      return {
-        ...mcpError("UNKNOWN_CATEGORY", `Unknown category: ${category}`, CATEGORIES.slice())
-      };
-    }
-    const categorySkills = getSkillsByCategory(matchedCategory);
-    const names = categorySkills.map((s) => s.name);
-    if (agentArg) {
-      let agents;
-      try {
-        agents = resolveAgents(agentArg);
-      } catch (err) {
-        return mcpError("INVALID_AGENT", err.message, [...AGENT_TARGETS, "all"]);
-      }
-      const results2 = [];
-      for (const name of names) {
-        for (const a of agents) {
-          const r = {
-            skill: name,
-            success: false,
-            error: `Direct agent skill-folder installs are disabled. Register Skills MCP instead: skills mcp --register ${a}`
-          };
-          results2.push({ ...r, agent: a, scope: scope || "global" });
-        }
-      }
-      return {
-        content: [{ type: "text", text: JSON.stringify({ category: matchedCategory, count: names.length, results: results2 }, null, 2) }],
-        isError: results2.some((r) => !r.success)
-      };
-    }
-    const results = names.map((name) => installSkill(name));
-    return {
-      content: [{ type: "text", text: JSON.stringify({ category: matchedCategory, count: names.length, results }, null, 2) }],
-      isError: results.some((r) => !r.success)
-    };
-  });
-  server.registerTool("unpin_skill", {
-    title: "Unpin Skill",
-    description: "Unpin a skill from .skills/project.json. Agent skill folders are unmanaged.",
-    inputSchema: {
-      name: exports_external.string(),
-      for: exports_external.string().optional(),
-      scope: exports_external.string().optional()
-    }
-  }, async ({ name, for: agentArg, scope }) => {
-    if (agentArg) {
-      let agents;
-      try {
-        agents = resolveAgents(agentArg);
-      } catch (err) {
-        return mcpError("INVALID_AGENT", err.message, [...AGENT_TARGETS, "all"]);
-      }
-      const results = agents.map((a) => ({
-        skill: name,
-        agent: a,
-        removed: false,
-        error: `Agent skill folders are unmanaged. Register Skills MCP instead: skills mcp --register ${a}`
-      }));
-      return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
-      };
-    }
-    const removed = removeSkill(name);
-    if (removed)
-      cacheClear();
-    return {
-      content: [{ type: "text", text: JSON.stringify({ skill: name, removed }, null, 2) }]
-    };
-  });
-  server.registerTool("list_categories", {
-    title: "List Categories",
-    description: "List all 17 skill categories with skill counts."
-  }, async () => {
-    const cats = CATEGORIES.map((category) => ({
-      name: category,
-      count: getSkillsByCategory(category).length
-    }));
-    return { content: [{ type: "text", text: JSON.stringify(cats, null, 2) }] };
-  });
-  server.registerTool("list_tags", {
-    title: "List Tags",
-    description: "List all unique skill tags with occurrence counts."
-  }, async () => {
-    const tagCounts = new Map;
-    for (const skill of loadRegistry()) {
-      for (const tag of skill.tags) {
-        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
-      }
-    }
-    const sorted = Array.from(tagCounts.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([name, count]) => ({ name, count }));
-    return { content: [{ type: "text", text: JSON.stringify(sorted, null, 2) }] };
-  });
-  server.registerTool("get_requirements", {
-    title: "Get Requirements",
-    description: "Get env vars, system deps, and npm dependencies for a skill.",
+      return "text/markdown";
+    case ".txt":
+    case ".log":
+      return "text/plain";
+    case ".json":
+      return "application/json";
+    case ".mp4":
+      return "video/mp4";
+    case ".mov":
+      return "video/quicktime";
+    default:
+      return "application/octet-stream";
+  }
+}
+
+// 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()
+      name: exports_external.string(),
+      description: exports_external.string().optional(),
+      overwrite: exports_external.boolean().optional()
     }
-  }, async ({ name }) => {
-    const reqs = getSkillRequirements(name);
-    if (!reqs) {
-      return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
+  }, async ({ name, description, overwrite }) => {
+    try {
+      const result = scaffoldPortableSkill(name, { description, overwrite });
+      clearRegistryCache();
+      cacheClear();
+      return mcpJson(result);
+    } catch (err) {
+      return mcpError("SCAFFOLD_FAILED", err.message);
     }
-    return { content: [{ type: "text", text: JSON.stringify(reqs, null, 2) }] };
   });
-  server.registerTool("quote_skill", {
-    title: "Quote Skill",
-    description: "Quote a skill run before spending account balance.",
+  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: {
-      name: exports_external.string(),
-      input: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
-      args: exports_external.array(exports_external.string()).optional()
-    }
-  }, async ({ name, input, args }) => {
-    const skill = getSkill(name);
-    if (!skill) {
-      return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
+      path: exports_external.string(),
+      name: exports_external.string().optional(),
+      overwrite: exports_external.boolean().optional()
     }
-    const { ARTICLE_GENERATION_SLUG: ARTICLE_GENERATION_SLUG2, getPublicSkillPricing: getPublicSkillPricing2, validateBlogArticleRunOptions: validateBlogArticleRunOptions2 } = await Promise.resolve().then(() => (init_pricing(), exports_pricing));
-    const runInput = input || {};
-    const runArgs = args || [];
-    if (skill.name === ARTICLE_GENERATION_SLUG2) {
-      const validation = validateBlogArticleRunOptions2(runInput, runArgs);
-      if (!validation.ok) {
-        return mcpError("INVALID_BLOG_ARTICLE_OPTIONS", validation.errors.join(" "));
-      }
+  }, 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);
     }
-    return mcpJson({
-      skill: skill.name,
-      pricing: getPublicSkillPricing2(skill.name, runInput, runArgs)
-    });
   });
-  server.registerTool("run_skill", {
-    title: "Run Skill",
-    description: "Run a skill by name with optional arguments.",
+  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.",
     inputSchema: {
       name: exports_external.string(),
-      input: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
-      args: exports_external.array(exports_external.string()).optional(),
-      approved: exports_external.boolean().optional()
-    }
-  }, async ({ name, input, args, approved }) => {
-    const skill = getSkill(name);
-    if (!skill) {
-      return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
-    }
-    const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_auth_store(), exports_auth_store));
-    const {
-      ARTICLE_GENERATION_SLUG: ARTICLE_GENERATION_SLUG2,
-      isPremiumSkill: isPremiumSkill2,
-      getSkillRunCostCents: getSkillRunCostCents2,
-      formatCost: formatCost2,
-      validateBlogArticleRunOptions: validateBlogArticleRunOptions2
-    } = await Promise.resolve().then(() => (init_pricing(), exports_pricing));
-    const skillName = skill.name;
-    const runInput = input || {};
-    const runArgs = args || [];
-    if (skillName === ARTICLE_GENERATION_SLUG2) {
-      const validation = validateBlogArticleRunOptions2(runInput, runArgs, { requireTopic: true });
-      if (!validation.ok) {
-        return mcpError("INVALID_BLOG_ARTICLE_OPTIONS", validation.errors.join(" "));
-      }
-    }
-    const apiKey = getApiKey2();
-    const costCents = isPremiumSkill2(skillName) ? getSkillRunCostCents2(skillName, runInput, runArgs) : undefined;
-    const runContext = createSkillRun({
-      skill: skillName,
-      args: runArgs,
-      remote: isPremiumSkill2(skillName),
-      costCents
-    });
-    if (isPremiumSkill2(skillName) && !apiKey) {
-      const cost = formatCost2(costCents ?? 0);
-      const error48 = `${skillName} is a hosted skill (${cost}). Run: skills setup --mode hosted && skills auth login`;
-      writeRunLogs(runContext, "", error48 + `
-`);
-      const run = completeSkillRun(runContext, { status: "failed", error: error48, costCents });
-      return mcpError("AUTH_REQUIRED", `${error48}. Local run metadata: ${run.paths.runDir}/run.json`, ["skills auth login"]);
-    }
-    if (isPremiumSkill2(skillName) && apiKey && approved !== true) {
-      const cost = formatCost2(costCents ?? 0);
-      const error48 = `${skillName} is a paid hosted skill (${cost}). Call quote_skill first, then call run_skill with approved: true after user approval.`;
-      writeRunLogs(runContext, "", error48 + `
-`);
-      const run = completeSkillRun(runContext, { status: "failed", error: error48, costCents });
-      return mcpError("APPROVAL_REQUIRED", `${error48}. Local run metadata: ${run.paths.runDir}/run.json`, [
-        "quote_skill",
-        "run_skill approved=true"
-      ]);
+      for: exports_external.string().optional(),
+      scope: exports_external.string().optional()
     }
-    if (isPremiumSkill2(skillName) && apiKey) {
+  }, async ({ name, for: agentArg, scope }) => {
+    if (agentArg) {
+      let agents;
       try {
-        const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
-        const client = new RemoteSkillsClient2(apiKey);
-        const run = await client.submitRun(skillName, runInput, runArgs);
-        if (run.error) {
-          writeRunLogs(runContext, "", String(run.error) + `
-`);
-          const localRun3 = completeSkillRun(runContext, { status: "failed", error: String(run.error) });
-          return mcpError("RUN_FAILED", `${run.error}. Local run metadata: ${localRun3.paths.runDir}/run.json`);
-        }
-        const localRun2 = updateSkillRun(runContext, {
-          status: run.status === "running" || run.status === "completed" || run.status === "failed" ? run.status : "queued",
-          remoteRunId: typeof run.id === "string" ? run.id : undefined
-        });
-        writeRunLogs(runContext, "", "");
-        const remoteRunId = typeof run.id === "string" ? run.id : undefined;
-        return mcpJson({
-          contractVersion: REMOTE_SKILL_RUN_CONTRACT_VERSION,
-          id: run.id,
-          localRunId: localRun2.id,
-          skill: skillName,
-          status: run.status,
-          correlationId: run.correlationId,
-          remote: true,
-          remoteRun: run,
-          run: localRun2,
-          nextActions: remoteRunNextActions(remoteRunId)
-        });
+        agents = resolveAgents(agentArg);
       } catch (err) {
-        const error48 = `Hosted skill ${skillName} requires hosted access: ${err.message}`;
-        writeRunLogs(runContext, "", error48 + `
-`);
-        const localRun2 = completeSkillRun(runContext, { status: "failed", error: error48 });
-        return mcpError("PLATFORM_ERROR", `${error48}. Local run metadata: ${localRun2.paths.runDir}/run.json`);
-      }
-    }
-    const result = await runSkill(skillName, runArgs, {
-      stdio: "pipe",
-      env: {
-        SKILLS_RUN_ID: runContext.record.id,
-        SKILLS_RUN_DIR: runContext.runDir,
-        SKILLS_EXPORT_DIR: runContext.exportDir
+        return mcpError("INVALID_AGENT", err.message, [...AGENT_TARGETS, "all"]);
       }
-    });
-    writeRunLogs(runContext, result.stdout ?? "", result.stderr ?? result.error ?? "");
-    const localRun = completeSkillRun(runContext, {
-      status: result.exitCode === 0 ? "completed" : "failed",
-      error: result.error
-    });
-    if (result.error) {
+      const results = agents.map((a) => ({
+        skill: name,
+        success: false,
+        agent: a,
+        scope: scope || "global",
+        error: `Direct agent skill-folder installs are disabled. Register Skills MCP instead: skills mcp --register ${a}`
+      }));
       return {
-        content: [{ type: "text", text: JSON.stringify({ exitCode: result.exitCode, error: result.error, run: localRun }, null, 2) }],
-        isError: true
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        isError: results.some((r) => !r.success)
       };
     }
+    const result = installSkill(name);
+    if (result.success)
+      cacheClear();
     return {
-      content: [{ type: "text", text: JSON.stringify({ exitCode: result.exitCode, skill: skillName, stdout: result.stdout, stderr: result.stderr, run: localRun }, null, 2) }]
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      isError: !result.success
     };
   });
-  server.registerTool("get_run_status", {
-    title: "Get Run Status",
-    description: "Fetch remote run status. Accepts a remote run id or a local run id linked to a remote run.",
+  server.registerTool("pin_category", {
+    title: "Pin Category",
+    description: "Pin all skills in a category. Agent skill-folder installs are disabled.",
     inputSchema: {
-      run_id: exports_external.string()
-    }
-  }, async ({ run_id }) => {
-    const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_auth_store(), exports_auth_store));
-    const apiKey = getApiKey2();
-    if (!apiKey) {
-      return mcpError("AUTH_REQUIRED", "Remote run status requires hosted access. Run: skills auth login", ["skills auth login"]);
-    }
-    const localRun = findSkillRun(run_id);
-    const remoteRunId = localRun?.remoteRunId || run_id;
-    if (localRun && !localRun.remoteRunId) {
-      return mcpError("LOCAL_RUN", `Run '${run_id}' is local and has no remote run id`);
+      category: exports_external.string(),
+      for: exports_external.string().optional(),
+      scope: exports_external.string().optional()
     }
-    try {
-      const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
-      const client = new RemoteSkillsClient2(apiKey);
-      const run = await client.getRun(remoteRunId);
-      if (!run)
-        return mcpError("RUN_NOT_FOUND", `Remote run '${remoteRunId}' not found`);
-      return mcpJson({
-        contractVersion: REMOTE_SKILL_RUN_CONTRACT_VERSION,
-        runId: remoteRunId,
-        ...localRun ? { localRunId: localRun.id } : {},
-        run,
-        nextActions: remoteRunNextActions(remoteRunId)
-      });
-    } catch (err) {
-      return mcpError("SKILLS_MD_ERROR", err.message);
+  }, async ({ category, for: agentArg, scope }) => {
+    const matchedCategory = CATEGORIES.find((c) => c.toLowerCase() === category.toLowerCase());
+    if (!matchedCategory) {
+      return {
+        ...mcpError("UNKNOWN_CATEGORY", `Unknown category: ${category}`, CATEGORIES.slice())
+      };
     }
-  });
-  server.registerTool("export_skills", {
-    title: "Export Pinned Skills",
-    description: "Export pinned skills as a JSON payload for import elsewhere."
-  }, async () => {
-    const skills = getInstalledSkills();
-    const payload = {
-      version: 1,
-      skills,
-      timestamp: new Date().toISOString()
+    const categorySkills = getSkillsByCategory(matchedCategory);
+    const names = categorySkills.map((s) => s.name);
+    if (agentArg) {
+      let agents;
+      try {
+        agents = resolveAgents(agentArg);
+      } catch (err) {
+        return mcpError("INVALID_AGENT", err.message, [...AGENT_TARGETS, "all"]);
+      }
+      const results2 = [];
+      for (const name of names) {
+        for (const a of agents) {
+          const r = {
+            skill: name,
+            success: false,
+            error: `Direct agent skill-folder installs are disabled. Register Skills MCP instead: skills mcp --register ${a}`
+          };
+          results2.push({ ...r, agent: a, scope: scope || "global" });
+        }
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ category: matchedCategory, count: names.length, results: results2 }, null, 2) }],
+        isError: results2.some((r) => !r.success)
+      };
+    }
+    const results = names.map((name) => installSkill(name));
+    return {
+      content: [{ type: "text", text: JSON.stringify({ category: matchedCategory, count: names.length, results }, null, 2) }],
+      isError: results.some((r) => !r.success)
     };
-    return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
   });
-  server.registerTool("import_skills", {
-    title: "Import Pinned Skills",
-    description: "Pin skills from an export payload. Supports MCP setup guidance via 'for'.",
+  server.registerTool("unpin_skill", {
+    title: "Unpin Skill",
+    description: "Unpin a skill from .skills/project.json. Agent skill folders are unmanaged.",
     inputSchema: {
-      skills: exports_external.array(exports_external.string()),
+      name: exports_external.string(),
       for: exports_external.string().optional(),
       scope: exports_external.string().optional()
     }
-  }, async ({ skills: skillList, for: agentArg, scope }) => {
-    if (!skillList || skillList.length === 0) {
-      return { content: [{ type: "text", text: JSON.stringify({ imported: 0, results: [] }, null, 2) }] };
-    }
-    const results = [];
+  }, async ({ name, for: agentArg, scope }) => {
     if (agentArg) {
       let agents;
       try {
@@ -33462,702 +34240,660 @@ function registerOperationTools(server) {
       } catch (err) {
         return mcpError("INVALID_AGENT", err.message, [...AGENT_TARGETS, "all"]);
       }
-      for (const name of skillList) {
-        results.push({
-          skill: name,
-          success: false,
-          error: `Direct agent skill-folder installs are disabled. Register Skills MCP instead: skills mcp --register ${agents.join(",")}`
-        });
-      }
-    } else {
-      for (const name of skillList) {
-        const result = installSkill(name);
-        results.push({ skill: result.skill, success: result.success, ...result.error ? { error: result.error } : {} });
-      }
+      const results = agents.map((a) => ({
+        skill: name,
+        agent: a,
+        removed: false,
+        error: `Agent skill folders are unmanaged. Register Skills MCP instead: skills mcp --register ${a}`
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+      };
     }
-    const imported = results.filter((r) => r.success).length;
-    const hasErrors = results.some((r) => !r.success);
+    const removed = removeSkill(name);
+    if (removed)
+      cacheClear();
     return {
-      content: [{ type: "text", text: JSON.stringify({ imported, total: skillList.length, results }, null, 2) }],
-      isError: hasErrors
+      content: [{ type: "text", text: JSON.stringify({ skill: name, removed }, null, 2) }]
     };
   });
-  server.registerTool("whoami", {
-    title: "Skills Whoami",
-    description: "Show setup summary: version, pinned skills, agent configs, cwd."
+  server.registerTool("list_categories", {
+    title: "List Categories",
+    description: "List all 17 skill categories with skill counts."
   }, async () => {
-    const version2 = package_default.version;
-    const cwd = process.cwd();
-    const installed = getInstalledSkills();
-    const agents = [];
-    for (const agent of AGENT_TARGETS) {
-      const agentSkillsPath = getAgentSkillsDir(agent, "global");
-      const exists = existsSync8(agentSkillsPath);
-      let skillCount = 0;
-      if (exists) {
-        try {
-          skillCount = readdirSync3(agentSkillsPath).filter((f) => {
-            const full = join8(agentSkillsPath, f);
-            return !f.startsWith(".") && statSync2(full).isDirectory();
-          }).length;
-        } catch {}
+    const cats = CATEGORIES.map((category) => ({
+      name: category,
+      count: getSkillsByCategory(category).length
+    }));
+    return { content: [{ type: "text", text: JSON.stringify(cats, null, 2) }] };
+  });
+  server.registerTool("list_tags", {
+    title: "List Tags",
+    description: "List all unique skill tags with occurrence counts."
+  }, async () => {
+    const tagCounts = new Map;
+    for (const skill of loadRegistry()) {
+      for (const tag of skill.tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
       }
-      agents.push({ agent, label: AGENT_LABELS[agent], path: agentSkillsPath, exists, skillCount });
     }
-    const skillsDir = getSkillPath("image").replace(/[/\\][^/\\]*$/, "");
-    const result = {
-      version: version2,
-      installedCount: installed.length,
-      installed,
-      agents,
-      skillsDir,
-      cwd
-    };
-    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-  });
-}
-
-// 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 { Database } from "bun:sqlite";
-function getFeedbackDbPath() {
-  return join9(homedir5(), ".hasna", "skills", "skills.db");
-}
-function getFeedbackDb() {
-  const dbPath = getFeedbackDbPath();
-  const dir = dirname3(dbPath);
-  if (!existsSync9(dir))
-    mkdirSync5(dir, { recursive: true });
-  const db = new Database(dbPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec([
-    "CREATE TABLE IF NOT EXISTS feedback (",
-    "id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),",
-    "message TEXT NOT NULL,",
-    "email TEXT,",
-    "category TEXT DEFAULT 'general',",
-    "agent TEXT,",
-    "version TEXT,",
-    "machine_id TEXT,",
-    "created_at TEXT NOT NULL DEFAULT (datetime('now'))",
-    ")"
-  ].join(" "));
-  try {
-    db.exec("ALTER TABLE feedback ADD COLUMN agent TEXT");
-  } catch {}
-  return db;
-}
-function saveFeedback(input) {
-  const message = input.message.trim();
-  if (!message)
-    throw new Error("Feedback message is required");
-  const category = input.category ?? "general";
-  const db = getFeedbackDb();
-  try {
-    db.run("INSERT INTO feedback (message, email, category, agent, version) VALUES (?, ?, ?, ?, ?)", [message, input.email || null, category, input.agent || null, input.version || null]);
-  } finally {
-    db.close();
-  }
-  return { saved: true, category, path: getFeedbackDbPath() };
-}
-
-// src/mcp/resource-meta-tools.ts
-function registerResourceMetaTools(server) {
-  server.registerResource("MCP Contracts", "skills://mcp/contracts", {
-    description: "Machine-readable MCP tool and resource contract manifest."
-  }, async () => ({
-    contents: [{
-      uri: "skills://mcp/contracts",
-      text: JSON.stringify(createMcpContractManifest(), null, 2),
-      mimeType: "application/json"
-    }]
-  }));
-  server.registerResource("Skills Registry", "skills://registry", {
-    description: "Compact default basic skill list [{name,category,pricing}]. Use list_skills with profile:'all' for the full registry, and skills://{name} for detail."
-  }, async () => ({
-    contents: [{
-      uri: "skills://registry",
-      text: JSON.stringify(loadRegistryProfile("basic").map(getCompactSkillDiscovery)),
-      mimeType: "application/json"
-    }]
-  }));
-  server.registerResource("Skill Info", new ResourceTemplate("skills://{name}", { list: undefined }), {
-    description: "Individual skill metadata and documentation"
-  }, async (uri, { name }) => {
-    const skill = getSkill(name);
-    const doc2 = getSkillBestDoc(name);
-    const reqs = getSkillRequirements(name);
-    const publicReqs = skill && reqs ? {
-      ...reqs,
-      envVars: publicDiscoveryEnvVars(skill.name, reqs.envVars),
-      dependencies: publicDiscoveryDependencies(skill.name, reqs.dependencies)
-    } : reqs;
-    return {
-      contents: [{
-        uri: uri.href,
-        text: JSON.stringify({
-          ...skill ? getPublicSkillDiscovery(skill) : {},
-          documentation: skill ? publicDiscoveryDocumentation(skill, doc2) : doc2,
-          requirements: publicReqs,
-          ...skill ? { mcp: createSkillMcpMetadata(getPublicSkillDiscovery(skill)) } : {}
-        }, null, 2),
-        mimeType: "application/json"
-      }]
-    };
-  });
-  server.registerTool("search_tools", {
-    title: "Search Tools",
-    description: "List tool names or summaries, optionally filtered by keyword.",
-    inputSchema: { query: exports_external.string().optional(), detail: exports_external.boolean().optional() }
-  }, async ({ query, detail }) => {
-    const contracts2 = listMcpToolContracts(query);
-    const tools = detail ? contracts2.map(summarizeMcpToolContract) : contracts2.map((contract) => contract.name);
-    return mcpJson({ schemaVersion: 1, tools, total: tools.length });
-  });
-  server.registerTool("describe_tools", {
-    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) });
+    const sorted = Array.from(tagCounts.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([name, count]) => ({ name, count }));
+    return { content: [{ type: "text", text: JSON.stringify(sorted, null, 2) }] };
   });
-  server.registerTool("get_mcp_contracts", {
-    title: "Get MCP Contracts",
-    description: "Return the machine-readable MCP tool and resource contract manifest.",
+  server.registerTool("get_requirements", {
+    title: "Get Requirements",
+    description: "Get env vars, system deps, and npm dependencies for a skill.",
     inputSchema: {
-      names: exports_external.array(exports_external.string()).optional(),
-      includeResources: exports_external.boolean().optional()
+      name: exports_external.string()
     }
-  }, 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 });
+  }, async ({ name }) => {
+    const reqs = getSkillRequirements(name);
+    if (!reqs) {
+      return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
     }
-    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);
+    return { content: [{ type: "text", text: JSON.stringify(reqs, null, 2) }] };
   });
-  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));
+  server.registerTool("quote_skill", {
+    title: "Quote Skill",
+    description: "Quote a skill run before spending account balance.",
+    inputSchema: {
+      name: exports_external.string(),
+      input: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+      args: exports_external.array(exports_external.string()).optional()
+    }
+  }, async ({ name, input, args }) => {
+    const skill = getSkill(name);
+    if (!skill) {
+      return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
+    }
+    const { ARTICLE_GENERATION_SLUG: ARTICLE_GENERATION_SLUG2, getPublicSkillPricing: getPublicSkillPricing2, validateBlogArticleRunOptions: validateBlogArticleRunOptions2 } = await Promise.resolve().then(() => (init_pricing(), exports_pricing));
+    const runInput = input || {};
+    const runArgs = args || [];
+    if (skill.name === ARTICLE_GENERATION_SLUG2) {
+      const validation = validateBlogArticleRunOptions2(runInput, runArgs);
+      if (!validation.ok) {
+        return mcpError("INVALID_BLOG_ARTICLE_OPTIONS", validation.errors.join(" "));
+      }
     }
+    return mcpJson({
+      skill: skill.name,
+      pricing: getPublicSkillPricing2(skill.name, runInput, runArgs)
+    });
   });
-}
-
-// 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}` };
+  server.registerTool("run_skill", {
+    title: "Run Skill",
+    description: "Run a skill by name with optional arguments.",
+    inputSchema: {
+      name: exports_external.string(),
+      input: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+      args: exports_external.array(exports_external.string()).optional(),
+      approved: exports_external.boolean().optional()
     }
-    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}` };
+  }, async ({ name, input, args, approved }) => {
+    const skill = getSkill(name);
+    if (!skill) {
+      return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
+    }
+    const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_auth_store(), exports_auth_store));
+    const {
+      ARTICLE_GENERATION_SLUG: ARTICLE_GENERATION_SLUG2,
+      isPremiumSkill: isPremiumSkill2,
+      getSkillRunCostCents: getSkillRunCostCents2,
+      formatCost: formatCost2,
+      validateBlogArticleRunOptions: validateBlogArticleRunOptions2
+    } = await Promise.resolve().then(() => (init_pricing(), exports_pricing));
+    const skillName = skill.name;
+    const runInput = input || {};
+    const runArgs = args || [];
+    if (skillName === ARTICLE_GENERATION_SLUG2) {
+      const validation = validateBlogArticleRunOptions2(runInput, runArgs, { requireTopic: true });
+      if (!validation.ok) {
+        return mcpError("INVALID_BLOG_ARTICLE_OPTIONS", validation.errors.join(" "));
       }
-      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}` };
+    const apiKey = getApiKey2();
+    const costCents = isPremiumSkill2(skillName) ? getSkillRunCostCents2(skillName, runInput, runArgs) : undefined;
+    const runContext = createSkillRun({
+      skill: skillName,
+      args: runArgs,
+      remote: isPremiumSkill2(skillName),
+      costCents
+    });
+    if (isPremiumSkill2(skillName) && !apiKey) {
+      const cost = formatCost2(costCents ?? 0);
+      const error48 = `${skillName} is a hosted skill (${cost}). Run: skills setup --mode hosted && skills auth login`;
+      writeRunLogs(runContext, "", error48 + `
+`);
+      const run = completeSkillRun(runContext, { status: "failed", error: error48, costCents });
+      return mcpError("AUTH_REQUIRED", `${error48}. Local run metadata: ${run.paths.runDir}/run.json`, ["skills auth login"]);
     }
-  }
-  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;
+    if (isPremiumSkill2(skillName) && apiKey && approved !== true) {
+      const cost = formatCost2(costCents ?? 0);
+      const error48 = `${skillName} is a paid hosted skill (${cost}). Call quote_skill first, then call run_skill with approved: true after user approval.`;
+      writeRunLogs(runContext, "", error48 + `
+`);
+      const run = completeSkillRun(runContext, { status: "failed", error: error48, costCents });
+      return mcpError("APPROVAL_REQUIRED", `${error48}. Local run metadata: ${run.paths.runDir}/run.json`, [
+        "quote_skill",
+        "run_skill approved=true"
+      ]);
     }
-    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);
+    if (isPremiumSkill2(skillName) && apiKey) {
+      try {
+        const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
+        const client = new RemoteSkillsClient2(apiKey);
+        const run = await client.submitRun(skillName, runInput, runArgs);
+        if (run.error) {
+          writeRunLogs(runContext, "", String(run.error) + `
+`);
+          const localRun3 = completeSkillRun(runContext, { status: "failed", error: String(run.error) });
+          return mcpError("RUN_FAILED", `${run.error}. Local run metadata: ${localRun3.paths.runDir}/run.json`);
+        }
+        const localRun2 = updateSkillRun(runContext, {
+          status: run.status === "running" || run.status === "completed" || run.status === "failed" ? run.status : "queued",
+          remoteRunId: typeof run.id === "string" ? run.id : undefined
+        });
+        writeRunLogs(runContext, "", "");
+        const remoteRunId = typeof run.id === "string" ? run.id : undefined;
+        return mcpJson({
+          contractVersion: REMOTE_SKILL_RUN_CONTRACT_VERSION,
+          id: run.id,
+          localRunId: localRun2.id,
+          skill: skillName,
+          status: run.status,
+          correlationId: run.correlationId,
+          remote: true,
+          remoteRun: run,
+          run: localRun2,
+          nextActions: remoteRunNextActions(remoteRunId)
+        });
+      } catch (err) {
+        const error48 = `Hosted skill ${skillName} requires hosted access: ${err.message}`;
+        writeRunLogs(runContext, "", error48 + `
+`);
+        const localRun2 = completeSkillRun(runContext, { status: "failed", error: error48 });
+        return mcpError("PLATFORM_ERROR", `${error48}. Local run metadata: ${localRun2.paths.runDir}/run.json`);
+      }
+    }
+    const result = await runSkill(skillName, runArgs, {
+      stdio: "pipe",
+      env: {
+        SKILLS_RUN_ID: runContext.record.id,
+        SKILLS_RUN_DIR: runContext.runDir,
+        SKILLS_EXPORT_DIR: runContext.exportDir
       }
-      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;
+    writeRunLogs(runContext, result.stdout ?? "", result.stderr ?? result.error ?? "");
+    const localRun = completeSkillRun(runContext, {
+      status: result.exitCode === 0 ? "completed" : "failed",
+      error: result.error
+    });
+    if (result.error) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ exitCode: result.exitCode, error: result.error, run: localRun }, null, 2) }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ exitCode: result.exitCode, skill: skillName, stdout: result.stdout, stderr: result.stderr, run: localRun }, null, 2) }]
+    };
+  });
+  server.registerTool("get_run_status", {
+    title: "Get Run Status",
+    description: "Fetch remote run status. Accepts a remote run id or a local run id linked to a remote run.",
+    inputSchema: {
+      run_id: exports_external.string()
+    }
+  }, async ({ run_id }) => {
+    const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_auth_store(), exports_auth_store));
+    const apiKey = getApiKey2();
+    if (!apiKey) {
+      return mcpError("AUTH_REQUIRED", "Remote run status requires hosted access. Run: skills auth login", ["skills auth login"]);
     }
-    if (!doms.includes(dom) || !dows.includes(dow)) {
-      candidate.setDate(candidate.getDate() + 1);
-      candidate.setHours(0, 0, 0, 0);
-      continue;
+    const localRun = findSkillRun(run_id);
+    const remoteRunId = localRun?.remoteRunId || run_id;
+    if (localRun && !localRun.remoteRunId) {
+      return mcpError("LOCAL_RUN", `Run '${run_id}' is local and has no remote run id`);
     }
-    if (!hours.includes(hour)) {
-      candidate.setHours(candidate.getHours() + 1, 0, 0, 0);
-      continue;
+    try {
+      const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
+      const client = new RemoteSkillsClient2(apiKey);
+      const run = await client.getRun(remoteRunId);
+      if (!run)
+        return mcpError("RUN_NOT_FOUND", `Remote run '${remoteRunId}' not found`);
+      return mcpJson({
+        contractVersion: REMOTE_SKILL_RUN_CONTRACT_VERSION,
+        runId: remoteRunId,
+        ...localRun ? { localRunId: localRun.id } : {},
+        run,
+        nextActions: remoteRunNextActions(remoteRunId)
+      });
+    } catch (err) {
+      return mcpError("SKILLS_MD_ERROR", err.message);
     }
-    if (!minutes.includes(minute)) {
-      candidate.setMinutes(candidate.getMinutes() + 1, 0, 0);
-      continue;
+  });
+  server.registerTool("export_skills", {
+    title: "Export Pinned Skills",
+    description: "Export pinned skills as a JSON payload for import elsewhere."
+  }, async () => {
+    const skills = getInstalledSkills();
+    const payload = {
+      version: 1,
+      skills,
+      timestamp: new Date().toISOString()
+    };
+    return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+  });
+  server.registerTool("import_skills", {
+    title: "Import Pinned Skills",
+    description: "Pin skills from an export payload. Supports MCP setup guidance via 'for'.",
+    inputSchema: {
+      skills: exports_external.array(exports_external.string()),
+      for: exports_external.string().optional(),
+      scope: exports_external.string().optional()
     }
-    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("/../");
-}
-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());
+  }, async ({ skills: skillList, for: agentArg, scope }) => {
+    if (!skillList || skillList.length === 0) {
+      return { content: [{ type: "text", text: JSON.stringify({ imported: 0, results: [] }, null, 2) }] };
+    }
+    const results = [];
+    if (agentArg) {
+      let agents;
+      try {
+        agents = resolveAgents(agentArg);
+      } catch (err) {
+        return mcpError("INVALID_AGENT", err.message, [...AGENT_TARGETS, "all"]);
+      }
+      for (const name of skillList) {
+        results.push({
+          skill: name,
+          success: false,
+          error: `Direct agent skill-folder installs are disabled. Register Skills MCP instead: skills mcp --register ${agents.join(",")}`
+        });
+      }
+    } else {
+      for (const name of skillList) {
+        const result = installSkill(name);
+        results.push({ skill: result.skill, success: result.success, ...result.error ? { error: result.error } : {} });
       }
-      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);
+    const imported = results.filter((r) => r.success).length;
+    const hasErrors = results.some((r) => !r.success);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ imported, total: skillList.length, results }, null, 2) }],
+      isError: hasErrors
+    };
+  });
+  server.registerTool("whoami", {
+    title: "Skills Whoami",
+    description: "Show setup summary: version, pinned skills, agent configs, cwd."
+  }, async () => {
+    const version2 = package_default.version;
+    const cwd = process.cwd();
+    const installed = getInstalledSkills();
+    const agents = [];
+    for (const agent of AGENT_TARGETS) {
+      const agentSkillsPath = getAgentSkillsDir(agent, "global");
+      const exists = existsSync10(agentSkillsPath);
+      let skillCount = 0;
+      if (exists) {
+        try {
+          skillCount = readdirSync5(agentSkillsPath).filter((f) => {
+            const full = join10(agentSkillsPath, f);
+            return !f.startsWith(".") && statSync4(full).isDirectory();
+          }).length;
+        } catch {}
+      }
+      agents.push({ agent, label: AGENT_LABELS[agent], path: agentSkillsPath, exists, skillCount });
     }
+    const skillsDir = getSkillPath("image").replace(/[/\\][^/\\]*$/, "");
+    const result = {
+      version: version2,
+      installedCount: installed.length,
+      installed,
+      agents,
+      skillsDir,
+      cwd
+    };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+}
+
+// src/lib/feedback.ts
+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 join11(homedir4(), ".hasna", "skills", "skills.db");
+}
+function getFeedbackDb() {
+  const dbPath = getFeedbackDbPath();
+  const dir = dirname4(dbPath);
+  if (!existsSync11(dir))
+    mkdirSync6(dir, { recursive: true });
+  const db = new Database(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec([
+    "CREATE TABLE IF NOT EXISTS feedback (",
+    "id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),",
+    "message TEXT NOT NULL,",
+    "email TEXT,",
+    "category TEXT DEFAULT 'general',",
+    "agent TEXT,",
+    "version TEXT,",
+    "machine_id TEXT,",
+    "created_at TEXT NOT NULL DEFAULT (datetime('now'))",
+    ")"
+  ].join(" "));
+  try {
+    db.exec("ALTER TABLE feedback ADD COLUMN agent TEXT");
+  } catch {}
+  return db;
+}
+function saveFeedback(input) {
+  const message = input.message.trim();
+  if (!message)
+    throw new Error("Feedback message is required");
+  const category = input.category ?? "general";
+  const db = getFeedbackDb();
+  try {
+    db.run("INSERT INTO feedback (message, email, category, agent, version) VALUES (?, ?, ?, ?, ?)", [message, input.email || null, category, input.agent || null, input.version || null]);
+  } finally {
+    db.close();
   }
-  return Object.keys(result).length > 0 ? result : null;
+  return { saved: true, category, path: getFeedbackDbPath() };
 }
-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}`);
+
+// src/mcp/resource-meta-tools.ts
+function registerResourceMetaTools(server) {
+  server.registerResource("MCP Contracts", "skills://mcp/contracts", {
+    description: "Machine-readable MCP tool and resource contract manifest."
+  }, async () => ({
+    contents: [{
+      uri: "skills://mcp/contracts",
+      text: JSON.stringify(createMcpContractManifest(), null, 2),
+      mimeType: "application/json"
+    }]
+  }));
+  server.registerResource("Skills Registry", "skills://registry", {
+    description: "Compact default basic skill list [{name,category,pricing}]. Use list_skills with profile:'all' for the full registry, and skills://{name} for detail."
+  }, async () => ({
+    contents: [{
+      uri: "skills://registry",
+      text: JSON.stringify(loadRegistryProfile("basic").map(getCompactSkillDiscovery)),
+      mimeType: "application/json"
+    }]
+  }));
+  server.registerResource("Skill Info", new ResourceTemplate("skills://{name}", { list: undefined }), {
+    description: "Individual skill metadata and documentation"
+  }, async (uri, { name }) => {
+    const skill = getSkill(name);
+    const doc2 = getSkillBestDoc(name);
+    const reqs = getSkillRequirements(name);
+    const publicReqs = skill && reqs ? {
+      ...reqs,
+      envVars: publicDiscoveryEnvVars(skill.name, reqs.envVars),
+      dependencies: publicDiscoveryDependencies(skill.name, reqs.dependencies)
+    } : reqs;
     return {
-      name: bareName,
-      path: skillPath,
-      valid: false,
-      issues: sortMessages(issues),
-      warnings: sortMessages(warnings),
-      metadata
+      contents: [{
+        uri: uri.href,
+        text: JSON.stringify({
+          ...skill ? getPublicSkillDiscovery(skill) : {},
+          documentation: skill ? publicDiscoveryDocumentation(skill, doc2) : doc2,
+          requirements: publicReqs,
+          ...skill ? { mcp: createSkillMcpMetadata(getPublicSkillDiscovery(skill)) } : {}
+        }, null, 2),
+        mimeType: "application/json"
+      }]
     };
-  }
-  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`);
+  });
+  server.registerTool("search_tools", {
+    title: "Search Tools",
+    description: "List tool names or summaries, optionally filtered by keyword.",
+    inputSchema: { query: exports_external.string().optional(), detail: exports_external.boolean().optional() }
+  }, async ({ query, detail }) => {
+    const contracts2 = listMcpToolContracts(query);
+    const tools = detail ? contracts2.map(summarizeMcpToolContract) : contracts2.map((contract) => contract.name);
+    return mcpJson({ schemaVersion: 1, tools, total: tools.length });
+  });
+  server.registerTool("describe_tools", {
+    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()
     }
-    if (lstatSync(entryPath).isSymbolicLink()) {
-      add(issues, "skill.symlink_forbidden", `Symlink '${entry}' is not allowed in skill packages`);
+  }, 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 (!KNOWN_TOP_LEVEL_ENTRIES.has(entry)) {
-      add(warnings, "skill.file_unrecognized", `Unrecognized top-level skill entry '${entry}'`);
+    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 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 loadSchedules(targetDir = process.cwd()) {
+  const path = getSchedulesPath(targetDir);
+  if (existsSync12(path)) {
+    try {
+      return JSON.parse(readFileSync10(path, "utf-8"));
+    } catch {}
   }
-  for (const docFile of DOC_FILES) {
-    if (existsSync11(join11(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 = 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 { version: 1, schedules: [] };
+}
+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 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}` };
     }
-  } 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`);
-            }
-          }
-        }
-      }
-    } catch (error48) {
-      add(issues, "package.invalid_json", `package.json is invalid JSON: ${error48.message}`);
+  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 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 +34959,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
@@ -34232,6 +34969,266 @@ function registerScheduleTools(server) {
   });
 }
 
+// src/lib/native-storage.ts
+init_config();
+import { createHash as createHash2, createHmac } from "crypto";
+import {
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync11,
+  readdirSync as readdirSync6,
+  statSync as statSync5,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { dirname as dirname5, join as join13, normalize as normalize3, relative as relative3, sep } from "path";
+var SKILLS_STORAGE_TABLES = [
+  "skills_sync_records",
+  "skills_sync_cursors"
+];
+var SKILLS_NATIVE_STORAGE_ENV = {
+  mode: "HASNA_SKILLS_STORAGE_MODE",
+  databaseUrl: "HASNA_SKILLS_DATABASE_URL",
+  databaseSsl: "HASNA_SKILLS_DATABASE_SSL",
+  databaseSchema: "HASNA_SKILLS_DATABASE_SCHEMA",
+  s3Bucket: "HASNA_SKILLS_S3_BUCKET",
+  s3Prefix: "HASNA_SKILLS_S3_PREFIX",
+  awsRegion: "HASNA_SKILLS_AWS_REGION",
+  s3Endpoint: "HASNA_SKILLS_S3_ENDPOINT",
+  s3ForcePathStyle: "HASNA_SKILLS_S3_FORCE_PATH_STYLE",
+  s3AccessKeyId: "HASNA_SKILLS_S3_ACCESS_KEY_ID",
+  s3SecretAccessKey: "HASNA_SKILLS_S3_SECRET_ACCESS_KEY",
+  s3SessionToken: "HASNA_SKILLS_S3_SESSION_TOKEN",
+  syncBatchSize: "HASNA_SKILLS_SYNC_BATCH_SIZE",
+  dryRun: "HASNA_SKILLS_SYNC_DRY_RUN"
+};
+var SKILLS_NATIVE_STORAGE_FALLBACK_ENV = {
+  mode: "SKILLS_STORAGE_MODE",
+  databaseUrl: "SKILLS_DATABASE_URL",
+  databaseSsl: "SKILLS_DATABASE_SSL",
+  databaseSchema: "SKILLS_DATABASE_SCHEMA",
+  s3Bucket: "SKILLS_S3_BUCKET",
+  s3Prefix: "SKILLS_S3_PREFIX",
+  awsRegion: "SKILLS_AWS_REGION",
+  s3Endpoint: "SKILLS_S3_ENDPOINT",
+  s3ForcePathStyle: "SKILLS_S3_FORCE_PATH_STYLE",
+  s3AccessKeyId: "SKILLS_S3_ACCESS_KEY_ID",
+  s3SecretAccessKey: "SKILLS_S3_SECRET_ACCESS_KEY",
+  s3SessionToken: "SKILLS_S3_SESSION_TOKEN",
+  syncBatchSize: "SKILLS_SYNC_BATCH_SIZE",
+  dryRun: "SKILLS_SYNC_DRY_RUN"
+};
+function resolveSkillsNativeStorageConfig(env = process.env) {
+  const mode = getSkillsStorageMode(env);
+  return {
+    mode,
+    databaseUrl: getSkillsStorageDatabaseUrl(env),
+    databaseSsl: parseBoolean(readStorageEnv(env, "databaseSsl").value),
+    databaseSchema: readStorageEnv(env, "databaseSchema").value,
+    s3Bucket: readStorageEnv(env, "s3Bucket").value,
+    s3Prefix: readStorageEnv(env, "s3Prefix").value,
+    awsRegion: readStorageEnv(env, "awsRegion").value ?? "us-east-1",
+    s3Endpoint: readStorageEnv(env, "s3Endpoint").value,
+    s3ForcePathStyle: parseBoolean(readStorageEnv(env, "s3ForcePathStyle").value) ?? false,
+    syncBatchSize: parsePositiveInteger(readStorageEnv(env, "syncBatchSize").value) ?? 500,
+    dryRun: parseBoolean(readStorageEnv(env, "dryRun").value) ?? true
+  };
+}
+function resolveStorageConfig(env = process.env) {
+  return resolveSkillsNativeStorageConfig(env);
+}
+function getSkillsStorageMode(env = process.env) {
+  return parseMode(readStorageEnv(env, "mode").value);
+}
+function getSkillsStorageDatabaseUrl(env = process.env) {
+  return readStorageEnv(env, "databaseUrl").value;
+}
+function getSkillsNativeStorageStatus(options = {}) {
+  const env = options.env ?? process.env;
+  const config2 = resolveSkillsNativeStorageConfig(env);
+  const modeEnv = readStorageEnv(env, "mode");
+  const databaseEnv = readStorageEnv(env, "databaseUrl");
+  const s3BucketEnv = readStorageEnv(env, "s3Bucket");
+  const targetDir = options.targetDir ?? process.cwd();
+  return {
+    package: "open-skills",
+    mode: config2.mode,
+    tables: [...SKILLS_STORAGE_TABLES],
+    env: {
+      mode: SKILLS_NATIVE_STORAGE_ENV.mode,
+      databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+      s3Bucket: SKILLS_NATIVE_STORAGE_ENV.s3Bucket
+    },
+    local: {
+      dataDir: getDataDir(),
+      projectStateDir: getProjectStateDir(targetDir),
+      feedbackDbPath: join13(getDataDir(), "skills.db")
+    },
+    remote: {
+      databaseConfigured: Boolean(config2.databaseUrl),
+      s3Configured: Boolean(config2.s3Bucket),
+      databaseEnv: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+      s3BucketEnv: SKILLS_NATIVE_STORAGE_ENV.s3Bucket,
+      activeModeEnv: modeEnv.name,
+      activeDatabaseEnv: databaseEnv.name,
+      activeS3BucketEnv: s3BucketEnv.name,
+      region: config2.awsRegion ?? "us-east-1",
+      dryRun: config2.dryRun
+    }
+  };
+}
+function getStorageStatus(options = {}) {
+  return getSkillsNativeStorageStatus(options);
+}
+function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
+  const projectStateDir = getProjectStateDir(targetDir);
+  const files = [];
+  if (existsSync13(projectStateDir)) {
+    for (const filePath of walkFiles2(projectStateDir)) {
+      const bytes = readFileSync11(filePath);
+      const relativePath = toPosix(relative3(targetDir, filePath));
+      files.push({
+        path: relativePath,
+        sizeBytes: bytes.byteLength,
+        sha256: createHash2("sha256").update(bytes).digest("hex"),
+        ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
+      });
+    }
+  }
+  return {
+    schemaVersion: 1,
+    exportedAt: new Date().toISOString(),
+    files: files.sort((a, b) => a.path.localeCompare(b.path))
+  };
+}
+var skillsPostgresSyncSchemaSql = `
+CREATE TABLE IF NOT EXISTS skills_sync_records (
+  scope TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  id TEXT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  deleted_at TIMESTAMPTZ,
+  source TEXT,
+  payload JSONB NOT NULL,
+  PRIMARY KEY (scope, kind, id)
+);
+
+CREATE INDEX IF NOT EXISTS skills_sync_records_updated_at_idx
+  ON skills_sync_records (updated_at);
+
+CREATE TABLE IF NOT EXISTS skills_sync_cursors (
+  scope TEXT NOT NULL,
+  cursor_name TEXT NOT NULL,
+  value TEXT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (scope, cursor_name)
+);
+`.trim();
+function planSkillsS3SnapshotUpload(snapshot, options = {}) {
+  const prefix = normalizeS3Prefix(options.prefix);
+  return snapshot.files.map((file2) => ({
+    path: file2.path,
+    key: [prefix, file2.path.replace(/^\.?\//, "")].filter(Boolean).join("/"),
+    sizeBytes: file2.sizeBytes,
+    sha256: file2.sha256
+  }));
+}
+function parseMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "remote" || normalized === "hybrid")
+    return normalized;
+  return "local";
+}
+function readStorageEnv(env, key) {
+  const primaryName = SKILLS_NATIVE_STORAGE_ENV[key];
+  const primaryValue = cleanOptional(env[primaryName]);
+  if (primaryValue !== undefined)
+    return { name: primaryName, value: primaryValue };
+  const fallbackName = SKILLS_NATIVE_STORAGE_FALLBACK_ENV[key];
+  const fallbackValue = cleanOptional(env[fallbackName]);
+  if (fallbackValue !== undefined)
+    return { name: fallbackName, value: fallbackValue };
+  return { name: primaryName };
+}
+function cleanOptional(value) {
+  const cleaned = value?.trim();
+  return cleaned ? cleaned : undefined;
+}
+function parseBoolean(value) {
+  if (value === undefined)
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized))
+    return true;
+  if (["0", "false", "no", "off"].includes(normalized))
+    return false;
+  return;
+}
+function parsePositiveInteger(value) {
+  if (!value)
+    return;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function walkFiles2(dir) {
+  const files = [];
+  for (const entry of readdirSync6(dir)) {
+    const full = join13(dir, entry);
+    const stats = statSync5(full);
+    if (stats.isDirectory())
+      files.push(...walkFiles2(full));
+    else
+      files.push(full);
+  }
+  return files;
+}
+function normalizeS3Prefix(prefix) {
+  return (prefix ?? "").trim().replace(/^\/+|\/+$/g, "");
+}
+function toPosix(path) {
+  return path.split(/[\\/]+/).join("/");
+}
+
+// src/mcp/storage-tools.ts
+function registerStorageTools(server) {
+  server.registerTool("storage_status", {
+    title: "Storage Status",
+    description: "Show local-first storage paths and optional repo-owned Postgres/S3 readiness.",
+    inputSchema: {
+      directory: exports_external.string().optional()
+    }
+  }, async ({ directory }) => {
+    return mcpJson(getStorageStatus({ targetDir: directory || process.cwd() }), true);
+  });
+  server.registerTool("storage_sync_plan", {
+    title: "Storage Sync Plan",
+    description: "Plan .skills snapshot sync for optional Postgres/S3 storage without network access.",
+    inputSchema: {
+      directory: exports_external.string().optional(),
+      includeSchemaSql: exports_external.boolean().optional()
+    }
+  }, async ({ directory, includeSchemaSql }) => {
+    const targetDir = directory || process.cwd();
+    const config2 = resolveStorageConfig();
+    const snapshot = exportSkillsLocalSnapshot(targetDir, { includeFileContents: false });
+    const s3Plan = config2.s3Bucket ? planSkillsS3SnapshotUpload(snapshot, { prefix: config2.s3Prefix }) : [];
+    return mcpJson({
+      package: "open-skills",
+      noNetwork: true,
+      mode: config2.mode,
+      databaseConfigured: Boolean(config2.databaseUrl),
+      s3Configured: Boolean(config2.s3Bucket),
+      snapshotFileCount: snapshot.files.length,
+      s3ObjectCount: s3Plan.length,
+      env: {
+        mode: SKILLS_NATIVE_STORAGE_ENV.mode,
+        databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
+        s3Bucket: SKILLS_NATIVE_STORAGE_ENV.s3Bucket
+      },
+      ...includeSchemaSql ? { schemaSql: skillsPostgresSyncSchemaSql } : {}
+    }, true);
+  });
+}
+
 // src/mcp/server.ts
 function buildServer() {
   const server = new McpServer({
@@ -34241,6 +35238,7 @@ function buildServer() {
   registerDiscoveryTools(server);
   registerOperationTools(server);
   registerScheduleTools(server);
+  registerStorageTools(server);
   registerResourceMetaTools(server);
   return server;
 }