@hasna/skills 0.1.71 → 0.2.0

package/bin/mcp.js

@@ -6679,10 +6679,114 @@ var init_retired_settings = __esm(() => {
   };
 });
 
-// src/lib/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join, dirname } from "path";
+// src/lib/app-home.ts
+import { existsSync } from "fs";
 import { homedir } from "os";
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return pathsResolverResolve("data", options);
+}
+function effectiveHome() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir() || "/tmp";
+}
+function legacyDataRoot() {
+  return join(effectiveHome(), ".hasna", "skills");
+}
+function resolverDataRoot(home = effectiveHome(), env) {
+  return dataDir({ app: "skills", home, env });
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join(resolved, GLOBAL_CONFIG_FILENAME));
+}
+function exactDataRoot() {
+  for (const key of [DATA_DIR_ENV, HASNA_SKILLS_HOME_ENV, SKILLS_HOME_ENV]) {
+    const dir = process.env[key]?.trim();
+    if (dir)
+      return resolve(dir);
+  }
+  return;
+}
+function hasExactOverride(env = process.env) {
+  return Boolean(env[DATA_DIR_ENV]?.trim()) || Boolean(env[HASNA_SKILLS_HOME_ENV]?.trim()) || Boolean(env[SKILLS_HOME_ENV]?.trim());
+}
+function hasOperatorOverride(env = process.env) {
+  return hasExactOverride(env) || Boolean(env.HASNA_DATA_HOME?.trim());
+}
+function getDataRoot() {
+  const exact = exactDataRoot();
+  if (exact)
+    return exact;
+  const resolved = resolverDataRoot();
+  return adoptResolverDataRoot(resolved) ? resolve(resolved) : resolve(legacyDataRoot());
+}
+var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE, DATA_DIR_ENV = "HASNA_SKILLS_DIR", HASNA_SKILLS_HOME_ENV = "HASNA_SKILLS_HOME", SKILLS_HOME_ENV = "SKILLS_HOME", DEFAULT_SQLITE_FILENAME = "server.db", GLOBAL_CONFIG_FILENAME = "config.json";
+var init_app_home = __esm(() => {
+  PATHS_RESOLVER_KIND_ENV = {
+    config: "HASNA_CONFIG_HOME",
+    data: "HASNA_DATA_HOME",
+    state: "HASNA_STATE_HOME",
+    cache: "HASNA_CACHE_HOME"
+  };
+  PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+});
+
+// src/lib/config.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
 function validKeys() {
   return [...Object.keys(ENUM_KEYS), ...STRING_KEYS];
 }
@@ -6690,19 +6794,19 @@ function allowedValues(key) {
   return ENUM_KEYS[key];
 }
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync(sourceDir))
+  if (!existsSync2(sourceDir))
     return;
   mkdirSync(targetDir, { recursive: true });
   for (const entry of readdirSync(sourceDir)) {
-    const sourcePath = join(sourceDir, entry);
-    const targetPath = join(targetDir, entry);
+    const sourcePath = join2(sourceDir, entry);
+    const targetPath = join2(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync(targetPath))
+      if (!existsSync2(targetPath))
         copyFileSync(sourcePath, targetPath);
     } catch {}
   }
@@ -6728,48 +6832,42 @@ function normalizeConfigValue(key, value) {
   return;
 }
 function isOwnerLayoutMigrated(appDir) {
-  return existsSync(join(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+  return existsSync2(join2(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
 }
 function getDataDir() {
-  const override = process.env[DATA_DIR_ENV];
-  if (override) {
-    try {
-      mkdirSync(override, { recursive: true });
-    } catch {}
-    return override;
-  }
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const newDir = join(home, ".hasna", "skills");
-  const oldDir = join(home, ".skills");
-  const oldConfigFile = join(home, ".skillsrc");
-  mkdirSync(newDir, { recursive: true });
+  const root = getDataRoot();
+  try {
+    mkdirSync(root, { recursive: true });
+  } catch {}
+  if (hasOperatorOverride())
+    return root;
+  const home = effectiveHome();
+  const oldDir = join2(home, ".skills");
+  const oldConfigFile = join2(home, ".skillsrc");
   try {
-    mergeDirectoryContents(oldDir, newDir);
+    mergeDirectoryContents(oldDir, root);
   } catch {}
-  if (existsSync(oldConfigFile) && !existsSync(join(newDir, "config.json"))) {
+  if (existsSync2(oldConfigFile) && !existsSync2(join2(root, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join(newDir, "config.json"));
+      copyFileSync(oldConfigFile, join2(root, "config.json"));
     } catch {}
   }
-  return newDir;
+  return root;
 }
 function getDataDirReadOnly() {
-  const override = process.env[DATA_DIR_ENV];
-  if (override)
-    return override;
-  return join(process.env["HOME"] || process.env["USERPROFILE"] || homedir(), ".hasna", "skills");
+  return getDataRoot();
 }
 function getConfigPathReadOnly(scope) {
   if (scope === "global")
-    return join(getDataDirReadOnly(), "config.json");
-  return join(process.cwd(), "skills.config.json");
+    return join2(getDataDirReadOnly(), "config.json");
+  return join2(process.cwd(), "skills.config.json");
 }
 function loadConfigReadOnly() {
   const canonicalConfigPath = getConfigPathReadOnly("global");
   let globalConfig2;
-  if (existsSync(canonicalConfigPath)) {
+  if (existsSync2(canonicalConfigPath)) {
     globalConfig2 = readConfigFile(canonicalConfigPath);
-  } else if (process.env[DATA_DIR_ENV] !== undefined) {
+  } else if (hasOperatorOverride()) {
     globalConfig2 = {};
   } else {
     globalConfig2 = readConfigFile(legacyConfigFilePath());
@@ -6778,16 +6876,16 @@ function loadConfigReadOnly() {
   return { ...globalConfig2, ...projectConfig };
 }
 function legacyConfigFilePath() {
-  return join(process.env["HOME"] || process.env["USERPROFILE"] || homedir(), ".skillsrc");
+  return join2(process.env["HOME"] || process.env["USERPROFILE"] || homedir2(), ".skillsrc");
 }
 function getConfigPath(scope) {
   if (scope === "global") {
-    return join(getDataDir(), "config.json");
+    return join2(getDataDir(), "config.json");
   }
-  return join(process.cwd(), "skills.config.json");
+  return join2(process.cwd(), "skills.config.json");
 }
 function readConfigFile(path) {
-  if (!existsSync(path))
+  if (!existsSync2(path))
     return {};
   let parsed;
   try {
@@ -6811,9 +6909,11 @@ function loadConfig() {
   const projectConfig = readConfigFile(getConfigPath("project"));
   return { ...globalConfig2, ...projectConfig };
 }
-var ENUM_KEYS, STRING_KEYS, DATA_DIR_ENV = "HASNA_SKILLS_DIR", INSTALLED_SKILLS_DIRNAME = "installed", SKILLS_CACHE_DIRNAME = "skills", LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
+var ENUM_KEYS, STRING_KEYS, INSTALLED_SKILLS_DIRNAME = "installed", SKILLS_CACHE_DIRNAME = "skills", LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
 var init_config = __esm(() => {
   init_retired_settings();
+  init_app_home();
+  init_app_home();
   ENUM_KEYS = {
     defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
     defaultScope: ["global", "project"],
@@ -6905,23 +7005,23 @@ __export(exports_auth_store, {
   getApiKey: () => getApiKey,
   clearAuthConfig: () => clearAuthConfig
 });
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, unlinkSync } from "fs";
-import { dirname as dirname5, join as join12 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, unlinkSync } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
+import { homedir as homedir4 } from "os";
 function getAuthFilePath() {
-  return join12(getDataDir(), "auth.json");
+  return join13(getDataDir(), "auth.json");
 }
 function getAuthFilePathReadOnly() {
-  return join12(getDataDirReadOnly(), "auth.json");
+  return join13(getDataDirReadOnly(), "auth.json");
 }
 function legacyAuthFilePath() {
-  return join12(process.env["HOME"] || process.env["USERPROFILE"] || homedir3(), ".skills", "auth.json");
+  return join13(process.env["HOME"] || process.env["USERPROFILE"] || homedir4(), ".skills", "auth.json");
 }
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const file = existsSync12(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
+    const file = existsSync13(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
     const raw = readFileSync11(file, "utf-8");
     const config2 = JSON.parse(raw);
     if (!config2.apiKey) {
@@ -6960,7 +7060,7 @@ function getApiKey() {
 }
 function getAuthConfigReadOnly() {
   try {
-    const file = existsSync12(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
+    const file = existsSync13(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
     const raw = readFileSync11(file, "utf-8");
     const config2 = JSON.parse(raw);
     if (!config2.apiKey)
@@ -7247,12 +7347,30 @@ class RemoteSkillsClient {
   async downloadSkillBundle(slug) {
     return this.request(`/api/v1/skills/${encodeURIComponent(slug)}/bundle`, { method: "GET" });
   }
-  async getBundle(slug) {
-    const response = await this.request(`/api/v1/skills/${encodeURIComponent(slug)}/bundle`, { method: "GET" });
+  async getBundle(slug, version2) {
+    const path = version2 ? `/api/v1/skills/${encodeURIComponent(slug)}/versions/${encodeURIComponent(version2)}/bundle` : `/api/v1/skills/${encodeURIComponent(slug)}/bundle`;
+    const response = await this.request(path, { method: "GET" });
     if (response.status === 404)
       return null;
     return response;
   }
+  async listSkillVersions(slug) {
+    const response = await this.requestNewRoute(`/api/v1/skills/${encodeURIComponent(slug)}/versions`, undefined, { domainNotFoundCodes: ["SKILL_NOT_FOUND"] });
+    if (response.status === 404)
+      return [];
+    if (!response.ok)
+      throw new Error(`versions request failed: ${response.status}`);
+    const body = await response.json();
+    return Array.isArray(body.versions) ? body.versions : [];
+  }
+  async getSkillVersion(slug, version2) {
+    const response = await this.requestNewRoute(`/api/v1/skills/${encodeURIComponent(slug)}/versions/${encodeURIComponent(version2)}`, undefined, { domainNotFoundCodes: ["SKILL_NOT_FOUND", "SKILL_VERSION_NOT_FOUND"] });
+    if (response.status === 404)
+      return null;
+    if (!response.ok)
+      throw new Error(`version request failed: ${response.status}`);
+    return await response.json();
+  }
   async listPins() {
     const response = await this.requestNewRoute("/api/v1/pins");
     return normalizePinList(await response.json());
@@ -12943,7 +13061,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.71",
+  version: "0.2.0",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -13023,7 +13141,7 @@ var package_default = {
   author: "Hasna",
   license: "Apache-2.0",
   devDependencies: {
-    "@types/bun": "latest",
+    "@types/bun": "1.3.14",
     "@types/node": "25.2.3",
     "@types/react": "^18.2.0",
     "bun-types": "1.3.14",
@@ -20887,14 +21005,14 @@ var EMPTY_COMPLETION_RESULT = {
 
 // src/lib/registry.ts
 init_config();
-import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync6 } from "fs";
+import { join as join8 } from "path";
 
 // src/lib/portable-skills.ts
 init_config();
 import {
   cpSync as cpSync2,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync3,
   mkdtempSync,
   readdirSync as readdirSync5,
@@ -20903,7 +21021,7 @@ import {
   statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join6, normalize as normalize2 } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join7, normalize as normalize2 } from "path";
 
 // src/lib/registry-data/development-tools.ts
 var DEVELOPMENT_TOOLS_SKILLS = [
@@ -21117,14 +21235,6 @@ var DEVELOPMENT_TOOLS_SKILLS = [
     category: "Development Tools",
     tags: ["storage", "backend", "postgresql", "sqlite", "two-backend", "oss-app"],
     kind: "instruction"
-  },
-  {
-    name: "session-inject-monitor",
-    displayName: "Session Inject Monitor",
-    description: "Set up a declarative monitor that injects a prompt into a live coding-agent session when a watched source (conversations, email, todos, knowledge, command output) has new content",
-    category: "Development Tools",
-    tags: ["monitor", "session", "injection", "automation", "wake"],
-    kind: "instruction"
   }
 ];
 
@@ -21623,8 +21733,8 @@ var SKILLS = [
 ];
 
 // src/lib/hosted-skill-set.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
 var HOSTED_RUNTIMES = new Set(["hosted"]);
 var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
 function normalizeMarker(value) {
@@ -21637,8 +21747,8 @@ function isHostedMetadataPackage(pkg) {
   return HOSTED_RUNTIMES.has(normalizeMarker(skills.runtime)) || HOSTED_SOURCES.has(normalizeMarker(skills.source));
 }
 function isHostedMetadataSkillDir(skillDir) {
-  const pkgPath = join2(skillDir, "package.json");
-  if (!existsSync2(pkgPath))
+  const pkgPath = join3(skillDir, "package.json");
+  if (!existsSync3(pkgPath))
     return false;
   try {
     return isHostedMetadataPackage(JSON.parse(readFileSync2(pkgPath, "utf8")));
@@ -21662,8 +21772,8 @@ var BRACE_SOURCE_EXCLUSION = new RegExp(`^!skills/\\{(${SLUG}(?:,${SLUG})+)\\}/s
 var SINGLE_SOURCE_EXCLUSION = new RegExp(`^!skills/(${SLUG})/src$`);
 
 // src/lib/skill-validation.ts
-import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { isAbsolute, join as join3, normalize } from "path";
+import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join4, normalize } from "path";
 var VALID_SKILL_KINDS = ["executable", "instruction"];
 var DOC_FILES = ["SKILL.md", "README.md", "CLAUDE.md"];
 var RESERVED_SKILL_ENTRIES = new Set([
@@ -21801,7 +21911,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     binCommands: [],
     docFiles: []
   };
-  if (!existsSync3(skillPath)) {
+  if (!existsSync4(skillPath)) {
     add(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
     return {
       name: bareName,
@@ -21816,7 +21926,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     add(issues, "skill.name_invalid", `Skill name '${bareName}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
   }
   for (const entry of readdirSync3(skillPath).sort()) {
-    const entryPath = join3(skillPath, entry);
+    const entryPath = join4(skillPath, entry);
     if (RESERVED_SKILL_ENTRIES.has(entry)) {
       add(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
     }
@@ -21828,14 +21938,14 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync3(join3(skillPath, docFile)))
+    if (existsSync4(join4(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 = join3(skillPath, "SKILL.md");
-  if (existsSync3(skillMdPath)) {
+  const skillMdPath = join4(skillPath, "SKILL.md");
+  if (existsSync4(skillMdPath)) {
     const frontmatter = parseSkillFrontmatter(readFileSync3(skillMdPath, "utf-8"));
     if (!frontmatter) {
       add(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
@@ -21878,8 +21988,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join3(skillPath, "package.json");
-  if (!existsSync3(pkgPath)) {
+  const pkgPath = join4(skillPath, "package.json");
+  if (!existsSync4(pkgPath)) {
     if (!isInstruction)
       add(issues, "package.missing", "Missing package.json");
   } else {
@@ -21937,8 +22047,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
               add(issues, "package.bin_target_unsafe", `package.json bin '${command}' target '${target}' must stay inside the skill directory`);
               continue;
             }
-            const targetPath = join3(skillPath, target);
-            if (!existsSync3(targetPath)) {
+            const targetPath = join4(skillPath, target);
+            if (!existsSync4(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`);
@@ -21955,17 +22065,17 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join3(skillPath, "src");
+    const srcDir = join4(skillPath, "src");
     if (hostedMetadata) {
-      if (existsSync3(srcDir)) {
+      if (existsSync4(srcDir)) {
         add(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
       }
-    } else if (!existsSync3(srcDir)) {
+    } else if (!existsSync4(srcDir)) {
       add(issues, "skill.src_missing", "Missing src/ directory");
-    } else if (!existsSync3(join3(srcDir, "index.ts")) && !existsSync3(join3(srcDir, "index.js"))) {
+    } else if (!existsSync4(join4(srcDir, "index.ts")) && !existsSync4(join4(srcDir, "index.js"))) {
       add(issues, "skill.src_index_missing", "Missing src/index.ts or src/index.js");
     } else {
-      const indexPath = existsSync3(join3(srcDir, "index.ts")) ? join3(srcDir, "index.ts") : join3(srcDir, "index.js");
+      const indexPath = existsSync4(join4(srcDir, "index.ts")) ? join4(srcDir, "index.ts") : join4(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)`);
@@ -21983,8 +22093,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
 
 // src/lib/skill-hash.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import { join as join4, sep } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { join as join5, sep } from "path";
 var CONTENT_HASH_ALGORITHM = "sha256";
 var HASH_EXCLUDE_DIRS = new Set([".git", "node_modules", "dist", "build", ".turbo"]);
 var HASH_COVERAGE = [
@@ -22043,8 +22153,8 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join4(skillPath, entry);
-    if (!existsSync4(absolute))
+    const absolute = join5(skillPath, entry);
+    if (!existsSync5(absolute))
       continue;
     if (statSync4(absolute).isDirectory())
       collectDirectory(files, absolute, entry);
@@ -22057,7 +22167,7 @@ function collectDirectory(files, dir, rel) {
   for (const entry of readdirSync4(dir).sort()) {
     if (entry.startsWith("."))
       continue;
-    const absolute = join4(dir, entry);
+    const absolute = join5(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
@@ -22277,14 +22387,14 @@ function validateRuntimeContract(manifest, issues, strict) {
 // src/lib/portable-skills-files.ts
 import {
   cpSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync5,
   realpathSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join5, relative } from "path";
+import { basename, dirname as dirname2, join as join6, relative } from "path";
 var ANY_SEGMENT_COPY_EXCLUDES = new Set([
   ".git",
   ".DS_Store",
@@ -22327,12 +22437,12 @@ function normalizePortableSkillName(name) {
   return normalized;
 }
 function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
-  const skillJsonPath = join5(skillPath, "skill.json");
-  const skillMdPath = join5(skillPath, "SKILL.md");
-  const pkgPath = join5(skillPath, "package.json");
-  const jsonManifest = existsSync5(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync5(skillMdPath) ? parseSkillFrontmatter(readFileSync5(skillMdPath, "utf-8")) ?? undefined : undefined;
-  const pkg = existsSync5(pkgPath) ? readJsonObject(pkgPath) : undefined;
+  const skillJsonPath = join6(skillPath, "skill.json");
+  const skillMdPath = join6(skillPath, "SKILL.md");
+  const pkgPath = join6(skillPath, "package.json");
+  const jsonManifest = existsSync6(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
+  const frontmatter = existsSync6(skillMdPath) ? parseSkillFrontmatter(readFileSync5(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const pkg = existsSync6(pkgPath) ? readJsonObject(pkgPath) : undefined;
   const 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;
@@ -22378,7 +22488,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join5(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join6(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -22427,12 +22537,12 @@ function createPortableManifest(name, options) {
   };
 }
 function writePortableSkillTemplate(skillPath, manifest) {
-  mkdirSync2(join5(skillPath, "src"), { recursive: true });
-  writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync2(join5(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync2(join5(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+  mkdirSync2(join6(skillPath, "src"), { recursive: true });
+  writeFileSync2(join6(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync2(join6(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync2(join6(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync2(join6(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync2(join6(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -22457,7 +22567,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync2(join6(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash = computeContentHash(skillPath);
   const withHash = {
@@ -22467,13 +22577,13 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync2(join6(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
 `);
   return withHash;
 }
 function readExistingSkillJson(skillPath) {
-  const path = join5(skillPath, "skill.json");
-  if (!existsSync5(path))
+  const path = join6(skillPath, "skill.json");
+  if (!existsSync6(path))
     return {};
   try {
     const parsed = JSON.parse(readFileSync5(path, "utf-8"));
@@ -22506,28 +22616,28 @@ function ensurePortableSkillFiles(skillPath, manifest) {
     tags: next.tags?.length ? next.tags : ["custom", next.name]
   };
   const entry = next.commands[0]?.entry ?? "src/index.ts";
-  if (entry && !existsSync5(join5(skillPath, entry))) {
-    mkdirSync2(dirname2(join5(skillPath, entry)), { recursive: true });
-    writeFileSync2(join5(skillPath, entry), renderEntrypoint(next));
+  if (entry && !existsSync6(join6(skillPath, entry))) {
+    mkdirSync2(dirname2(join6(skillPath, entry)), { recursive: true });
+    writeFileSync2(join6(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync5(join5(skillPath, "SKILL.md")))
-    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync6(join6(skillPath, "SKILL.md")))
+    writeFileSync2(join6(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync2(join5(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync5(join5(skillPath, "SKILL.md"), "utf-8"), next));
-  if (!existsSync5(join5(skillPath, "AGENTS.md")))
-    writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(next));
+    writeFileSync2(join6(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync5(join6(skillPath, "SKILL.md"), "utf-8"), next));
+  if (!existsSync6(join6(skillPath, "AGENTS.md")))
+    writeFileSync2(join6(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
-  if (!existsSync5(join5(skillPath, "tsconfig.json")))
-    writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
+  if (!existsSync6(join6(skillPath, "tsconfig.json")))
+    writeFileSync2(join6(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
 function ensurePackageJson(skillPath, manifest) {
-  const pkgPath = join5(skillPath, "package.json");
+  const pkgPath = join6(skillPath, "package.json");
   const first = manifest.commands[0] ?? { name: manifest.name, entry: "src/index.ts" };
   const commandName = normalizePortableSkillName(first.name || manifest.name);
   const entry = (first.entry ?? "src/index.ts").replace(/^\.\//, "");
-  if (!existsSync5(pkgPath)) {
+  if (!existsSync6(pkgPath)) {
     writeFileSync2(pkgPath, renderPackageJson(manifest));
     return;
   }
@@ -22570,8 +22680,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync5(join5(skillPath, "SKILL.md"))) {
-    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync6(join6(skillPath, "SKILL.md"))) {
+    writeFileSync2(join6(skillPath, "SKILL.md"), renderSkillMd(next));
   }
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
@@ -22854,18 +22964,18 @@ var LEGACY_CUSTOM_DIRNAME = "custom";
 function getPortableSkillsRoot(options = {}) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join6(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache = join6(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join7(options.homeDir, ".hasna", "skills") : getDataDir();
+  const cache = join7(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
     return cache;
-  const installed = join6(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join7(appDir, INSTALLED_SKILLS_DIRNAME);
   migrateLegacySkillLayout(appDir, installed);
   return installed;
 }
 function looksLikeSkillDirectory(path) {
   if (!safeIsDirectory(path))
     return false;
-  return existsSync6(join6(path, "SKILL.md")) || existsSync6(join6(path, "skill.json")) || existsSync6(join6(path, "package.json"));
+  return existsSync7(join7(path, "SKILL.md")) || existsSync7(join7(path, "skill.json")) || existsSync7(join7(path, "package.json"));
 }
 function migrateLegacySkillLayout(appDir, installed) {
   if (!safeIsDirectory(appDir))
@@ -22875,7 +22985,7 @@ function migrateLegacySkillLayout(appDir, installed) {
     for (const entry of readdirSync5(appDir)) {
       if (entry.startsWith(".") || entry === INSTALLED_SKILLS_DIRNAME)
         continue;
-      const path = join6(appDir, entry);
+      const path = join7(appDir, entry);
       if (entry === LEGACY_CUSTOM_DIRNAME) {
         if (!safeIsDirectory(path))
           continue;
@@ -22883,7 +22993,7 @@ function migrateLegacySkillLayout(appDir, installed) {
           for (const nested of readdirSync5(path)) {
             if (nested.startsWith("."))
               continue;
-            const nestedPath = join6(path, nested);
+            const nestedPath = join7(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -22897,10 +23007,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join6(installed, name);
-    if (existsSync6(target))
+    const target = join7(installed, name);
+    if (existsSync7(target))
       continue;
-    const staging = join6(installed, `.migrating-${name}-${process.pid}`);
+    const staging = join7(installed, `.migrating-${name}-${process.pid}`);
     try {
       rmSync(staging, { recursive: true, force: true });
       cpSync2(from, staging, { recursive: true, errorOnExist: false });
@@ -22913,7 +23023,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join6(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join7(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -22923,7 +23033,7 @@ function findPortableSkill(name, options = {}) {
     return null;
   }
   const path = getPortableSkillPath(normalized, options);
-  if (!existsSync6(path) || !statSync6(path).isDirectory())
+  if (!existsSync7(path) || !statSync6(path).isDirectory())
     return null;
   try {
     return summarizePortableSkill(path, normalized);
@@ -22939,7 +23049,7 @@ function listPortableSkills(options = {}) {
   for (const entry of readdirSync5(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join6(root, entry);
+    const path = join7(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -22973,8 +23083,8 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizePortableSkillName(name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join6(root, skillName);
-  if (existsSync6(skillPath)) {
+  const skillPath = join7(root, skillName);
+  if (existsSync7(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
     rmSync(skillPath, { recursive: true, force: true });
@@ -22992,7 +23102,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize2(sourcePath);
-  if (!existsSync6(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
+  if (!existsSync7(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Skill source directory not found: ${sourcePath}`);
   }
   const inferred = readPortableSkillManifest(absoluteSource, basename2(absoluteSource));
@@ -23004,8 +23114,8 @@ function portPortableSkill(sourcePath, options = {}) {
     throw new Error(`${via} Importing it would shadow the official '${skillName}'. ` + `Pass --name to choose a different name, or --allow-shadow to override deliberately.`);
   }
   const root = getPortableSkillsRoot(options);
-  const destination = join6(root, skillName);
-  if (existsSync6(destination)) {
+  const destination = join7(root, skillName);
+  if (existsSync7(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync(destination, { recursive: true, force: true });
@@ -23033,10 +23143,10 @@ function validatePortableSkillDirectory(name, skillPath) {
   const issues = [...base.issues];
   const warnings = [...base.warnings];
   let manifest;
-  if (existsSync6(skillPath)) {
-    const skillJsonPath = join6(skillPath, "skill.json");
-    const skillMdPath = join6(skillPath, "SKILL.md");
-    if (!existsSync6(skillJsonPath) && !existsSync6(skillMdPath)) {
+  if (existsSync7(skillPath)) {
+    const skillJsonPath = join7(skillPath, "skill.json");
+    const skillMdPath = join7(skillPath, "SKILL.md");
+    if (!existsSync7(skillJsonPath) && !existsSync7(skillMdPath)) {
       add3(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
     try {
@@ -23055,7 +23165,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add3(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync6(join6(skillPath, "skill.json")),
+        strict: existsSync7(join7(skillPath, "skill.json")),
         skillPath
       });
       for (const issue2 of contractIssues)
@@ -23091,8 +23201,8 @@ function validatePortableSkillDirectory(name, skillPath) {
               add3(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
               continue;
             }
-            const entryPath = join6(skillPath, command.entry);
-            if (!existsSync6(entryPath))
+            const entryPath = join7(skillPath, command.entry);
+            if (!existsSync7(entryPath))
               add3(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
             else if (statSync6(entryPath).isDirectory())
               add3(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
@@ -23102,7 +23212,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error2) {
       add3(issues, "portable.manifest_invalid", error2.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync6(join6(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync7(join7(skillPath, "AGENTS.md"))) {
       add3(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -23360,7 +23470,7 @@ function parseSkillMdFrontmatter(content) {
   return Object.keys(result).length > 0 ? result : null;
 }
 function discoverSkillsInDir(dir, source = "custom") {
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     return [];
   const result = [];
   try {
@@ -23368,8 +23478,8 @@ function discoverSkillsInDir(dir, source = "custom") {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join7(dir, entry.name, "SKILL.md");
-      if (!existsSync7(skillMdPath))
+      const skillMdPath = join8(dir, entry.name, "SKILL.md");
+      if (!existsSync8(skillMdPath))
         continue;
       let content;
       try {
@@ -23388,7 +23498,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
-        ...isHostedMetadataSkillDir(join7(dir, entry.name)) ? { serverOwned: true } : {},
+        ...isHostedMetadataSkillDir(join8(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -23397,16 +23507,16 @@ function discoverSkillsInDir(dir, source = "custom") {
 }
 function findExtensionSkillPath(name) {
   const config2 = loadConfig();
-  if (!config2.extensionsDir || !existsSync7(config2.extensionsDir))
+  if (!config2.extensionsDir || !existsSync8(config2.extensionsDir))
     return null;
   try {
     const entries = readdirSync6(config2.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join7(config2.extensionsDir, entry.name);
-      const skillMdPath = join7(skillDir, "SKILL.md");
-      if (!existsSync7(skillMdPath))
+      const skillDir = join8(config2.extensionsDir, entry.name);
+      const skillMdPath = join8(skillDir, "SKILL.md");
+      if (!existsSync8(skillMdPath))
         continue;
       let content;
       try {
@@ -23438,12 +23548,12 @@ function loadRegistry(cwd) {
   if (registryCache && registryCacheKey === rootKey && now - registryCacheTime < REGISTRY_CACHE_TTL) {
     return registryCache;
   }
-  const dataDir = getDataDir();
+  const dataDir2 = getDataDir();
   const config2 = loadConfig();
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
   const extensions = config2.extensionsDir ? discoverSkillsInDir(config2.extensionsDir, "extension") : [];
   const portableCustom = listPortableSkillMetas();
-  const legacyCustom = discoverSkillsInDir(join7(dataDir, "custom"));
+  const legacyCustom = discoverSkillsInDir(join8(dataDir2, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now;
@@ -23479,9 +23589,9 @@ function mergeCustomSkills(skills) {
 }
 
 // src/lib/installer.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, rmSync as rmSync2 } from "fs";
-import { dirname as dirname4, join as join9 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync as rmSync2 } from "fs";
+import { dirname as dirname4, join as join10 } from "path";
+import { homedir as homedir3 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/home-migration.ts
@@ -23497,8 +23607,8 @@ function normalizeSkillName(name) {
 init_config();
 
 // src/lib/project-state.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
   "custom",
@@ -23513,14 +23623,14 @@ var SKILLS_PROJECT_DIR = ".skills";
 var PROJECT_CONFIG_FILE = "project.json";
 var DEFAULT_EXPORT_DIR = ".skills/exports";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join8(targetDir, SKILLS_PROJECT_DIR);
+  return join9(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join8(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join9(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return null;
   try {
     return normalizeProjectConfig(JSON.parse(readFileSync7(path, "utf-8")));
@@ -23622,12 +23732,12 @@ var __dirname2 = dirname4(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join9(dir, "skills");
-    if (existsSync9(candidate) && !dir.includes(".skills"))
+    const candidate = join10(dir, "skills");
+    if (existsSync10(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname4(dir);
   }
-  return join9(__dirname2, "..", "skills");
+  return join10(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
@@ -23635,13 +23745,13 @@ function getSkillPath(name) {
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join9(getDataDir(), "custom", skillName);
-  if (existsSync9(legacyCustomPath))
+  const legacyCustomPath = join10(getDataDir(), "custom", skillName);
+  if (existsSync10(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join9(SKILLS_DIR, skillName);
+  return join10(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
@@ -23650,7 +23760,7 @@ function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync9(getSkillPath(name))) {
+  if (!existsSync10(getSkillPath(name))) {
     const knownOfficial = Boolean(getSkill(name));
     return {
       skill: canonicalName,
@@ -23705,11 +23815,11 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join9(base, ".pi", "skills") : join9(homedir2(), ".pi", "agent", "skills");
+      return scope === "project" ? join10(base, ".pi", "skills") : join10(homedir3(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join9(base, ".opencode", "skills") : join9(homedir2(), ".config", "opencode", "skills");
+      return scope === "project" ? join10(base, ".opencode", "skills") : join10(homedir3(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join9(base, `.${agent}`, "skills") : join9(homedir2(), `.${agent}`, "skills");
+      return scope === "project" ? join10(base, `.${agent}`, "skills") : join10(homedir3(), `.${agent}`, "skills");
   }
 }
 function warnMissingDependencies(name, targetDir) {
@@ -23724,8 +23834,8 @@ function warnMissingDependencies(name, targetDir) {
   }
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join9(getSkillPath(name), "package.json");
-  if (!existsSync9(pkgPath))
+  const pkgPath = join10(getSkillPath(name), "package.json");
+  if (!existsSync10(pkgPath))
     return "unknown";
   try {
     const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
@@ -23736,13 +23846,13 @@ function readBundledSkillVersion(name) {
 }
 
 // src/lib/skillinfo.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { join as join11 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join10(skillPath, "SKILL.md");
-  if (!existsSync10(skillMdPath))
+  const skillMdPath = join11(skillPath, "SKILL.md");
+  if (!existsSync11(skillMdPath))
     return false;
   try {
     return parseSkillFrontmatter(readFileSync9(skillMdPath, "utf-8"))?.kind === "instruction";
@@ -23768,12 +23878,12 @@ var HOSTED_PROVIDER_ENV_PREFIXES = [
 ];
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync10(skillPath))
+  if (!existsSync11(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join10(skillPath, "SKILL.md")),
-    readme: readIfExists(join10(skillPath, "README.md")),
-    claudeMd: readIfExists(join10(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join11(skillPath, "SKILL.md")),
+    readme: readIfExists(join11(skillPath, "README.md")),
+    claudeMd: readIfExists(join11(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -23784,11 +23894,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync10(skillPath))
+  if (!existsSync11(skillPath))
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join10(skillPath, file));
+    const content = readIfExists(join11(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -23827,8 +23937,8 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join10(skillPath, "package.json");
-  if (existsSync10(pkgPath)) {
+  const pkgPath = join11(skillPath, "package.json");
+  if (existsSync11(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
@@ -23848,7 +23958,7 @@ async function runSkill(name, args, options = {}) {
   const meta = getSkill(name);
   const canonicalName = meta?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync10(skillPath)) {
+  if (!existsSync11(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
   if (isInstructionSkillDir(skillPath, meta)) {
@@ -23857,8 +23967,8 @@ async function runSkill(name, args, options = {}) {
       error: `Skill '${name}' is an instruction skill (kind: instruction) and is not runnable. Instruction skills are consumed by coding agents via SKILL.md, not executed with 'skills run'.`
     };
   }
-  const pkgPath = join10(skillPath, "package.json");
-  if (!existsSync10(pkgPath)) {
+  const pkgPath = join11(skillPath, "package.json");
+  if (!existsSync11(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
@@ -23877,12 +23987,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join10(skillPath, entryPoint);
-  if (!existsSync10(entryPath)) {
+  const entryPath = join11(skillPath, entryPoint);
+  if (!existsSync11(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join10(skillPath, "node_modules");
-  if (!existsSync10(nodeModules)) {
+  const nodeModules = join11(skillPath, "node_modules");
+  if (!existsSync11(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -23909,8 +24019,8 @@ async function runSkill(name, args, options = {}) {
   return { exitCode };
 }
 function detectProjectSkills(cwd = process.cwd()) {
-  const pkgPath = join10(cwd, "package.json");
-  if (!existsSync10(pkgPath)) {
+  const pkgPath = join11(cwd, "package.json");
+  if (!existsSync11(pkgPath)) {
     const alwaysRecommend = ["market-research-report", "repo-onboarding-report", "blog-article"];
     const recommended2 = alwaysRecommend.map((name) => loadRegistry().find((s) => s.name === name)).filter((s) => s !== undefined);
     return { detected: [], recommended: recommended2 };
@@ -24006,7 +24116,7 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync10(path)) {
+    if (existsSync11(path)) {
       return readFileSync9(path, "utf-8");
     }
   } catch {}
@@ -25589,25 +25699,25 @@ function registerDiscoveryTools(server) {
 }
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync13, readdirSync as readdirSync8, statSync as statSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync8, statSync as statSync8 } from "fs";
+import { join as join14 } from "path";
 
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, readdirSync as readdirSync7, statSync as statSync7, writeFileSync as writeFileSync5 } from "fs";
-import { extname, join as join11, relative as relative2 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync10, readdirSync as readdirSync7, statSync as statSync7, writeFileSync as writeFileSync5 } from "fs";
+import { extname, join as join12, 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 = join11(root, "runs", day, id);
-  const logsDir = join11(runDir, "logs");
-  const exportDir = join11(root, "exports", skillName, id);
+  const runDir = join12(root, "runs", day, id);
+  const logsDir = join12(runDir, "logs");
+  const exportDir = join12(root, "exports", skillName, id);
   mkdirSync5(logsDir, { recursive: true });
   mkdirSync5(exportDir, { recursive: true });
-  mkdirSync5(join11(root, "tmp"), { recursive: true });
+  mkdirSync5(join12(root, "tmp"), { recursive: true });
   const record3 = {
     id,
     skill: skillName,
@@ -25658,22 +25768,22 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync5(join11(context.logsDir, "stdout.log"), stdout);
-  writeFileSync5(join11(context.logsDir, "stderr.log"), stderr);
+  writeFileSync5(join12(context.logsDir, "stdout.log"), stdout);
+  writeFileSync5(join12(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join11(context.runDir, "events.ndjson");
-  const previous = existsSync11(path) ? readFileSync10(path, "utf-8") : "";
+  const path = join12(context.runDir, "events.ndjson");
+  const previous = existsSync12(path) ? readFileSync10(path, "utf-8") : "";
   writeFileSync5(path, previous + line);
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join11(getProjectStateDir(targetDir), "runs");
-  if (!existsSync11(runsRoot))
+  const runsRoot = join12(getProjectStateDir(targetDir), "runs");
+  if (!existsSync12(runsRoot))
     return null;
   for (const day of readdirSync7(runsRoot)) {
-    const record3 = readRunRecord(join11(runsRoot, day, runId));
+    const record3 = readRunRecord(join12(runsRoot, day, runId));
     if (record3)
       return record3;
   }
@@ -25690,15 +25800,15 @@ function skillRunEnv(context) {
   };
 }
 function writeRunRecord(context) {
-  writeFileSync5(join11(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync5(join12(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync5(join11(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync5(join12(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
-  if (!existsSync11(context.exportDir))
+  if (!existsSync12(context.exportDir))
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
@@ -25714,8 +25824,8 @@ function collectRunArtifacts(context) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join11(runDir, "run.json");
-  if (!existsSync11(path))
+  const path = join12(runDir, "run.json");
+  if (!existsSync12(path))
     return null;
   try {
     return JSON.parse(readFileSync10(path, "utf-8"));
@@ -25726,7 +25836,7 @@ function readRunRecord(runDir) {
 function walkFiles(dir) {
   const files = [];
   for (const entry of readdirSync7(dir)) {
-    const full = join11(dir, entry);
+    const full = join12(dir, entry);
     if (statSync7(full).isDirectory())
       files.push(...walkFiles(full));
     else
@@ -26197,12 +26307,12 @@ function registerOperationTools(server) {
     const agents = [];
     for (const agent of AGENT_TARGETS) {
       const agentSkillsPath = getAgentSkillsDir(agent, "global");
-      const exists = existsSync13(agentSkillsPath);
+      const exists = existsSync14(agentSkillsPath);
       let skillCount = 0;
       if (exists) {
         try {
           skillCount = readdirSync8(agentSkillsPath).filter((f) => {
-            const full = join13(agentSkillsPath, f);
+            const full = join14(agentSkillsPath, f);
             return !f.startsWith(".") && statSync8(full).isDirectory();
           }).length;
         } catch {}
@@ -26248,17 +26358,18 @@ function compactRunToolPayload(payload, detailHint) {
 }
 
 // src/lib/feedback.ts
+init_api_url();
 init_config();
-import { existsSync as existsSync14, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname6, join as join14 } from "path";
+import { appendFileSync, existsSync as existsSync15, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname6, join as join15 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join14(getDataDir(), "skills.db");
+  return join15(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
   const dir = dirname6(dbPath);
-  if (!existsSync14(dir))
+  if (!existsSync15(dir))
     mkdirSync7(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
@@ -26284,6 +26395,15 @@ function saveFeedback(input) {
   if (!message)
     throw new Error("Feedback message is required");
   const category = input.category ?? "general";
+  if (isApiMode()) {
+    const path = join15(getDataDir(), "feedback.jsonl");
+    const dir = dirname6(path);
+    if (!existsSync15(dir))
+      mkdirSync7(dir, { recursive: true });
+    appendFileSync(path, JSON.stringify({ message, category, email: input.email ?? null, agent: input.agent ?? null, version: input.version ?? null, createdAt: new Date().toISOString() }) + `
+`);
+    return { saved: true, category, path };
+  }
   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]);
@@ -26292,6 +26412,15 @@ function saveFeedback(input) {
   }
   return { saved: true, category, path: getFeedbackDbPath() };
 }
+function isApiMode(env = process.env) {
+  if (env.HASNA_SKILLS_API_URL?.trim())
+    return true;
+  try {
+    return Boolean(resolveApiUrl(undefined, env));
+  } catch {
+    return Boolean(env.SKILLS_API_URL?.trim());
+  }
+}
 
 // src/mcp/resource-meta-tools.ts
 function registerResourceMetaTools(server) {
@@ -26417,14 +26546,14 @@ function registerResourceMetaTools(server) {
 }
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8 } from "fs";
+import { join as join16 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join15(targetDir, ".skills", "schedules.json");
+  return join16(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  if (existsSync15(path)) {
+  if (existsSync16(path)) {
     try {
       return JSON.parse(readFileSync12(path, "utf-8"));
     } catch {}
@@ -26433,8 +26562,8 @@ function loadSchedules(targetDir = process.cwd()) {
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join15(targetDir, ".skills");
-  if (!existsSync15(dir))
+  const dir = join16(targetDir, ".skills");
+  if (!existsSync16(dir))
     mkdirSync8(dir, { recursive: true });
   writeFileSync7(path, JSON.stringify(data, null, 2));
 }
@@ -26697,14 +26826,14 @@ function registerScheduleTools(server) {
 init_config();
 import { createHash as createHash3, createHmac } from "crypto";
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync13,
   readdirSync as readdirSync9,
   statSync as statSync9,
   writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname7, join as join16, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
+import { dirname as dirname7, join as join17, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
 init_retired_settings();
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
@@ -26781,7 +26910,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join16(getDataDir(), "skills.db")
+      feedbackDbPath: join17(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config2.databaseUrl),
@@ -26801,7 +26930,7 @@ function getStorageStatus(options = {}) {
 function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const projectStateDir = getProjectStateDir(targetDir);
   const files = [];
-  if (existsSync16(projectStateDir)) {
+  if (existsSync17(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
       const bytes = readFileSync13(filePath);
       const relativePath = toPosix(relative3(targetDir, filePath));
@@ -26885,7 +27014,7 @@ function parsePositiveInteger(value) {
 function walkFiles2(dir) {
   const files = [];
   for (const entry of readdirSync9(dir)) {
-    const full = join16(dir, entry);
+    const full = join17(dir, entry);
     const stats = statSync9(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
@@ -27433,7 +27562,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
         });
         if (!chunk) {
           if (i === 1) {
-            await new Promise((resolve) => setTimeout(resolve));
+            await new Promise((resolve2) => setTimeout(resolve2));
             maxReadCount = 3;
             continue;
           }
@@ -27990,9 +28119,9 @@ data:
       const initRequest = messages.find((m) => isInitializeRequest(m));
       const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
       if (this._enableJsonResponse) {
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           this._streamMapping.set(streamId, {
-            resolveJson: resolve,
+            resolveJson: resolve2,
             cleanup: () => {
               this._streamMapping.delete(streamId);
             }
@@ -28340,19 +28469,19 @@ async function connectMcpForNode() {
   return { server: server2, transport };
 }
 function readBody(req) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve(undefined);
+        resolve2(undefined);
         return;
       }
       try {
-        resolve(JSON.parse(raw));
+        resolve2(JSON.parse(raw));
       } catch {
-        resolve(undefined);
+        resolve2(undefined);
       }
     });
     req.on("error", reject);
@@ -28394,9 +28523,9 @@ async function startSkillsMcpHttpServer(options = {}) {
       }
     }
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     httpServer.once("error", reject);
-    httpServer.listen(port, hostname2, () => resolve());
+    httpServer.listen(port, hostname2, () => resolve2());
   });
   const address = httpServer.address();
   const listenPort = typeof address === "object" && address ? address.port : port;