@hasna/skills 0.1.72 → 0.2.0

package/bin/mcp.js

@@ -6679,92 +6679,77 @@ var init_retired_settings = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
+// src/lib/app-home.ts
+import { existsSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
-function assertApp(app) {
+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 (!APP_SLUG_RE.test(app)) {
+  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 envOf(options) {
-  return options.env ?? process.env;
-}
-function envValue(options, kind) {
-  const value = envOf(options)[KIND_ENV[kind]];
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function isMacOS(platform) {
-  return platform === "darwin";
+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 baseDir(kind, options) {
-  const override = envValue(options, kind);
-  if (override)
+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 ?? homedir();
+  const home = options.home ?? pathsResolverHomedir();
   const platform = options.platform ?? process.platform;
-  if (isMacOS(platform)) {
+  if (platform === "darwin") {
     switch (kind) {
       case "config":
       case "data":
-        return join(home, "Library", "Application Support", "Hasna");
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
       case "cache":
-        return join(home, "Library", "Caches", "Hasna");
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
       case "state":
-        return join(home, "Library", "Logs", "Hasna");
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
     }
   }
   switch (kind) {
     case "config":
-      return join(home, ".config", "hasna");
+      return pathsResolverJoin(home, ".config", "hasna");
     case "data":
-      return join(home, ".local", "share", "hasna");
+      return pathsResolverJoin(home, ".local", "share", "hasna");
     case "state":
-      return join(home, ".local", "state", "hasna");
+      return pathsResolverJoin(home, ".local", "state", "hasna");
     case "cache":
-      return join(home, ".cache", "hasna");
+      return pathsResolverJoin(home, ".cache", "hasna");
   }
 }
-function resolvePath(kind, options) {
-  assertApp(options.app);
-  const appSegment = options.internal === true ? join("internal", options.app) : options.app;
-  return join(baseDir(kind, options), appSegment);
+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 resolvePath("data", options);
+  return pathsResolverResolve("data", options);
 }
-var KIND_ENV, APP_SLUG_RE;
-var init_dist = __esm(() => {
-  KIND_ENV = {
-    config: "HASNA_CONFIG_HOME",
-    data: "HASNA_DATA_HOME",
-    state: "HASNA_STATE_HOME",
-    cache: "HASNA_CACHE_HOME"
-  };
-  APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-});
-
-// src/lib/app-home.ts
-import { existsSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2, resolve } from "path";
 function effectiveHome() {
-  return process.env["HOME"] || process.env["USERPROFILE"] || homedir2() || "/tmp";
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir() || "/tmp";
 }
 function legacyDataRoot() {
-  return join2(effectiveHome(), ".hasna", "skills");
+  return join(effectiveHome(), ".hasna", "skills");
 }
-function resolverDataRoot(home = effectiveHome()) {
-  return dataDir({ app: "skills", home });
+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(join2(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join2(resolved, GLOBAL_CONFIG_FILENAME));
+  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]) {
@@ -6787,15 +6772,21 @@ function getDataRoot() {
   const resolved = resolverDataRoot();
   return adoptResolverDataRoot(resolved) ? resolve(resolved) : resolve(legacyDataRoot());
 }
-var 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 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(() => {
-  init_dist();
+  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 join3, dirname } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
 function validKeys() {
   return [...Object.keys(ENUM_KEYS), ...STRING_KEYS];
 }
@@ -6807,8 +6798,8 @@ function mergeDirectoryContents(sourceDir, targetDir) {
     return;
   mkdirSync(targetDir, { recursive: true });
   for (const entry of readdirSync(sourceDir)) {
-    const sourcePath = join3(sourceDir, entry);
-    const targetPath = join3(targetDir, entry);
+    const sourcePath = join2(sourceDir, entry);
+    const targetPath = join2(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
@@ -6841,7 +6832,7 @@ function normalizeConfigValue(key, value) {
   return;
 }
 function isOwnerLayoutMigrated(appDir) {
-  return existsSync2(join3(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+  return existsSync2(join2(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
 }
 function getDataDir() {
   const root = getDataRoot();
@@ -6851,14 +6842,14 @@ function getDataDir() {
   if (hasOperatorOverride())
     return root;
   const home = effectiveHome();
-  const oldDir = join3(home, ".skills");
-  const oldConfigFile = join3(home, ".skillsrc");
+  const oldDir = join2(home, ".skills");
+  const oldConfigFile = join2(home, ".skillsrc");
   try {
     mergeDirectoryContents(oldDir, root);
   } catch {}
-  if (existsSync2(oldConfigFile) && !existsSync2(join3(root, "config.json"))) {
+  if (existsSync2(oldConfigFile) && !existsSync2(join2(root, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join3(root, "config.json"));
+      copyFileSync(oldConfigFile, join2(root, "config.json"));
     } catch {}
   }
   return root;
@@ -6868,8 +6859,8 @@ function getDataDirReadOnly() {
 }
 function getConfigPathReadOnly(scope) {
   if (scope === "global")
-    return join3(getDataDirReadOnly(), "config.json");
-  return join3(process.cwd(), "skills.config.json");
+    return join2(getDataDirReadOnly(), "config.json");
+  return join2(process.cwd(), "skills.config.json");
 }
 function loadConfigReadOnly() {
   const canonicalConfigPath = getConfigPathReadOnly("global");
@@ -6885,13 +6876,13 @@ function loadConfigReadOnly() {
   return { ...globalConfig2, ...projectConfig };
 }
 function legacyConfigFilePath() {
-  return join3(process.env["HOME"] || process.env["USERPROFILE"] || homedir3(), ".skillsrc");
+  return join2(process.env["HOME"] || process.env["USERPROFILE"] || homedir2(), ".skillsrc");
 }
 function getConfigPath(scope) {
   if (scope === "global") {
-    return join3(getDataDir(), "config.json");
+    return join2(getDataDir(), "config.json");
   }
-  return join3(process.cwd(), "skills.config.json");
+  return join2(process.cwd(), "skills.config.json");
 }
 function readConfigFile(path) {
   if (!existsSync2(path))
@@ -7015,16 +7006,16 @@ __export(exports_auth_store, {
   clearAuthConfig: () => clearAuthConfig
 });
 import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, unlinkSync } from "fs";
-import { dirname as dirname5, join as join14 } from "path";
-import { homedir as homedir5 } from "os";
+import { dirname as dirname5, join as join13 } from "path";
+import { homedir as homedir4 } from "os";
 function getAuthFilePath() {
-  return join14(getDataDir(), "auth.json");
+  return join13(getDataDir(), "auth.json");
 }
 function getAuthFilePathReadOnly() {
-  return join14(getDataDirReadOnly(), "auth.json");
+  return join13(getDataDirReadOnly(), "auth.json");
 }
 function legacyAuthFilePath() {
-  return join14(process.env["HOME"] || process.env["USERPROFILE"] || homedir5(), ".skills", "auth.json");
+  return join13(process.env["HOME"] || process.env["USERPROFILE"] || homedir4(), ".skills", "auth.json");
 }
 function getAuthConfig() {
   if (cachedConfig !== undefined)
@@ -7356,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());
@@ -13052,7 +13061,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.72",
+  version: "0.2.0",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -13132,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",
@@ -13144,7 +13153,6 @@ var package_default = {
     "@aws-sdk/client-ecs": "^3.1079.0",
     "@aws-sdk/client-s3": "^3.1079.0",
     "@hasna/events": "0.1.16",
-    "@hasna/paths": "0.1.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -20998,7 +21006,7 @@ var EMPTY_COMPLETION_RESULT = {
 // src/lib/registry.ts
 init_config();
 import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync6 } from "fs";
-import { join as join9 } from "path";
+import { join as join8 } from "path";
 
 // src/lib/portable-skills.ts
 init_config();
@@ -21013,7 +21021,7 @@ import {
   statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join8, 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 = [
@@ -21227,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"
   }
 ];
 
@@ -21734,7 +21734,7 @@ var SKILLS = [
 
 // src/lib/hosted-skill-set.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 var HOSTED_RUNTIMES = new Set(["hosted"]);
 var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
 function normalizeMarker(value) {
@@ -21747,7 +21747,7 @@ function isHostedMetadataPackage(pkg) {
   return HOSTED_RUNTIMES.has(normalizeMarker(skills.runtime)) || HOSTED_SOURCES.has(normalizeMarker(skills.source));
 }
 function isHostedMetadataSkillDir(skillDir) {
-  const pkgPath = join4(skillDir, "package.json");
+  const pkgPath = join3(skillDir, "package.json");
   if (!existsSync3(pkgPath))
     return false;
   try {
@@ -21773,7 +21773,7 @@ var SINGLE_SOURCE_EXCLUSION = new RegExp(`^!skills/(${SLUG})/src$`);
 
 // src/lib/skill-validation.ts
 import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { isAbsolute, join as join5, normalize } from "path";
+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([
@@ -21926,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 = join5(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`);
     }
@@ -21938,13 +21938,13 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync4(join5(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 = join5(skillPath, "SKILL.md");
+  const skillMdPath = join4(skillPath, "SKILL.md");
   if (existsSync4(skillMdPath)) {
     const frontmatter = parseSkillFrontmatter(readFileSync3(skillMdPath, "utf-8"));
     if (!frontmatter) {
@@ -21988,7 +21988,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join5(skillPath, "package.json");
+  const pkgPath = join4(skillPath, "package.json");
   if (!existsSync4(pkgPath)) {
     if (!isInstruction)
       add(issues, "package.missing", "Missing package.json");
@@ -22047,7 +22047,7 @@ 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 = join5(skillPath, target);
+            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()) {
@@ -22065,17 +22065,17 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join5(skillPath, "src");
+    const srcDir = join4(skillPath, "src");
     if (hostedMetadata) {
       if (existsSync4(srcDir)) {
         add(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
       }
     } else if (!existsSync4(srcDir)) {
       add(issues, "skill.src_missing", "Missing src/ directory");
-    } else if (!existsSync4(join5(srcDir, "index.ts")) && !existsSync4(join5(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 = existsSync4(join5(srcDir, "index.ts")) ? join5(srcDir, "index.ts") : join5(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)`);
@@ -22094,7 +22094,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
 // src/lib/skill-hash.ts
 import { createHash } from "crypto";
 import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import { join as join6, sep } from "path";
+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 = [
@@ -22153,7 +22153,7 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join6(skillPath, entry);
+    const absolute = join5(skillPath, entry);
     if (!existsSync5(absolute))
       continue;
     if (statSync4(absolute).isDirectory())
@@ -22167,7 +22167,7 @@ function collectDirectory(files, dir, rel) {
   for (const entry of readdirSync4(dir).sort()) {
     if (entry.startsWith("."))
       continue;
-    const absolute = join6(dir, entry);
+    const absolute = join5(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
@@ -22394,7 +22394,7 @@ import {
   realpathSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join7, relative } from "path";
+import { basename, dirname as dirname2, join as join6, relative } from "path";
 var ANY_SEGMENT_COPY_EXCLUDES = new Set([
   ".git",
   ".DS_Store",
@@ -22437,9 +22437,9 @@ function normalizePortableSkillName(name) {
   return normalized;
 }
 function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
-  const skillJsonPath = join7(skillPath, "skill.json");
-  const skillMdPath = join7(skillPath, "SKILL.md");
-  const pkgPath = join7(skillPath, "package.json");
+  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;
@@ -22488,7 +22488,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join7(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join6(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -22537,12 +22537,12 @@ function createPortableManifest(name, options) {
   };
 }
 function writePortableSkillTemplate(skillPath, manifest) {
-  mkdirSync2(join7(skillPath, "src"), { recursive: true });
-  writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync2(join7(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync2(join7(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync2(join7(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync2(join7(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) {
@@ -22567,7 +22567,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join7(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 = {
@@ -22577,12 +22577,12 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join7(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 = join7(skillPath, "skill.json");
+  const path = join6(skillPath, "skill.json");
   if (!existsSync6(path))
     return {};
   try {
@@ -22616,24 +22616,24 @@ function ensurePortableSkillFiles(skillPath, manifest) {
     tags: next.tags?.length ? next.tags : ["custom", next.name]
   };
   const entry = next.commands[0]?.entry ?? "src/index.ts";
-  if (entry && !existsSync6(join7(skillPath, entry))) {
-    mkdirSync2(dirname2(join7(skillPath, entry)), { recursive: true });
-    writeFileSync2(join7(skillPath, entry), renderEntrypoint(next));
+  if (entry && !existsSync6(join6(skillPath, entry))) {
+    mkdirSync2(dirname2(join6(skillPath, entry)), { recursive: true });
+    writeFileSync2(join6(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync6(join7(skillPath, "SKILL.md")))
-    writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync6(join6(skillPath, "SKILL.md")))
+    writeFileSync2(join6(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync2(join7(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync5(join7(skillPath, "SKILL.md"), "utf-8"), next));
-  if (!existsSync6(join7(skillPath, "AGENTS.md")))
-    writeFileSync2(join7(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 (!existsSync6(join7(skillPath, "tsconfig.json")))
-    writeFileSync2(join7(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 = join7(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(/^\.\//, "");
@@ -22680,8 +22680,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync6(join7(skillPath, "SKILL.md"))) {
-    writeFileSync2(join7(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);
@@ -22964,18 +22964,18 @@ var LEGACY_CUSTOM_DIRNAME = "custom";
 function getPortableSkillsRoot(options = {}) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join8(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache = join8(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 = join8(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 existsSync7(join8(path, "SKILL.md")) || existsSync7(join8(path, "skill.json")) || existsSync7(join8(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))
@@ -22985,7 +22985,7 @@ function migrateLegacySkillLayout(appDir, installed) {
     for (const entry of readdirSync5(appDir)) {
       if (entry.startsWith(".") || entry === INSTALLED_SKILLS_DIRNAME)
         continue;
-      const path = join8(appDir, entry);
+      const path = join7(appDir, entry);
       if (entry === LEGACY_CUSTOM_DIRNAME) {
         if (!safeIsDirectory(path))
           continue;
@@ -22993,7 +22993,7 @@ function migrateLegacySkillLayout(appDir, installed) {
           for (const nested of readdirSync5(path)) {
             if (nested.startsWith("."))
               continue;
-            const nestedPath = join8(path, nested);
+            const nestedPath = join7(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -23007,10 +23007,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join8(installed, name);
+    const target = join7(installed, name);
     if (existsSync7(target))
       continue;
-    const staging = join8(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 });
@@ -23023,7 +23023,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join8(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join7(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -23049,7 +23049,7 @@ function listPortableSkills(options = {}) {
   for (const entry of readdirSync5(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join8(root, entry);
+    const path = join7(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -23083,7 +23083,7 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizePortableSkillName(name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join8(root, skillName);
+  const skillPath = join7(root, skillName);
   if (existsSync7(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
@@ -23114,7 +23114,7 @@ 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 = join8(root, skillName);
+  const destination = join7(root, skillName);
   if (existsSync7(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
@@ -23144,8 +23144,8 @@ function validatePortableSkillDirectory(name, skillPath) {
   const warnings = [...base.warnings];
   let manifest;
   if (existsSync7(skillPath)) {
-    const skillJsonPath = join8(skillPath, "skill.json");
-    const skillMdPath = join8(skillPath, "SKILL.md");
+    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");
     }
@@ -23165,7 +23165,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add3(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync7(join8(skillPath, "skill.json")),
+        strict: existsSync7(join7(skillPath, "skill.json")),
         skillPath
       });
       for (const issue2 of contractIssues)
@@ -23201,7 +23201,7 @@ 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 = join8(skillPath, command.entry);
+            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())
@@ -23212,7 +23212,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error2) {
       add3(issues, "portable.manifest_invalid", error2.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync7(join8(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");
     }
   }
@@ -23478,7 +23478,7 @@ function discoverSkillsInDir(dir, source = "custom") {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join9(dir, entry.name, "SKILL.md");
+      const skillMdPath = join8(dir, entry.name, "SKILL.md");
       if (!existsSync8(skillMdPath))
         continue;
       let content;
@@ -23498,7 +23498,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
-        ...isHostedMetadataSkillDir(join9(dir, entry.name)) ? { serverOwned: true } : {},
+        ...isHostedMetadataSkillDir(join8(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -23514,8 +23514,8 @@ function findExtensionSkillPath(name) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join9(config2.extensionsDir, entry.name);
-      const skillMdPath = join9(skillDir, "SKILL.md");
+      const skillDir = join8(config2.extensionsDir, entry.name);
+      const skillMdPath = join8(skillDir, "SKILL.md");
       if (!existsSync8(skillMdPath))
         continue;
       let content;
@@ -23553,7 +23553,7 @@ function loadRegistry(cwd) {
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
   const extensions = config2.extensionsDir ? discoverSkillsInDir(config2.extensionsDir, "extension") : [];
   const portableCustom = listPortableSkillMetas();
-  const legacyCustom = discoverSkillsInDir(join9(dataDir2, "custom"));
+  const legacyCustom = discoverSkillsInDir(join8(dataDir2, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now;
@@ -23590,8 +23590,8 @@ function mergeCustomSkills(skills) {
 
 // src/lib/installer.ts
 import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync as rmSync2 } from "fs";
-import { dirname as dirname4, join as join11 } from "path";
-import { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join10 } from "path";
+import { homedir as homedir3 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/home-migration.ts
@@ -23608,7 +23608,7 @@ init_config();
 
 // src/lib/project-state.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join10 } from "path";
+import { join as join9 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
   "custom",
@@ -23623,10 +23623,10 @@ var SKILLS_PROJECT_DIR = ".skills";
 var PROJECT_CONFIG_FILE = "project.json";
 var DEFAULT_EXPORT_DIR = ".skills/exports";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join10(targetDir, SKILLS_PROJECT_DIR);
+  return join9(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join10(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join9(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
@@ -23732,12 +23732,12 @@ var __dirname2 = dirname4(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join11(dir, "skills");
+    const candidate = join10(dir, "skills");
     if (existsSync10(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname4(dir);
   }
-  return join11(__dirname2, "..", "skills");
+  return join10(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
@@ -23745,13 +23745,13 @@ function getSkillPath(name) {
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join11(getDataDir(), "custom", skillName);
+  const legacyCustomPath = join10(getDataDir(), "custom", skillName);
   if (existsSync10(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join11(SKILLS_DIR, skillName);
+  return join10(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
@@ -23815,11 +23815,11 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join11(base, ".pi", "skills") : join11(homedir4(), ".pi", "agent", "skills");
+      return scope === "project" ? join10(base, ".pi", "skills") : join10(homedir3(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join11(base, ".opencode", "skills") : join11(homedir4(), ".config", "opencode", "skills");
+      return scope === "project" ? join10(base, ".opencode", "skills") : join10(homedir3(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join11(base, `.${agent}`, "skills") : join11(homedir4(), `.${agent}`, "skills");
+      return scope === "project" ? join10(base, `.${agent}`, "skills") : join10(homedir3(), `.${agent}`, "skills");
   }
 }
 function warnMissingDependencies(name, targetDir) {
@@ -23834,7 +23834,7 @@ function warnMissingDependencies(name, targetDir) {
   }
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join11(getSkillPath(name), "package.json");
+  const pkgPath = join10(getSkillPath(name), "package.json");
   if (!existsSync10(pkgPath))
     return "unknown";
   try {
@@ -23847,11 +23847,11 @@ function readBundledSkillVersion(name) {
 
 // src/lib/skillinfo.ts
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join12(skillPath, "SKILL.md");
+  const skillMdPath = join11(skillPath, "SKILL.md");
   if (!existsSync11(skillMdPath))
     return false;
   try {
@@ -23881,9 +23881,9 @@ function getSkillDocs(name) {
   if (!existsSync11(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join12(skillPath, "SKILL.md")),
-    readme: readIfExists(join12(skillPath, "README.md")),
-    claudeMd: readIfExists(join12(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join11(skillPath, "SKILL.md")),
+    readme: readIfExists(join11(skillPath, "README.md")),
+    claudeMd: readIfExists(join11(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -23898,7 +23898,7 @@ function getSkillRequirements(name) {
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join12(skillPath, file));
+    const content = readIfExists(join11(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -23937,7 +23937,7 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join12(skillPath, "package.json");
+  const pkgPath = join11(skillPath, "package.json");
   if (existsSync11(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
@@ -23967,7 +23967,7 @@ 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 = join12(skillPath, "package.json");
+  const pkgPath = join11(skillPath, "package.json");
   if (!existsSync11(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
@@ -23987,11 +23987,11 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join12(skillPath, entryPoint);
+  const entryPath = join11(skillPath, entryPoint);
   if (!existsSync11(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join12(skillPath, "node_modules");
+  const nodeModules = join11(skillPath, "node_modules");
   if (!existsSync11(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
@@ -24019,7 +24019,7 @@ async function runSkill(name, args, options = {}) {
   return { exitCode };
 }
 function detectProjectSkills(cwd = process.cwd()) {
-  const pkgPath = join12(cwd, "package.json");
+  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);
@@ -25700,24 +25700,24 @@ function registerDiscoveryTools(server) {
 
 // src/mcp/operation-tools.ts
 import { existsSync as existsSync14, readdirSync as readdirSync8, statSync as statSync8 } from "fs";
-import { join as join15 } from "path";
+import { join as join14 } from "path";
 
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
 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 join13, relative as relative2 } from "path";
+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 = join13(root, "runs", day, id);
-  const logsDir = join13(runDir, "logs");
-  const exportDir = join13(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(join13(root, "tmp"), { recursive: true });
+  mkdirSync5(join12(root, "tmp"), { recursive: true });
   const record3 = {
     id,
     skill: skillName,
@@ -25768,22 +25768,22 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync5(join13(context.logsDir, "stdout.log"), stdout);
-  writeFileSync5(join13(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 = join13(context.runDir, "events.ndjson");
+  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 = join13(getProjectStateDir(targetDir), "runs");
+  const runsRoot = join12(getProjectStateDir(targetDir), "runs");
   if (!existsSync12(runsRoot))
     return null;
   for (const day of readdirSync7(runsRoot)) {
-    const record3 = readRunRecord(join13(runsRoot, day, runId));
+    const record3 = readRunRecord(join12(runsRoot, day, runId));
     if (record3)
       return record3;
   }
@@ -25800,11 +25800,11 @@ function skillRunEnv(context) {
   };
 }
 function writeRunRecord(context) {
-  writeFileSync5(join13(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(join13(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) {
@@ -25824,7 +25824,7 @@ function collectRunArtifacts(context) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join13(runDir, "run.json");
+  const path = join12(runDir, "run.json");
   if (!existsSync12(path))
     return null;
   try {
@@ -25836,7 +25836,7 @@ function readRunRecord(runDir) {
 function walkFiles(dir) {
   const files = [];
   for (const entry of readdirSync7(dir)) {
-    const full = join13(dir, entry);
+    const full = join12(dir, entry);
     if (statSync7(full).isDirectory())
       files.push(...walkFiles(full));
     else
@@ -26312,7 +26312,7 @@ function registerOperationTools(server) {
       if (exists) {
         try {
           skillCount = readdirSync8(agentSkillsPath).filter((f) => {
-            const full = join15(agentSkillsPath, f);
+            const full = join14(agentSkillsPath, f);
             return !f.startsWith(".") && statSync8(full).isDirectory();
           }).length;
         } catch {}
@@ -26358,12 +26358,13 @@ function compactRunToolPayload(payload, detailHint) {
 }
 
 // src/lib/feedback.ts
+init_api_url();
 init_config();
-import { existsSync as existsSync15, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname6, join as join16 } 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 join16(getDataDir(), "skills.db");
+  return join15(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
@@ -26394,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]);
@@ -26402,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) {
@@ -26528,9 +26547,9 @@ function registerResourceMetaTools(server) {
 
 // src/lib/scheduler.ts
 import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8 } from "fs";
-import { join as join17 } from "path";
+import { join as join16 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join17(targetDir, ".skills", "schedules.json");
+  return join16(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
@@ -26543,7 +26562,7 @@ function loadSchedules(targetDir = process.cwd()) {
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join17(targetDir, ".skills");
+  const dir = join16(targetDir, ".skills");
   if (!existsSync16(dir))
     mkdirSync8(dir, { recursive: true });
   writeFileSync7(path, JSON.stringify(data, null, 2));
@@ -26814,7 +26833,7 @@ import {
   statSync as statSync9,
   writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname7, join as join18, 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",
@@ -26891,7 +26910,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join18(getDataDir(), "skills.db")
+      feedbackDbPath: join17(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config2.databaseUrl),
@@ -26995,7 +27014,7 @@ function parsePositiveInteger(value) {
 function walkFiles2(dir) {
   const files = [];
   for (const entry of readdirSync9(dir)) {
-    const full = join18(dir, entry);
+    const full = join17(dir, entry);
     const stats = statSync9(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));