@hasna/skills 0.1.70 → 0.1.72

package/dist/index.js

@@ -47,13 +47,12 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/lib/registry.ts
-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 join9 } from "path";
 
 // src/lib/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join3, dirname } from "path";
 
 // src/lib/retired-settings.ts
 var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
@@ -101,6 +100,123 @@ function assertNoRetiredConfigKeys(config, source) {
   }
 }
 
+// src/lib/app-home.ts
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, resolve } from "path";
+
+// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
+import { homedir } from "os";
+import { join } from "path";
+var KIND_ENV = {
+  config: "HASNA_CONFIG_HOME",
+  data: "HASNA_DATA_HOME",
+  state: "HASNA_STATE_HOME",
+  cache: "HASNA_CACHE_HOME"
+};
+var APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function assertApp(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)) {
+    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 baseDir(kind, options) {
+  const override = envValue(options, kind);
+  if (override)
+    return override;
+  const home = options.home ?? homedir();
+  const platform = options.platform ?? process.platform;
+  if (isMacOS(platform)) {
+    switch (kind) {
+      case "config":
+      case "data":
+        return join(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return join(home, "Library", "Caches", "Hasna");
+      case "state":
+        return join(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return join(home, ".config", "hasna");
+    case "data":
+      return join(home, ".local", "share", "hasna");
+    case "state":
+      return join(home, ".local", "state", "hasna");
+    case "cache":
+      return join(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 dataDir(options) {
+  return resolvePath("data", options);
+}
+
+// src/lib/app-home.ts
+var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
+var HASNA_SKILLS_HOME_ENV = "HASNA_SKILLS_HOME";
+var SKILLS_HOME_ENV = "SKILLS_HOME";
+var DEFAULT_SQLITE_FILENAME = "server.db";
+var GLOBAL_CONFIG_FILENAME = "config.json";
+function effectiveHome() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir2() || "/tmp";
+}
+function legacyDataRoot() {
+  return join2(effectiveHome(), ".hasna", "skills");
+}
+function resolverDataRoot(home = effectiveHome()) {
+  return dataDir({ app: "skills", home });
+}
+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));
+}
+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());
+}
+function skillsDataRootForHome(home) {
+  const resolved = resolverDataRoot(home);
+  return adoptResolverDataRoot(resolved) ? resolve(resolved) : resolve(join2(home, ".hasna", "skills"));
+}
+
 // src/lib/config.ts
 var ENUM_KEYS = {
   defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
@@ -115,19 +231,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 = join3(sourceDir, entry);
+    const targetPath = join3(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync(targetPath))
+      if (!existsSync2(targetPath))
         copyFileSync(sourcePath, targetPath);
     } catch {}
   }
@@ -152,44 +268,40 @@ function normalizeConfigValue(key, value) {
     return value.trim() ? value : undefined;
   return;
 }
-var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
 var INSTALLED_SKILLS_DIRNAME = "installed";
 var SKILLS_CACHE_DIRNAME = "skills";
 var LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
 function isOwnerLayoutMigrated(appDir) {
-  return existsSync(join(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+  return existsSync2(join3(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 {
-    mergeDirectoryContents(oldDir, newDir);
+    mkdirSync(root, { recursive: true });
   } catch {}
-  if (existsSync(oldConfigFile) && !existsSync(join(newDir, "config.json"))) {
+  if (hasOperatorOverride())
+    return root;
+  const home = effectiveHome();
+  const oldDir = join3(home, ".skills");
+  const oldConfigFile = join3(home, ".skillsrc");
+  try {
+    mergeDirectoryContents(oldDir, root);
+  } catch {}
+  if (existsSync2(oldConfigFile) && !existsSync2(join3(root, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join(newDir, "config.json"));
+      copyFileSync(oldConfigFile, join3(root, "config.json"));
     } catch {}
   }
-  return newDir;
+  return root;
 }
 function getConfigPath(scope) {
   if (scope === "global") {
-    return join(getDataDir(), "config.json");
+    return join3(getDataDir(), "config.json");
   }
-  return join(process.cwd(), "skills.config.json");
+  return join3(process.cwd(), "skills.config.json");
 }
 function readConfigFile(path) {
-  if (!existsSync(path))
+  if (!existsSync2(path))
     return {};
   let parsed;
   try {
@@ -225,7 +337,7 @@ function saveConfig(key, value, scope = "project") {
   }
   const filePath = getConfigPath(scope);
   let existing = {};
-  if (existsSync(filePath)) {
+  if (existsSync2(filePath)) {
     try {
       existing = JSON.parse(readFileSync(filePath, "utf-8"));
       if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
@@ -236,7 +348,7 @@ function saveConfig(key, value, scope = "project") {
     }
   } else {
     const dir = dirname(filePath);
-    if (!existsSync(dir)) {
+    if (!existsSync2(dir)) {
       mkdirSync(dir, { recursive: true });
     }
   }
@@ -250,7 +362,7 @@ function unsetConfig(key, scope = "project") {
     throw new Error(`Unknown config key: ${key}. Valid keys: ${validKeys().join(", ")}`);
   }
   const filePath = getConfigPath(scope);
-  if (!existsSync(filePath))
+  if (!existsSync2(filePath))
     return false;
   let existing;
   try {
@@ -272,7 +384,7 @@ function unsetConfig(key, scope = "project") {
 // src/lib/portable-skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync3,
   mkdtempSync,
   readdirSync as readdirSync5,
@@ -281,7 +393,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 join8, normalize as normalize2 } from "path";
 
 // src/lib/registry-data/development-tools.ts
 var DEVELOPMENT_TOOLS_SKILLS = [
@@ -1001,8 +1113,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 join4 } from "path";
 var HOSTED_RUNTIMES = new Set(["hosted"]);
 var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
 function normalizeMarker(value) {
@@ -1015,8 +1127,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 = join4(skillDir, "package.json");
+  if (!existsSync3(pkgPath))
     return false;
   try {
     return isHostedMetadataPackage(JSON.parse(readFileSync2(pkgPath, "utf8")));
@@ -1040,8 +1152,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 join5, normalize } from "path";
 var VALID_SKILL_KINDS = ["executable", "instruction"];
 var DOC_FILES = ["SKILL.md", "README.md", "CLAUDE.md"];
 var RESERVED_SKILL_ENTRIES = new Set([
@@ -1179,7 +1291,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,
@@ -1194,7 +1306,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 = join5(skillPath, entry);
     if (RESERVED_SKILL_ENTRIES.has(entry)) {
       add(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
     }
@@ -1206,14 +1318,14 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync3(join3(skillPath, docFile)))
+    if (existsSync4(join5(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 = join5(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");
@@ -1256,8 +1368,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join3(skillPath, "package.json");
-  if (!existsSync3(pkgPath)) {
+  const pkgPath = join5(skillPath, "package.json");
+  if (!existsSync4(pkgPath)) {
     if (!isInstruction)
       add(issues, "package.missing", "Missing package.json");
   } else {
@@ -1315,8 +1427,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 = join5(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`);
@@ -1333,17 +1445,17 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join3(skillPath, "src");
+    const srcDir = join5(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(join5(srcDir, "index.ts")) && !existsSync4(join5(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(join5(srcDir, "index.ts")) ? join5(srcDir, "index.ts") : join5(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)`);
@@ -1367,8 +1479,8 @@ function validateRegistryConsistency(registry, skillsDir) {
     seen.add(name);
     return false;
   })));
-  const skillDirs = existsSync3(skillsDir) ? readdirSync3(skillsDir).filter((entry) => {
-    const fullPath = join3(skillsDir, entry);
+  const skillDirs = existsSync4(skillsDir) ? readdirSync3(skillsDir).filter((entry) => {
+    const fullPath = join5(skillsDir, entry);
     return !entry.startsWith(".") && entry !== "_common" && statSync3(fullPath).isDirectory();
   }) : [];
   const directoryNames = new Set(skillDirs);
@@ -1385,8 +1497,8 @@ function validateRegistryConsistency(registry, skillsDir) {
 
 // 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 join6, sep } from "path";
 var CONTENT_HASH_ALGORITHM = "sha256";
 var HASH_EXCLUDE_DIRS = new Set([".git", "node_modules", "dist", "build", ".turbo"]);
 var HASH_COVERAGE = [
@@ -1445,8 +1557,8 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join4(skillPath, entry);
-    if (!existsSync4(absolute))
+    const absolute = join6(skillPath, entry);
+    if (!existsSync5(absolute))
       continue;
     if (statSync4(absolute).isDirectory())
       collectDirectory(files, absolute, entry);
@@ -1459,7 +1571,7 @@ function collectDirectory(files, dir, rel) {
   for (const entry of readdirSync4(dir).sort()) {
     if (entry.startsWith("."))
       continue;
-    const absolute = join4(dir, entry);
+    const absolute = join6(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
@@ -1679,14 +1791,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 join7, relative } from "path";
 var ANY_SEGMENT_COPY_EXCLUDES = new Set([
   ".git",
   ".DS_Store",
@@ -1729,12 +1841,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 = join7(skillPath, "skill.json");
+  const skillMdPath = join7(skillPath, "SKILL.md");
+  const pkgPath = join7(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 version = stringField(jsonManifest, "version") ?? frontmatter?.version ?? stringValue(pkg?.version) ?? PORTABLE_SKILL_DEFAULT_VERSION;
@@ -1780,7 +1892,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join5(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join7(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -1829,12 +1941,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(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));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -1859,7 +1971,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync2(join7(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash = computeContentHash(skillPath);
   const withHash = {
@@ -1869,13 +1981,13 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync2(join7(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 = join7(skillPath, "skill.json");
+  if (!existsSync6(path))
     return {};
   try {
     const parsed = JSON.parse(readFileSync5(path, "utf-8"));
@@ -1908,28 +2020,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(join7(skillPath, entry))) {
+    mkdirSync2(dirname2(join7(skillPath, entry)), { recursive: true });
+    writeFileSync2(join7(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync5(join5(skillPath, "SKILL.md")))
-    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync6(join7(skillPath, "SKILL.md")))
+    writeFileSync2(join7(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(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));
   ensurePackageJson(skillPath, next);
-  if (!existsSync5(join5(skillPath, "tsconfig.json")))
-    writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
+  if (!existsSync6(join7(skillPath, "tsconfig.json")))
+    writeFileSync2(join7(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
 function ensurePackageJson(skillPath, manifest) {
-  const pkgPath = join5(skillPath, "package.json");
+  const pkgPath = join7(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;
   }
@@ -1972,8 +2084,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync5(join5(skillPath, "SKILL.md"))) {
-    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync6(join7(skillPath, "SKILL.md"))) {
+    writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(next));
   }
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
@@ -2265,18 +2377,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 ? join8(options.homeDir, ".hasna", "skills") : getDataDir();
+  const cache = join8(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
     return cache;
-  const installed = join6(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join8(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(join8(path, "SKILL.md")) || existsSync7(join8(path, "skill.json")) || existsSync7(join8(path, "package.json"));
 }
 function migrateLegacySkillLayout(appDir, installed) {
   if (!safeIsDirectory(appDir))
@@ -2286,7 +2398,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 = join8(appDir, entry);
       if (entry === LEGACY_CUSTOM_DIRNAME) {
         if (!safeIsDirectory(path))
           continue;
@@ -2294,7 +2406,7 @@ function migrateLegacySkillLayout(appDir, installed) {
           for (const nested of readdirSync5(path)) {
             if (nested.startsWith("."))
               continue;
-            const nestedPath = join6(path, nested);
+            const nestedPath = join8(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -2308,10 +2420,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join6(installed, name);
-    if (existsSync6(target))
+    const target = join8(installed, name);
+    if (existsSync7(target))
       continue;
-    const staging = join6(installed, `.migrating-${name}-${process.pid}`);
+    const staging = join8(installed, `.migrating-${name}-${process.pid}`);
     try {
       rmSync(staging, { recursive: true, force: true });
       cpSync2(from, staging, { recursive: true, errorOnExist: false });
@@ -2324,7 +2436,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join6(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join8(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -2334,7 +2446,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);
@@ -2350,7 +2462,7 @@ function listPortableSkills(options = {}) {
   for (const entry of readdirSync5(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join6(root, entry);
+    const path = join8(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -2384,8 +2496,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 = join8(root, skillName);
+  if (existsSync7(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
     rmSync(skillPath, { recursive: true, force: true });
@@ -2403,7 +2515,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkillDirectory(sourceDir, options = {}) {
   const absoluteSource = normalize2(sourceDir);
-  if (!existsSync6(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
+  if (!existsSync7(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Import directory not found: ${sourceDir}`);
   }
   const continueOnError = options.continueOnError ?? true;
@@ -2416,7 +2528,7 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   const skipped = [];
   const entries = readdirSync5(absoluteSource, { withFileTypes: true }).map((entry) => entry.name).filter((entryName) => !entryName.startsWith(".")).sort();
   for (const entryName of entries) {
-    const childPath = join6(absoluteSource, entryName);
+    const childPath = join8(absoluteSource, entryName);
     if (!safeIsDirectory(childPath))
       continue;
     if (!isSkillCandidate(childPath)) {
@@ -2445,11 +2557,11 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
 }
 function isSkillCandidate(dir) {
-  return existsSync6(join6(dir, "SKILL.md")) || existsSync6(join6(dir, "skill.json")) || existsSync6(join6(dir, "package.json"));
+  return existsSync7(join8(dir, "SKILL.md")) || existsSync7(join8(dir, "skill.json")) || existsSync7(join8(dir, "package.json"));
 }
 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));
@@ -2461,8 +2573,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 = join8(root, skillName);
+  if (existsSync7(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync(destination, { recursive: true, force: true });
@@ -2504,10 +2616,10 @@ function buildCorpusManifest(input, name) {
 function writeCorpusSkill(input, options = {}) {
   const name = normalizePortableSkillName(input.name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join6(root, name);
-  const created = !existsSync6(skillPath);
+  const skillPath = join8(root, name);
+  const created = !existsSync7(skillPath);
   mkdirSync3(skillPath, { recursive: true });
-  writeFileSync3(join6(skillPath, "SKILL.md"), input.skillMd);
+  writeFileSync3(join8(skillPath, "SKILL.md"), input.skillMd);
   const manifest = buildCorpusManifest(input, name);
   writeSkillJsonWithHash(skillPath, manifest);
   return { name, path: skillPath, manifest, created };
@@ -2515,19 +2627,19 @@ function writeCorpusSkill(input, options = {}) {
 function installCorpusSkillAtomically(input, options = {}) {
   const name = normalizePortableSkillName(input.name);
   const root = getPortableSkillsRoot(options);
-  const target = join6(root, name);
-  const created = !existsSync6(target);
+  const target = join8(root, name);
+  const created = !existsSync7(target);
   mkdirSync3(root, { recursive: true });
-  const staging = mkdtempSync(join6(root, `.pull-${name}-`));
+  const staging = mkdtempSync(join8(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
-    writeFileSync3(join6(staging, "SKILL.md"), input.skillMd);
+    writeFileSync3(join8(staging, "SKILL.md"), input.skillMd);
     const manifest = buildCorpusManifest(input, name);
     writeSkillJsonWithHash(staging, manifest);
-    if (existsSync6(target)) {
-      backup = mkdtempSync(join6(root, `.pull-backup-${name}-`));
-      renameSync(target, join6(backup, name));
+    if (existsSync7(target)) {
+      backup = mkdtempSync(join8(root, `.pull-backup-${name}-`));
+      renameSync(target, join8(backup, name));
       moved = true;
     }
     renameSync(staging, target);
@@ -2536,9 +2648,9 @@ function installCorpusSkillAtomically(input, options = {}) {
     return { name, path: target, manifest, created };
   } catch (error) {
     rmSync(staging, { recursive: true, force: true });
-    if (moved && backup && existsSync6(join6(backup, name))) {
+    if (moved && backup && existsSync7(join8(backup, name))) {
       try {
-        renameSync(join6(backup, name), target);
+        renameSync(join8(backup, name), target);
       } catch {}
     }
     throw error;
@@ -2550,10 +2662,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 = join8(skillPath, "skill.json");
+    const skillMdPath = join8(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 {
@@ -2572,7 +2684,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(join8(skillPath, "skill.json")),
         skillPath
       });
       for (const issue of contractIssues)
@@ -2608,8 +2720,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 = join8(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`);
@@ -2619,7 +2731,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error) {
       add3(issues, "portable.manifest_invalid", error.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync6(join6(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync7(join8(skillPath, "AGENTS.md"))) {
       add3(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -2655,13 +2767,13 @@ async function runPortableSkill(name, args, options = {}) {
   if (!isSafeRelativePath2(command.entry)) {
     return { exitCode: 1, error: `Portable skill '${name}' command entry is unsafe` };
   }
-  const entryPath = join6(skill.path, command.entry);
-  if (!existsSync6(entryPath)) {
+  const entryPath = join8(skill.path, command.entry);
+  if (!existsSync7(entryPath)) {
     return { exitCode: 1, error: `Entry point '${command.entry}' not found in portable skill '${name}'` };
   }
-  const pkgPath = join6(skill.path, "package.json");
-  const nodeModules = join6(skill.path, "node_modules");
-  if (existsSync6(pkgPath) && !existsSync6(nodeModules) && hasPackageDependencies(pkgPath)) {
+  const pkgPath = join8(skill.path, "package.json");
+  const nodeModules = join8(skill.path, "node_modules");
+  if (existsSync7(pkgPath) && !existsSync7(nodeModules) && hasPackageDependencies(pkgPath)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skill.path,
       stdout: "pipe",
@@ -2930,7 +3042,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 {
@@ -2938,8 +3050,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 = join9(dir, entry.name, "SKILL.md");
+      if (!existsSync8(skillMdPath))
         continue;
       let content;
       try {
@@ -2958,7 +3070,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(join9(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -2967,16 +3079,16 @@ function discoverSkillsInDir(dir, source = "custom") {
 }
 function findExtensionSkillPath(name) {
   const config = loadConfig();
-  if (!config.extensionsDir || !existsSync7(config.extensionsDir))
+  if (!config.extensionsDir || !existsSync8(config.extensionsDir))
     return null;
   try {
     const entries = readdirSync6(config.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join7(config.extensionsDir, entry.name);
-      const skillMdPath = join7(skillDir, "SKILL.md");
-      if (!existsSync7(skillMdPath))
+      const skillDir = join9(config.extensionsDir, entry.name);
+      const skillMdPath = join9(skillDir, "SKILL.md");
+      if (!existsSync8(skillMdPath))
         continue;
       let content;
       try {
@@ -3008,12 +3120,12 @@ function loadRegistry(cwd) {
   if (registryCache && registryCacheKey === rootKey && now - registryCacheTime < REGISTRY_CACHE_TTL) {
     return registryCache;
   }
-  const dataDir = getDataDir();
+  const dataDir2 = getDataDir();
   const config = loadConfig();
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
   const extensions = config.extensionsDir ? discoverSkillsInDir(config.extensionsDir, "extension") : [];
   const portableCustom = listPortableSkillMetas();
-  const legacyCustom = discoverSkillsInDir(join7(dataDir, "custom"));
+  const legacyCustom = discoverSkillsInDir(join9(dataDir2, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now;
@@ -3060,15 +3172,15 @@ function getAllTags() {
   return Array.from(tagSet).sort();
 }
 // src/lib/installer.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9, rmSync as rmSync3 } from "fs";
-import { dirname as dirname5, join as join10 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync11, readFileSync as readFileSync9, rmSync as rmSync3 } from "fs";
+import { dirname as dirname5, join as join12 } from "path";
+import { homedir as homedir4 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/agent-sync.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync4,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync7,
@@ -3078,8 +3190,8 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename as basename3, dirname as dirname4, join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+import { basename as basename3, dirname as dirname4, join as join10 } from "path";
 // src/lib/home-migration.ts
 function resolveCorpusRoot(options = {}) {
   return getPortableSkillsRoot(options);
@@ -3101,12 +3213,12 @@ function resolveSyncAgents(arg) {
   }
   return [arg];
 }
-function agentGlobalSkillsDir(agent, homeDir = homedir2()) {
+function agentGlobalSkillsDir(agent, homeDir = homedir3()) {
   switch (agent) {
     case "opencode":
-      return join8(homeDir, ".config", "opencode", "skills");
+      return join10(homeDir, ".config", "opencode", "skills");
     default:
-      return join8(homeDir, `.${agent}`, "skills");
+      return join10(homeDir, `.${agent}`, "skills");
   }
 }
 function adaptSkillMdForAgent(skillMd, agent) {
@@ -3165,8 +3277,8 @@ function resolveSyncCorpus(options = {}) {
 function packageSourceRoots(source) {
   const roots = [];
   for (const sub of ["skills"]) {
-    const candidate = join8(source, sub);
-    if (existsSync8(candidate) && isDirectory(candidate))
+    const candidate = join10(source, sub);
+    if (existsSync9(candidate) && isDirectory(candidate))
       roots.push(candidate);
   }
   if (roots.length > 0)
@@ -3181,10 +3293,10 @@ function containsSkillDirectories(path) {
     return false;
   }
   return entries.some((entry) => {
-    const candidate = join8(path, entry);
+    const candidate = join10(path, entry);
     if (!isDirectory(candidate))
       return false;
-    return existsSync8(join8(candidate, "SKILL.md")) || existsSync8(join8(candidate, "skill.json")) || existsSync8(join8(candidate, "package.json"));
+    return existsSync9(join10(candidate, "SKILL.md")) || existsSync9(join10(candidate, "skill.json")) || existsSync9(join10(candidate, "package.json"));
   });
 }
 function isDirectory(path) {
@@ -3197,7 +3309,7 @@ function isDirectory(path) {
 function syncSkillsToAgents(options = {}) {
   const requested = normalizeRequested(options.names);
   const agents = options.agents?.length ? options.agents : [...SYNC_AGENTS];
-  const homeDir = options.homeDir ?? homedir2();
+  const homeDir = options.homeDir ?? homedir3();
   const { roots, source } = resolveSyncCorpus(options);
   const corpus = listPortableSkillsAcrossRoots(roots);
   const byName = new Map(corpus.map((skill) => [skill.name, skill]));
@@ -3223,7 +3335,7 @@ function syncSkillsToAgents(options = {}) {
         actions.push({
           skill: name,
           agent,
-          path: join8(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
+          path: join10(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
           action: "skip",
           reason: "not found in this machine's corpus"
         });
@@ -3252,8 +3364,8 @@ function syncSkillsToAgents(options = {}) {
   return { actions };
 }
 function writeManagedAgentSkill(params) {
-  const homeDir = params.homeDir ?? homedir2();
-  const dir = join8(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
+  const homeDir = params.homeDir ?? homedir3();
+  const dir = join10(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
   const result = writeManagedSkillDir(dir, params.skillMd, {
     skill: params.skill,
     source: params.source,
@@ -3270,11 +3382,11 @@ function writeManagedAgentSkill(params) {
   };
 }
 function writeManagedSkillDir(dir, skillMd, options) {
-  const skillMdPath = join8(dir, "SKILL.md");
-  const markerPath = join8(dir, SYNC_MARKER_FILE);
-  const dirExists = existsSync8(dir);
-  const managed = existsSync8(markerPath);
-  const hasSkillMd = existsSync8(skillMdPath);
+  const skillMdPath = join10(dir, "SKILL.md");
+  const markerPath = join10(dir, SYNC_MARKER_FILE);
+  const dirExists = existsSync9(dir);
+  const managed = existsSync9(markerPath);
+  const hasSkillMd = existsSync9(skillMdPath);
   if (dirExists && !managed && !hasSkillMd) {
     return {
       action: "skip",
@@ -3309,11 +3421,11 @@ function writeManagedSkillDir(dir, skillMd, options) {
     return { action, path: skillMdPath };
   const parentDir = dirname4(dir);
   mkdirSync4(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync2(join8(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
-  const candidateDir = join8(transactionDir, "candidate");
-  const backupDir = join8(transactionDir, "backup");
-  const candidateSkillMdPath = join8(candidateDir, "SKILL.md");
-  const candidateMarkerPath = join8(candidateDir, SYNC_MARKER_FILE);
+  const transactionDir = mkdtempSync2(join10(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
+  const candidateDir = join10(transactionDir, "candidate");
+  const backupDir = join10(transactionDir, "backup");
+  const candidateSkillMdPath = join10(candidateDir, "SKILL.md");
+  const candidateMarkerPath = join10(candidateDir, SYNC_MARKER_FILE);
   const marker = {
     managedBy: SYNC_MARKER_MANAGED_BY,
     skill: options.skill,
@@ -3340,9 +3452,9 @@ function writeManagedSkillDir(dir, skillMd, options) {
     }
     renameDirectory(candidateDir, dir);
   } catch (error) {
-    if (originalMoved && existsSync8(backupDir)) {
+    if (originalMoved && existsSync9(backupDir)) {
       try {
-        if (existsSync8(dir))
+        if (existsSync9(dir))
           rmSync2(dir, { recursive: true, force: true });
         renameDirectory(backupDir, dir);
         originalMoved = false;
@@ -3361,17 +3473,17 @@ function writeManagedSkillDir(dir, skillMd, options) {
   }
   return { action, path: skillMdPath };
 }
-function removeManagedAgentSkill(skill, agent, homeDir = homedir2()) {
-  const dir = join8(agentGlobalSkillsDir(agent, homeDir), skill);
-  if (!existsSync8(join8(dir, SYNC_MARKER_FILE)))
+function removeManagedAgentSkill(skill, agent, homeDir = homedir3()) {
+  const dir = join10(agentGlobalSkillsDir(agent, homeDir), skill);
+  if (!existsSync9(join10(dir, SYNC_MARKER_FILE)))
     return false;
   rmSync2(dir, { recursive: true, force: true });
   return true;
 }
 function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = false) {
   if (kind === undefined || kind === "instruction" || preferBundledDocs) {
-    const skillMdPath = join8(skillPath, "SKILL.md");
-    if (existsSync8(skillMdPath))
+    const skillMdPath = join10(skillPath, "SKILL.md");
+    if (existsSync9(skillMdPath))
       return readFileSync7(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
@@ -3402,8 +3514,8 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { join as join11 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
   "custom",
@@ -3418,14 +3530,14 @@ var SKILLS_PROJECT_DIR = ".skills";
 var PROJECT_CONFIG_FILE = "project.json";
 var DEFAULT_EXPORT_DIR = ".skills/exports";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join9(targetDir, SKILLS_PROJECT_DIR);
+  return join11(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join9(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join11(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return null;
   try {
     return normalizeProjectConfig(JSON.parse(readFileSync8(path, "utf-8")));
@@ -3546,12 +3658,12 @@ var __dirname2 = dirname5(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join10(dir, "skills");
-    if (existsSync10(candidate) && !dir.includes(".skills"))
+    const candidate = join12(dir, "skills");
+    if (existsSync11(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname5(dir);
   }
-  return join10(__dirname2, "..", "skills");
+  return join12(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
@@ -3559,25 +3671,25 @@ function getSkillPath(name) {
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join10(getDataDir(), "custom", skillName);
-  if (existsSync10(legacyCustomPath))
+  const legacyCustomPath = join12(getDataDir(), "custom", skillName);
+  if (existsSync11(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join10(SKILLS_DIR, skillName);
+  return join12(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
 }
 function skillExists(name) {
-  return existsSync10(getSkillPath(name));
+  return existsSync11(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync10(getSkillPath(name))) {
+  if (!existsSync11(getSkillPath(name))) {
     const knownOfficial = Boolean(getSkill(name));
     return {
       skill: canonicalName,
@@ -3604,7 +3716,7 @@ function installSkill(name, options = {}) {
 }
 function installSkillSource(name, _options = {}) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync10(getSkillPath(name))) {
+  if (!existsSync11(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found`, mode: "source" };
   }
   return {
@@ -3625,11 +3737,11 @@ function installSkillManifest(manifest, _options = {}) {
 }
 function createLocalSkillManifest(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync10(sourcePath))
+  if (!existsSync11(sourcePath))
     return null;
   let skillMd = "";
-  const skillMdPath = join10(sourcePath, "SKILL.md");
-  if (existsSync10(skillMdPath)) {
+  const skillMdPath = join12(sourcePath, "SKILL.md");
+  if (existsSync11(skillMdPath)) {
     skillMd = readFileSync9(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
@@ -3702,20 +3814,20 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join10(base, ".pi", "skills") : join10(homedir3(), ".pi", "agent", "skills");
+      return scope === "project" ? join12(base, ".pi", "skills") : join12(homedir4(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join10(base, ".opencode", "skills") : join10(homedir3(), ".config", "opencode", "skills");
+      return scope === "project" ? join12(base, ".opencode", "skills") : join12(homedir4(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join10(base, `.${agent}`, "skills") : join10(homedir3(), `.${agent}`, "skills");
+      return scope === "project" ? join12(base, `.${agent}`, "skills") : join12(homedir4(), `.${agent}`, "skills");
   }
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
-  return join10(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join12(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync10(getSkillPath(name))) {
+  if (!existsSync11(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found` };
   }
   const scope = options.scope ?? "global";
@@ -3739,15 +3851,15 @@ function removeSkillForAgent(name, options) {
   const canonicalName = getCanonicalSkillName(name);
   const scope = options.scope ?? "global";
   const dir = getAgentSkillPath(canonicalName, options.agent, scope, options.projectDir);
-  if (!existsSync10(join10(dir, SYNC_MARKER_FILE)))
+  if (!existsSync11(join12(dir, SYNC_MARKER_FILE)))
     return false;
   rmSync3(dir, { recursive: true, force: true });
   return true;
 }
 function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  const skillMdPath = join10(sourcePath, "SKILL.md");
-  if (existsSync10(skillMdPath))
+  const skillMdPath = join12(sourcePath, "SKILL.md");
+  if (existsSync11(skillMdPath))
     return readFileSync9(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
@@ -3766,7 +3878,7 @@ function warnMissingDependencies(name, targetDir) {
 }
 function generateMinimalSkillMd(name) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync10(sourcePath))
+  if (!existsSync11(sourcePath))
     return null;
   const canonicalName = getCanonicalSkillName(name);
   const meta = getSkill(canonicalName);
@@ -3781,7 +3893,7 @@ function generateMinimalSkillMd(name) {
     "---",
     ""
   ].filter(Boolean);
-  const fallbackDoc = readFileIfExists(join10(sourcePath, "README.md")) || readFileIfExists(join10(sourcePath, "CLAUDE.md"));
+  const fallbackDoc = readFileIfExists(join12(sourcePath, "README.md")) || readFileIfExists(join12(sourcePath, "CLAUDE.md"));
   if (fallbackDoc)
     return `${frontmatter.join(`
 `)}${fallbackDoc.trim()}
@@ -3800,8 +3912,8 @@ skills run ${canonicalName}
 `;
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join10(getSkillPath(name), "package.json");
-  if (!existsSync10(pkgPath))
+  const pkgPath = join12(getSkillPath(name), "package.json");
+  if (!existsSync11(pkgPath))
     return "unknown";
   try {
     const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
@@ -3811,27 +3923,27 @@ function readBundledSkillVersion(name) {
   }
 }
 function readFileIfExists(path) {
-  return existsSync10(path) ? readFileSync9(path, "utf-8") : null;
+  return existsSync11(path) ? readFileSync9(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
 }
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync as readdirSync8, statSync as statSync8, writeFileSync as writeFileSync6 } from "fs";
-import { extname, join as join11, relative as relative2 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync as readdirSync8, statSync as statSync8, writeFileSync as writeFileSync6 } from "fs";
+import { extname, join as join13, 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 = join13(root, "runs", day, id);
+  const logsDir = join13(runDir, "logs");
+  const exportDir = join13(root, "exports", skillName, id);
   mkdirSync6(logsDir, { recursive: true });
   mkdirSync6(exportDir, { recursive: true });
-  mkdirSync6(join11(root, "tmp"), { recursive: true });
+  mkdirSync6(join13(root, "tmp"), { recursive: true });
   const record = {
     id,
     skill: skillName,
@@ -3882,27 +3994,27 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync6(join11(context.logsDir, "stdout.log"), stdout);
-  writeFileSync6(join11(context.logsDir, "stderr.log"), stderr);
+  writeFileSync6(join13(context.logsDir, "stdout.log"), stdout);
+  writeFileSync6(join13(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 = join13(context.runDir, "events.ndjson");
+  const previous = existsSync12(path) ? readFileSync10(path, "utf-8") : "";
   writeFileSync6(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
-  const runsRoot = join11(getProjectStateDir(targetDir), "runs");
-  if (!existsSync11(runsRoot))
+  const runsRoot = join13(getProjectStateDir(targetDir), "runs");
+  if (!existsSync12(runsRoot))
     return [];
   const records = [];
   for (const day of readdirSync8(runsRoot).sort().reverse()) {
-    const dayDir = join11(runsRoot, day);
+    const dayDir = join13(runsRoot, day);
     if (!statSync8(dayDir).isDirectory())
       continue;
     for (const runId of readdirSync8(dayDir).sort().reverse()) {
-      const record = readRunRecord(join11(dayDir, runId));
+      const record = readRunRecord(join13(dayDir, runId));
       if (record)
         records.push(record);
       if (records.length >= limit)
@@ -3912,29 +4024,29 @@ function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   return records;
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join11(getProjectStateDir(targetDir), "runs");
-  if (!existsSync11(runsRoot))
+  const runsRoot = join13(getProjectStateDir(targetDir), "runs");
+  if (!existsSync12(runsRoot))
     return null;
   for (const day of readdirSync8(runsRoot)) {
-    const record = readRunRecord(join11(runsRoot, day, runId));
+    const record = readRunRecord(join13(runsRoot, day, runId));
     if (record)
       return record;
   }
   return null;
 }
 function getRunExportDir(runId, skill, targetDir = process.cwd()) {
-  return join11(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
+  return join13(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
 }
 function writeRunRecord(context) {
-  writeFileSync6(join11(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync6(join13(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync6(join11(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync6(join13(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)) {
@@ -3950,8 +4062,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 = join13(runDir, "run.json");
+  if (!existsSync12(path))
     return null;
   try {
     return JSON.parse(readFileSync10(path, "utf-8"));
@@ -3962,7 +4074,7 @@ function readRunRecord(runDir) {
 function walkFiles(dir) {
   const files = [];
   for (const entry of readdirSync8(dir)) {
-    const full = join11(dir, entry);
+    const full = join13(dir, entry);
     if (statSync8(full).isDirectory())
       files.push(...walkFiles(full));
     else
@@ -4008,13 +4120,13 @@ function mimeForPath(path) {
   }
 }
 // src/lib/skillinfo.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+import { join as join14 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join12(skillPath, "SKILL.md");
-  if (!existsSync12(skillMdPath))
+  const skillMdPath = join14(skillPath, "SKILL.md");
+  if (!existsSync13(skillMdPath))
     return false;
   try {
     return parseSkillFrontmatter(readFileSync11(skillMdPath, "utf-8"))?.kind === "instruction";
@@ -4040,12 +4152,12 @@ var HOSTED_PROVIDER_ENV_PREFIXES = [
 ];
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync12(skillPath))
+  if (!existsSync13(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join12(skillPath, "SKILL.md")),
-    readme: readIfExists(join12(skillPath, "README.md")),
-    claudeMd: readIfExists(join12(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join14(skillPath, "SKILL.md")),
+    readme: readIfExists(join14(skillPath, "README.md")),
+    claudeMd: readIfExists(join14(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -4056,11 +4168,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync12(skillPath))
+  if (!existsSync13(skillPath))
     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(join14(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -4099,8 +4211,8 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join12(skillPath, "package.json");
-  if (existsSync12(pkgPath)) {
+  const pkgPath = join14(skillPath, "package.json");
+  if (existsSync13(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
@@ -4120,7 +4232,7 @@ async function runSkill(name, args, options = {}) {
   const meta = getSkill(name);
   const canonicalName = meta?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync12(skillPath)) {
+  if (!existsSync13(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
   if (isInstructionSkillDir(skillPath, meta)) {
@@ -4129,8 +4241,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 = join12(skillPath, "package.json");
-  if (!existsSync12(pkgPath)) {
+  const pkgPath = join14(skillPath, "package.json");
+  if (!existsSync13(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
@@ -4149,12 +4261,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join12(skillPath, entryPoint);
-  if (!existsSync12(entryPath)) {
+  const entryPath = join14(skillPath, entryPoint);
+  if (!existsSync13(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join12(skillPath, "node_modules");
-  if (!existsSync12(nodeModules)) {
+  const nodeModules = join14(skillPath, "node_modules");
+  if (!existsSync13(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -4226,7 +4338,7 @@ function generateSkillMd(name) {
   if (!meta)
     return null;
   const skillPath = getSkillPath(name);
-  if (!existsSync12(skillPath))
+  if (!existsSync13(skillPath))
     return null;
   const frontmatter = [
     "---",
@@ -4235,11 +4347,11 @@ function generateSkillMd(name) {
     "---"
   ].join(`
 `);
-  const readme = readIfExists(join12(skillPath, "README.md"));
-  const claudeMd = readIfExists(join12(skillPath, "CLAUDE.md"));
+  const readme = readIfExists(join14(skillPath, "README.md"));
+  const claudeMd = readIfExists(join14(skillPath, "CLAUDE.md"));
   let cliCommand = null;
-  const pkgPath = join12(skillPath, "package.json");
-  if (existsSync12(pkgPath)) {
+  const pkgPath = join14(skillPath, "package.json");
+  if (existsSync13(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       if (pkg.bin) {
@@ -4316,7 +4428,7 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync12(path)) {
+    if (existsSync13(path)) {
       return readFileSync11(path, "utf-8");
     }
   } catch {}
@@ -8320,21 +8432,21 @@ function requireApiUrl(action = "This command", config, env) {
 }
 
 // src/lib/auth-store.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync } from "fs";
-import { dirname as dirname6, join as join13 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync } from "fs";
+import { dirname as dirname6, join as join15 } from "path";
+import { homedir as homedir5 } from "os";
 function getAuthFilePath() {
-  return join13(getDataDir(), "auth.json");
+  return join15(getDataDir(), "auth.json");
 }
 function legacyAuthFilePath() {
-  return join13(process.env["HOME"] || process.env["USERPROFILE"] || homedir4(), ".skills", "auth.json");
+  return join15(process.env["HOME"] || process.env["USERPROFILE"] || homedir5(), ".skills", "auth.json");
 }
 var cachedConfig;
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const file = existsSync13(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
+    const file = existsSync14(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
     const raw = readFileSync12(file, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiKey) {
@@ -9435,14 +9547,14 @@ function createRemoteSkillsClient() {
   return new RemoteSkillsClient(apiKey);
 }
 // src/lib/scheduler.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync13, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join16 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join14(targetDir, ".skills", "schedules.json");
+  return join16(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  if (existsSync14(path)) {
+  if (existsSync15(path)) {
     try {
       return JSON.parse(readFileSync13(path, "utf-8"));
     } catch {}
@@ -9451,8 +9563,8 @@ function loadSchedules(targetDir = process.cwd()) {
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join14(targetDir, ".skills");
-  if (!existsSync14(dir))
+  const dir = join16(targetDir, ".skills");
+  if (!existsSync15(dir))
     mkdirSync8(dir, { recursive: true });
   writeFileSync8(path, JSON.stringify(data, null, 2));
 }
@@ -9639,8 +9751,8 @@ function recordScheduleRun(id, status, targetDir) {
   saveSchedules(data, targetDir);
 }
 // src/lib/pull.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync14, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname7, join as join15 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync14, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname7, join as join17 } from "path";
 
 // src/lib/revision.ts
 import { createHash as createHash3 } from "crypto";
@@ -9931,7 +10043,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
       return reconcileTombstone(slug, corpusOptions);
     }
     if (bundleResponse.status === 404) {
-      const marker = readPullMarker(join15(getPortableSkillsRoot(corpusOptions), slug));
+      const marker = readPullMarker(join17(getPortableSkillsRoot(corpusOptions), slug));
       if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
         return { name: slug, success: true, purged: true, removed: false };
       }
@@ -9962,7 +10074,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
     return { name: slug, success: false, error: `Skill '${slug}' was not found on the configured Skills instance.` };
   }
   if (!meta?.revisionId) {
-    const marker = readPullMarker(join15(getPortableSkillsRoot(corpusOptions), slug));
+    const marker = readPullMarker(join17(getPortableSkillsRoot(corpusOptions), slug));
     if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
       return { name: slug, success: true, purged: true, removed: false };
     }
@@ -10019,8 +10131,8 @@ function provenRevision(meta, slug, bundle) {
   return declared;
 }
 function reconcileTombstone(slug, corpusOptions) {
-  const target = join15(getPortableSkillsRoot(corpusOptions), slug);
-  if (!existsSync15(join15(target, PULL_MARKER_FILE))) {
+  const target = join17(getPortableSkillsRoot(corpusOptions), slug);
+  if (!existsSync16(join17(target, PULL_MARKER_FILE))) {
     return { name: slug, success: true, tombstoned: true, removed: false, leftInPlace: true };
   }
   rmSync4(target, { recursive: true, force: true });
@@ -10028,7 +10140,7 @@ function reconcileTombstone(slug, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync14(join15(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync14(join17(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -10149,14 +10261,14 @@ function verifyBundleResponseBytes(buffer, response, verify = {}) {
 function installBundleAtomically(name, entries, options = {}, marker = {}) {
   const root = getPortableSkillsRoot(options);
   mkdirSync9(root, { recursive: true });
-  const target = join15(root, name);
-  const created = !existsSync15(target);
-  const staging = mkdtempSync3(join15(root, `.pull-${name}-`));
+  const target = join17(root, name);
+  const created = !existsSync16(target);
+  const staging = mkdtempSync3(join17(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
     for (const entry of entries) {
-      const destination = join15(staging, entry.path);
+      const destination = join17(staging, entry.path);
       mkdirSync9(dirname7(destination), { recursive: true });
       writeFileSync9(destination, entry.bytes, { mode: entry.mode });
     }
@@ -10168,9 +10280,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       ...marker.signature ? { signature: marker.signature } : {},
       ...marker.revisionId ? { revisionId: marker.revisionId } : {}
     });
-    if (existsSync15(target)) {
-      backup = mkdtempSync3(join15(root, `.pull-backup-${name}-`));
-      renameSync3(target, join15(backup, name));
+    if (existsSync16(target)) {
+      backup = mkdtempSync3(join17(root, `.pull-backup-${name}-`));
+      renameSync3(target, join17(backup, name));
       moved = true;
     }
     renameSync3(staging, target);
@@ -10178,9 +10290,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       rmSync4(backup, { recursive: true, force: true });
   } catch (error) {
     rmSync4(staging, { recursive: true, force: true });
-    if (moved && backup && existsSync15(join15(backup, name))) {
+    if (moved && backup && existsSync16(join17(backup, name))) {
       try {
-        renameSync3(join15(backup, name), target);
+        renameSync3(join17(backup, name), target);
       } catch {}
     }
     throw error;
@@ -10199,7 +10311,7 @@ function writePullMarker(dir, record) {
     ...record.revisionId ? { revisionId: record.revisionId } : {},
     syncedAt: new Date().toISOString()
   };
-  writeFileSync9(join15(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+  writeFileSync9(join17(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function safeMeta(client, slug) {
@@ -10350,7 +10462,7 @@ import { dirname as dirname8, relative as relative3 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.70",
+  version: "0.1.72",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -10442,6 +10554,7 @@ 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",
@@ -11366,16 +11479,16 @@ function clone2(value) {
   return JSON.parse(JSON.stringify(value));
 }
 // src/lib/feedback.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11 } from "fs";
-import { dirname as dirname9, join as join16 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname9, join as join18 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join16(getDataDir(), "skills.db");
+  return join18(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
   const dir = dirname9(dbPath);
-  if (!existsSync16(dir))
+  if (!existsSync17(dir))
     mkdirSync11(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
@@ -11412,14 +11525,14 @@ function saveFeedback(input) {
 // src/lib/native-storage.ts
 import { createHash as createHash5, createHmac as createHmac2 } from "crypto";
 import {
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync15,
   readdirSync as readdirSync9,
   statSync as statSync9,
   writeFileSync as writeFileSync11
 } from "fs";
-import { dirname as dirname10, join as join17, normalize as normalize3, relative as relative4, sep as sep2 } from "path";
+import { dirname as dirname10, join as join19, normalize as normalize3, relative as relative4, sep as sep2 } from "path";
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
   "skills_sync_cursors"
@@ -11556,7 +11669,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join17(getDataDir(), "skills.db")
+      feedbackDbPath: join19(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config.databaseUrl),
@@ -11579,7 +11692,7 @@ function getStorageStatus(options = {}) {
 function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const projectStateDir = getProjectStateDir(targetDir);
   const files = [];
-  if (existsSync17(projectStateDir)) {
+  if (existsSync18(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
       const bytes = readFileSync15(filePath);
       const relativePath = toPosix(relative4(targetDir, filePath));
@@ -11606,7 +11719,7 @@ function importSkillsLocalSnapshot(snapshot, targetDir = process.cwd(), options
       continue;
     }
     const absolutePath = resolveSnapshotPath(targetDir, file.path);
-    if (existsSync17(absolutePath) && !options.overwrite) {
+    if (existsSync18(absolutePath) && !options.overwrite) {
       skipped += 1;
       continue;
     }
@@ -11913,7 +12026,7 @@ function parsePositiveInteger(value) {
 function walkFiles2(dir) {
   const files = [];
   for (const entry of readdirSync9(dir)) {
-    const full = join17(dir, entry);
+    const full = join19(dir, entry);
     const stats = statSync9(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
@@ -11930,7 +12043,7 @@ function resolveSnapshotPath(targetDir, snapshotPath) {
   if (!toPosix(normalizedPath).startsWith(".skills/")) {
     throw new Error(`Snapshot path must stay inside .skills: ${snapshotPath}`);
   }
-  return join17(targetDir, normalizedPath);
+  return join19(targetDir, normalizedPath);
 }
 function normalizeS3Prefix(prefix) {
   return (prefix ?? "").trim().replace(/^\/+|\/+$/g, "");
@@ -11990,14 +12103,642 @@ function toArrayBuffer(bytes) {
   new Uint8Array(buffer).set(bytes);
   return buffer;
 }
+// src/lib/station-snapshot.ts
+import { createHash as createHash6 } from "crypto";
+import {
+  copyFileSync as copyFileSync2,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync16,
+  statSync as statSync11,
+  writeFileSync as writeFileSync12
+} from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3, relative as relative5, resolve as resolve2, sep as sep4 } from "path";
+
+// src/lib/portable-snapshot-filter.ts
+import { readdirSync as readdirSync10, statSync as statSync10 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join20, sep as sep3 } from "path";
+var SYNC_HOMES = [
+  { name: "skills", subClass: "skills", agent: null },
+  { name: "custom", subClass: "custom", agent: null },
+  { name: "claude", subClass: "agent-homes", agent: "claude" },
+  { name: "codewith", subClass: "agent-homes", agent: "codewith" },
+  { name: "codex", subClass: "agent-homes", agent: "codex" },
+  { name: "opencode", subClass: "agent-homes", agent: "opencode" },
+  { name: "cursor", subClass: "agent-homes", agent: "cursor" }
+];
+var EXCLUDE_DIR_NAMES = new Set([
+  ".git",
+  "node_modules",
+  "__pycache__",
+  ".cache",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache"
+]);
+var EXCLUDE_DIR_PATTERNS = [
+  /^\.merge-pr\.rollback-/
+];
+var EXCLUDE_FILE_NAMES = new Set([
+  ".DS_Store",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "Cargo.lock"
+]);
+var EXCLUDE_FILE_PATTERNS = [
+  /^\._/,
+  /\.bak$/,
+  /\.orig$/,
+  /\.rej$/,
+  /~$/,
+  /\.pyc$/,
+  /\.pyo$/,
+  /\.log$/,
+  /\.db$/,
+  /\.sqlite(\d)?$/,
+  /^bun\.lock/,
+  /\.env($|\.)/,
+  /\.pem$/,
+  /\.key$/,
+  /\.p12$/,
+  /\.pfx$/,
+  /\.jks$/,
+  /^id_rsa/,
+  /^id_ed25519/,
+  /^credentials/
+];
+var PORTABLE_TOP_LEVEL = new Set(["SKILL.md", "skill.json"]);
+var PORTABLE_SUBDIRS = new Set(["scripts", "assets", "references"]);
+var REFUSED_SCANNER_FLAGGED = new Set([
+  "aws-cross-account-app-migration/SKILL.md",
+  "aws-cross-account-app-migration/scripts/selftest.sh",
+  "gateway-serve/SKILL.md",
+  "infinity-drain/SKILL.md",
+  "infinity-run/SKILL.md",
+  "oss-saas-code-cleanup/SKILL.md",
+  "repo-project-familiarization/scripts/repo_shape.py",
+  "repo-project-familiarization/scripts/session_history.py",
+  "scale-check/SKILL.md",
+  "standard-align-repo/SKILL.md",
+  "standard-build-iapp/SKILL.md",
+  "standard-build-oss/SKILL.md",
+  "skill-image/SKILL.md",
+  "skill-scale-check/SKILL.md",
+  "sqlite-to-rds-parity-migrate/scripts/parity-migrate.ts",
+  "pdf-operations/scripts/pdf_ops.py"
+]);
+function isExcludedSkillFileName(fileName) {
+  if (EXCLUDE_FILE_NAMES.has(fileName)) {
+    return true;
+  }
+  return EXCLUDE_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
+}
+function isPortableWithinSkill(relativeParts) {
+  if (relativeParts.length < 2) {
+    return false;
+  }
+  const [, second] = relativeParts;
+  if (PORTABLE_TOP_LEVEL.has(second)) {
+    return relativeParts.length === 2;
+  }
+  if (relativeParts.length < 3) {
+    return false;
+  }
+  return PORTABLE_SUBDIRS.has(second);
+}
+function homePathFor(definition, homesRoot) {
+  const home = homesRoot ?? homedir6();
+  if (definition.subClass === "skills" || definition.subClass === "custom") {
+    return join20(skillsDataRootForHome(home), definition.name);
+  }
+  if (definition.agent === "opencode") {
+    return join20(home, ".config", "opencode", "skills");
+  }
+  return join20(home, `.${definition.agent}`, "skills");
+}
+function destinationFor(definition, stationId, relativePath) {
+  const category = definition.subClass === "agent-homes" ? join20("agent-homes", definition.agent ?? "") : definition.name;
+  return join20("resources", stationId, "skills", category, ...relativePath.split(sep3));
+}
+function walkEntries(absoluteRoot) {
+  let entries;
+  try {
+    entries = readdirSync10(absoluteRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const output = [];
+  for (const entry of entries) {
+    const childFull = join20(absoluteRoot, entry.name);
+    if (entry.isSymbolicLink()) {
+      output.push({ kind: "symlink", relativePath: entry.name, fullPath: childFull });
+      continue;
+    }
+    if (entry.isDirectory()) {
+      if (EXCLUDE_DIR_NAMES.has(entry.name) || EXCLUDE_DIR_PATTERNS.some((pattern) => pattern.test(entry.name))) {
+        continue;
+      }
+      const nested = walkEntries(childFull);
+      for (const item of nested) {
+        output.push({ ...item, relativePath: join20(entry.name, item.relativePath) });
+      }
+      continue;
+    }
+    if (entry.isFile()) {
+      output.push({ kind: "file", relativePath: entry.name, fullPath: childFull });
+    }
+  }
+  return output;
+}
+function isRegularFile(filePath) {
+  try {
+    return statSync10(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/station-snapshot.ts
+var STATION_SYNC_MANIFEST_SCHEMA = "hasna.fleet-resources.skills-sync-manifest/v1";
+var STATION_SNAPSHOT_PRODUCER = { name: "@hasna/skills", version: package_default.version };
+
+class StationSnapshotError extends Error {
+  code;
+  detail;
+  constructor(code, message, detail = []) {
+    super(message);
+    this.name = "StationSnapshotError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function validateStationId(stationId) {
+  if (!/^[a-z0-9-]+$/.test(stationId)) {
+    throw new StationSnapshotError("INVALID_STATION", `station id must be a slug, got: ${stationId}`);
+  }
+}
+function sha256File(filePath) {
+  return createHash6("sha256").update(readFileSync16(filePath)).digest("hex");
+}
+function scanHome(definition, homesRoot) {
+  const homePath = homePathFor(definition, homesRoot);
+  const entries = walkEntries(homePath);
+  const portable = [];
+  const skipped = [];
+  for (const entry of entries) {
+    const relativeParts = entry.relativePath.split(sep4);
+    const fileName = relativeParts[relativeParts.length - 1];
+    if (entry.kind === "symlink") {
+      skipped.push({ relativePath: entry.relativePath, reason: "symlink" });
+      continue;
+    }
+    if (!isPortableWithinSkill(relativeParts)) {
+      skipped.push({ relativePath: entry.relativePath, reason: "not-portable" });
+      continue;
+    }
+    if (isExcludedSkillFileName(fileName)) {
+      skipped.push({ relativePath: entry.relativePath, reason: "excluded" });
+      continue;
+    }
+    if (REFUSED_SCANNER_FLAGGED.has(entry.relativePath)) {
+      skipped.push({ relativePath: entry.relativePath, reason: "refused-scanner-flagged" });
+      continue;
+    }
+    if (!isRegularFile(entry.fullPath)) {
+      skipped.push({ relativePath: entry.relativePath, reason: "not-regular-file" });
+      continue;
+    }
+    const info = statSync11(entry.fullPath);
+    portable.push({
+      relativePath: entry.relativePath,
+      fullPath: entry.fullPath,
+      size: info.size,
+      mtimeMs: info.mtimeMs,
+      mtimeIso: info.mtime.toISOString()
+    });
+  }
+  return { definition, homePath, portable, skipped };
+}
+function planStationSnapshot(options) {
+  validateStationId(options.stationId);
+  const scanned = SYNC_HOMES.map((definition) => scanHome(definition, options.homesRoot));
+  const symlinks = scanned.reduce((sum, item) => sum + item.skipped.filter((entry) => entry.reason === "symlink").length, 0);
+  if (symlinks > 0) {
+    throw new StationSnapshotError("SYMLINKS_REFUSED", `${symlinks} symlink(s) inside skill homes; symlinks are refused (fail closed)`);
+  }
+  const plans = [];
+  for (const item of scanned) {
+    for (const file of item.portable) {
+      plans.push({
+        definition: item.definition,
+        source: file,
+        destination: destinationFor(item.definition, options.stationId, file.relativePath),
+        digest: sha256File(file.fullPath)
+      });
+    }
+  }
+  const totalBytes = plans.reduce((sum, plan) => sum + plan.source.size, 0);
+  return { scanned, plans, totalBytes };
+}
+function humanHomes(scanned) {
+  return scanned.map((item) => ({
+    name: item.definition.name,
+    homePath: item.homePath,
+    files: item.portable.length,
+    skipped: item.skipped.length
+  }));
+}
+function writeStationSnapshot(options) {
+  const repoRoot = resolve2(options.repoRoot ?? process.cwd());
+  const { scanned, plans, totalBytes } = planStationSnapshot(options);
+  const manifestFiles = plans.map((plan) => ({
+    relativePath: plan.source.relativePath,
+    destination: plan.destination,
+    subClass: plan.definition.subClass,
+    agent: plan.definition.agent,
+    sha256: plan.digest,
+    sourceMtimeMs: plan.source.mtimeMs,
+    sourceMtimeIso: plan.source.mtimeIso,
+    size: plan.source.size
+  }));
+  const base = {
+    stationId: options.stationId,
+    mode: "dry-run",
+    repoRoot,
+    stats: { files: plans.length, bytes: totalBytes },
+    homes: humanHomes(scanned),
+    files: manifestFiles
+  };
+  if (options.dryRun !== false) {
+    return base;
+  }
+  const conflicts = [];
+  const untouched = [];
+  for (const plan of plans) {
+    const destination = resolve2(repoRoot, plan.destination);
+    const destinationRelative = relative5(repoRoot, destination);
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep4) || isAbsolute3(destinationRelative)) {
+      throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
+    }
+    let existingDigest = null;
+    try {
+      existingDigest = sha256File(destination);
+    } catch {}
+    if (existingDigest !== null) {
+      if (existingDigest === plan.digest) {
+        continue;
+      }
+      conflicts.push(`existing destination differs from staged source: ${plan.destination}`);
+      continue;
+    }
+    untouched.push(plan);
+  }
+  if (conflicts.length > 0) {
+    throw new StationSnapshotError("CONFLICT", `${conflicts.length} conflict(s); terminal non-acceptance, nothing written`, conflicts);
+  }
+  let written = 0;
+  for (const plan of untouched) {
+    const destination = resolve2(repoRoot, plan.destination);
+    mkdirSync13(dirname11(destination), { recursive: true });
+    copyFileSync2(plan.source.fullPath, destination);
+    written += 1;
+  }
+  const unchanged = plans.length - untouched.length;
+  const manifest = {
+    schema: STATION_SYNC_MANIFEST_SCHEMA,
+    stationId: options.stationId,
+    syncedAt: new Date().toISOString(),
+    producer: STATION_SNAPSHOT_PRODUCER,
+    stats: {
+      written,
+      unchanged,
+      files: plans.length,
+      bytes: totalBytes
+    },
+    files: manifestFiles
+  };
+  const manifestPath = resolve2(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
+  mkdirSync13(dirname11(manifestPath), { recursive: true });
+  writeFileSync12(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  return {
+    ...base,
+    mode: "populate",
+    stats: { files: plans.length, bytes: totalBytes, written, unchanged },
+    manifestPath
+  };
+}
+// src/lib/station-hydrate.ts
+import { createHash as createHash7 } from "crypto";
+import {
+  copyFileSync as copyFileSync3,
+  mkdirSync as mkdirSync14,
+  readdirSync as readdirSync11,
+  readFileSync as readFileSync17,
+  statSync as statSync12,
+  writeFileSync as writeFileSync13
+} from "fs";
+import { dirname as dirname12, join as join21, resolve as resolve3, sep as sep5 } from "path";
+var STATION_HYDRATION_MANIFEST_SCHEMA = "hasna.fleet-resources.skills-hydration-manifest/v1";
+var STATION_HYDRATION_PRODUCER = { name: "@hasna/skills", version: package_default.version };
+var MANIFEST_HASH_KEY_SEP = String.fromCharCode(0);
+function fail(code, message, detail = []) {
+  throw new StationSnapshotError(code, message, detail);
+}
+function snapshotRootFor(repoRoot, stationId) {
+  return join21(repoRoot, "resources", stationId, "skills");
+}
+function readSnapshotManifest(repoRoot, stationId) {
+  const snapshotRoot = snapshotRootFor(repoRoot, stationId);
+  const manifestPath = join21(snapshotRoot, "sync-manifest.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync17(manifestPath, "utf8"));
+  } catch (error) {
+    fail("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error.message}`);
+  }
+  const sourceSnapshotSha = sha256File(manifestPath);
+  return { manifest, manifestPath, sourceSnapshotSha };
+}
+function planStationHydration(stationId, repoRoot) {
+  validateStationId(stationId);
+  const { manifest, sourceSnapshotSha } = readSnapshotManifest(repoRoot, stationId);
+  const snapshotRoot = snapshotRootFor(repoRoot, stationId);
+  const manifestHashes = new Map;
+  for (const file of manifest.files ?? []) {
+    const relativePath = file.relativePath;
+    const agent = file.agent;
+    if (agent && relativePath) {
+      manifestHashes.set(`${agent}${MANIFEST_HASH_KEY_SEP}${relativePath}`, file.sha256);
+    }
+  }
+  const candidates = [];
+  const symlinks = [];
+  const hashMismatches = [];
+  const skippedByRule = [];
+  for (const agent of SYNC_AGENTS) {
+    const agentRoot = join21(snapshotRoot, "agent-homes", agent);
+    let identEntries;
+    try {
+      identEntries = readdirSync11(agentRoot, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const identEntry of identEntries) {
+      if (!identEntry.isDirectory() || identEntry.name.startsWith(".")) {
+        continue;
+      }
+      const identRoot = join21(agentRoot, identEntry.name);
+      const entries = walkEntries(identRoot);
+      for (const entry of entries) {
+        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep5)];
+        if (entry.kind === "symlink") {
+          symlinks.push({ ident: identEntry.name, agent, relativePath: entry.relativePath });
+          continue;
+        }
+        if (!isPortableWithinSkill(relativeParts)) {
+          skippedByRule.push({
+            ident: identEntry.name,
+            agent,
+            relativePath: entry.relativePath,
+            reason: "not-portable"
+          });
+          continue;
+        }
+        const fileName = relativeParts[relativeParts.length - 1];
+        if (isExcludedSkillFileName(fileName)) {
+          skippedByRule.push({
+            ident: identEntry.name,
+            agent,
+            relativePath: entry.relativePath,
+            reason: "excluded"
+          });
+          continue;
+        }
+        const withinIdent = relativeParts.slice(1).join(sep5);
+        const homeRelative = relativeParts.join(sep5);
+        if (REFUSED_SCANNER_FLAGGED.has(homeRelative)) {
+          skippedByRule.push({
+            ident: identEntry.name,
+            agent,
+            relativePath: entry.relativePath,
+            reason: "refused-scanner-flagged"
+          });
+          continue;
+        }
+        if (!isRegularFile(entry.fullPath)) {
+          skippedByRule.push({
+            ident: identEntry.name,
+            agent,
+            relativePath: entry.relativePath,
+            reason: "not-regular-file"
+          });
+          continue;
+        }
+        const info = statSync12(entry.fullPath);
+        const manifestHash = manifestHashes.get(`${agent}${MANIFEST_HASH_KEY_SEP}${homeRelative}`) ?? null;
+        let verified = false;
+        if (manifestHash !== null) {
+          verified = sha256File(entry.fullPath) === manifestHash;
+          if (!verified) {
+            hashMismatches.push({
+              ident: identEntry.name,
+              agent,
+              relativePath: entry.relativePath
+            });
+          }
+        }
+        candidates.push({
+          ident: identEntry.name,
+          agent,
+          withinIdent,
+          fullPath: entry.fullPath,
+          size: info.size,
+          mtimeMs: info.mtimeMs,
+          manifestHash,
+          verified
+        });
+      }
+    }
+  }
+  if (symlinks.length > 0) {
+    fail("SYMLINKS_REFUSED", `${symlinks.length} symlink(s) inside the snapshot; symlinks are refused (fail closed)`);
+  }
+  if (hashMismatches.length > 0) {
+    fail("MANIFEST_HASH_MISMATCH", `${hashMismatches.length} snapshot file(s) no longer match their sync-manifest sha256; ` + "stale or tampered content is refused (fail closed), nothing written \u2014 re-run sync to refresh the manifest", hashMismatches.map((mismatch) => `agent-homes/${mismatch.agent}/${mismatch.ident}/${mismatch.relativePath}`));
+  }
+  const byIdent = new Map;
+  for (const candidate of candidates) {
+    const group = byIdent.get(candidate.ident) ?? [];
+    group.push(candidate);
+    byIdent.set(candidate.ident, group);
+  }
+  const winners = [];
+  for (const [ident, group] of byIdent) {
+    const byFile = new Map;
+    for (const candidate of group) {
+      const copies = byFile.get(candidate.withinIdent) ?? [];
+      copies.push(candidate);
+      byFile.set(candidate.withinIdent, copies);
+    }
+    const files = [];
+    for (const [withinIdent, copies] of byFile) {
+      let eligible = copies;
+      if (withinIdent === "SKILL.md") {
+        const content = [];
+        for (const copy of copies) {
+          let isStub = false;
+          try {
+            isStub = isPointerSkillMd(readFileSync17(copy.fullPath, "utf8"));
+          } catch {
+            isStub = false;
+          }
+          if (!isStub)
+            content.push(copy);
+        }
+        if (content.length > 0) {
+          eligible = content;
+        }
+      }
+      eligible.sort((left, right) => {
+        const leftHash = left.verified;
+        const rightHash = right.verified;
+        if (leftHash !== rightHash) {
+          return leftHash ? -1 : 1;
+        }
+        if (right.mtimeMs !== left.mtimeMs) {
+          return right.mtimeMs - left.mtimeMs;
+        }
+        return SYNC_AGENTS.indexOf(left.agent) - SYNC_AGENTS.indexOf(right.agent);
+      });
+      const winner = eligible[0];
+      files.push({
+        withinIdent,
+        winner,
+        alternates: copies.filter((copy) => copy !== winner).map((copy) => copy.agent)
+      });
+    }
+    files.sort((left, right) => left.withinIdent.localeCompare(right.withinIdent));
+    winners.push({ ident, files });
+  }
+  winners.sort((left, right) => left.ident.localeCompare(right.ident));
+  const totalFiles = winners.reduce((sum, skill) => sum + skill.files.length, 0);
+  const totalBytes = winners.reduce((sum, skill) => sum + skill.files.reduce((inner, file) => inner + file.winner.size, 0), 0);
+  return { manifest, sourceSnapshotSha, winners, skippedByRule, totalFiles, totalBytes };
+}
+function skillSha256(skill) {
+  const skillMd = skill.files.find((file) => file.withinIdent === "SKILL.md");
+  if (skillMd) {
+    return sha256File(skillMd.winner.fullPath);
+  }
+  if (skill.files.length === 1) {
+    return sha256File(skill.files[0].winner.fullPath);
+  }
+  const joined = skill.files.map((file) => sha256File(file.winner.fullPath));
+  return createHash7("sha256").update(joined.sort().join(`
+`)).digest("hex");
+}
+function writeStationHydration(options) {
+  const repoRoot = resolve3(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve3(options.cacheRoot ?? resolveCorpusRoot());
+  const plan = planStationHydration(options.stationId, repoRoot);
+  const resultSkills = plan.winners.map((skill) => ({
+    ident: skill.ident,
+    files: skill.files.map((file) => ({
+      relativePath: file.withinIdent,
+      sourceAgent: file.winner.agent,
+      sourceMtimeMs: file.winner.mtimeMs,
+      size: file.winner.size
+    })),
+    sha256: skillSha256(skill)
+  }));
+  const base = {
+    stationId: options.stationId,
+    mode: "dry-run",
+    cacheRoot,
+    snapshotRoot: snapshotRootFor(repoRoot, options.stationId),
+    sourceSnapshotSha: plan.sourceSnapshotSha,
+    stats: {
+      idents: plan.winners.length,
+      files: plan.totalFiles,
+      bytes: plan.totalBytes
+    },
+    winners: plan.winners,
+    skills: resultSkills
+  };
+  if (options.dryRun !== false) {
+    return base;
+  }
+  const conflicts = [];
+  const toWrite = [];
+  for (const skill of plan.winners) {
+    for (const file of skill.files) {
+      const destination = join21(cacheRoot, skill.ident, file.withinIdent);
+      const digest = sha256File(file.winner.fullPath);
+      let existingDigest = null;
+      try {
+        existingDigest = sha256File(destination);
+      } catch {}
+      if (existingDigest !== null) {
+        if (existingDigest === digest) {
+          continue;
+        }
+        conflicts.push(`existing destination differs from snapshot winner: ${destination}`);
+        continue;
+      }
+      toWrite.push({ destination, fullPath: file.winner.fullPath });
+    }
+  }
+  if (conflicts.length > 0) {
+    fail("CONFLICT", `${conflicts.length} conflict(s); terminal non-acceptance, nothing written`, conflicts);
+  }
+  let written = 0;
+  for (const entry of toWrite) {
+    mkdirSync14(dirname12(entry.destination), { recursive: true });
+    copyFileSync3(entry.fullPath, entry.destination);
+    written += 1;
+  }
+  const unchanged = plan.totalFiles - written;
+  const hydration = {
+    schema: STATION_HYDRATION_MANIFEST_SCHEMA,
+    stationId: options.stationId,
+    hydratedAt: new Date().toISOString(),
+    producer: STATION_HYDRATION_PRODUCER,
+    sourceSnapshotSha: plan.sourceSnapshotSha,
+    cacheRoot,
+    stats: {
+      idents: plan.winners.length,
+      written,
+      unchanged,
+      files: plan.totalFiles,
+      bytes: plan.totalBytes
+    },
+    skills: resultSkills
+  };
+  const hydrationManifestPath = join21(dirname12(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync14(dirname12(hydrationManifestPath), { recursive: true });
+  writeFileSync13(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
+`);
+  return {
+    ...base,
+    mode: "apply",
+    stats: { ...base.stats, written, unchanged },
+    manifestPath: hydrationManifestPath
+  };
+}
 export {
+  writeStationSnapshot,
+  writeStationHydration,
   writeRunLogs,
   writeRegistrySyncArtifact,
   writeManagedSkillDir,
   writeManagedAgentSkill,
   writeCorpusSkill,
+  walkEntries,
   verifyContentHash,
   validateToolPrimitiveCoverage,
+  validateStationId,
   validateSkillsCliMcpParity,
   validateSkillDirectory,
   validateRegistryConsistency,
@@ -12016,6 +12757,7 @@ export {
   skillsPostgresSyncSchemaSql,
   skillExists,
   signSkillsAwsV4Request,
+  sha256File,
   setSkillDisabled,
   setScheduleEnabled,
   searchSkills,
@@ -12043,6 +12785,8 @@ export {
   portPortableSkillDirectory,
   portPortableSkill,
   pointerSkillMd,
+  planStationSnapshot,
+  planStationHydration,
   planSkillsS3SnapshotUpload,
   pinSkill,
   pinProjectSkill,
@@ -12068,7 +12812,10 @@ export {
   listPinnedSkills,
   listMcpToolContracts,
   isSyncAgent,
+  isRegularFile,
+  isPortableWithinSkill,
   isGatewayBackedSkill,
+  isExcludedSkillFileName,
   isBasicSkillName,
   installSkills,
   installSkillSource,
@@ -12076,6 +12823,7 @@ export {
   installSkillForAgent,
   installSkill,
   importSkillsLocalSnapshot,
+  homePathFor,
   getToolPrimitive,
   getStorageStatus,
   getStorageDatabaseUrl,
@@ -12125,6 +12873,7 @@ export {
   ensureProjectConfig,
   enableSkill,
   disableSkill,
+  destinationFor,
   describeMcpToolContracts,
   createSkillsSnapshotSyncRecord,
   createSkillsS3ObjectStore,
@@ -12148,12 +12897,16 @@ export {
   adaptSkillMdForAgent,
   TOOL_PRIMITIVE_SCHEMA_VERSION,
   TOOL_PRIMITIVES,
+  StationSnapshotError,
   SkillsS3ObjectStore,
   SkillsPostgresSyncStore,
   SYNC_MARKER_MANAGED_BY,
   SYNC_MARKER_FILE,
+  SYNC_HOMES,
   SYNC_AGENTS,
   STORAGE_TABLES,
+  STATION_SYNC_MANIFEST_SCHEMA,
+  STATION_HYDRATION_MANIFEST_SCHEMA,
   SKILL_SYSTEM_DEPS_ALLOWLIST,
   SKILL_SANDBOX_MODES,
   SKILL_RUNTIMES,
@@ -12170,6 +12923,7 @@ export {
   RemoteRouteUnsupportedError,
   RemoteRequestError,
   REMOTE_SKILL_RUN_CONTRACT_VERSION,
+  REFUSED_SCANNER_FLAGGED,
   PullSkillError,
   PROJECT_CONFIG_FILE,
   PORTABLE_SKILL_STANDARD,