@hasna/skills 0.1.70 → 0.1.72

package/bin/index.js

@@ -36860,7 +36860,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.1.70",
+    version: "0.1.72",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -36952,6 +36952,7 @@ var init_package = __esm(() => {
       "@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",
@@ -37917,10 +37918,127 @@ var init_retired_settings = __esm(() => {
   };
 });
 
-// src/lib/config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
-import { join as join3, dirname } from "path";
+// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
 import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+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(platform2) {
+  return platform2 === "darwin";
+}
+function baseDir(kind, options) {
+  const override = envValue(options, kind);
+  if (override)
+    return override;
+  const home = options.home ?? homedir2();
+  const platform2 = options.platform ?? process.platform;
+  if (isMacOS(platform2)) {
+    switch (kind) {
+      case "config":
+      case "data":
+        return join3(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return join3(home, "Library", "Caches", "Hasna");
+      case "state":
+        return join3(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return join3(home, ".config", "hasna");
+    case "data":
+      return join3(home, ".local", "share", "hasna");
+    case "state":
+      return join3(home, ".local", "state", "hasna");
+    case "cache":
+      return join3(home, ".cache", "hasna");
+  }
+}
+function resolvePath(kind, options) {
+  assertApp(options.app);
+  const appSegment = options.internal === true ? join3("internal", options.app) : options.app;
+  return join3(baseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return resolvePath("data", options);
+}
+var KIND_ENV, APP_SLUG_RE;
+var init_dist = __esm(() => {
+  KIND_ENV = {
+    config: "HASNA_CONFIG_HOME",
+    data: "HASNA_DATA_HOME",
+    state: "HASNA_STATE_HOME",
+    cache: "HASNA_CACHE_HOME"
+  };
+  APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+});
+
+// src/lib/app-home.ts
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve } from "path";
+function effectiveHome() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir3() || "/tmp";
+}
+function legacyDataRoot() {
+  return join4(effectiveHome(), ".hasna", "skills");
+}
+function resolverDataRoot(home = effectiveHome()) {
+  return dataDir({ app: "skills", home });
+}
+function adoptResolverDataRoot(resolved, env3 = process.env) {
+  const dataOverride = env3.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync3(join4(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync3(join4(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(env3 = process.env) {
+  return Boolean(env3[DATA_DIR_ENV]?.trim()) || Boolean(env3[HASNA_SKILLS_HOME_ENV]?.trim()) || Boolean(env3[SKILLS_HOME_ENV]?.trim());
+}
+function hasOperatorOverride(env3 = process.env) {
+  return hasExactOverride(env3) || Boolean(env3.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(join4(home, ".hasna", "skills"));
+}
+var DATA_DIR_ENV = "HASNA_SKILLS_DIR", HASNA_SKILLS_HOME_ENV = "HASNA_SKILLS_HOME", SKILLS_HOME_ENV = "SKILLS_HOME", DEFAULT_SQLITE_FILENAME = "server.db", GLOBAL_CONFIG_FILENAME = "config.json";
+var init_app_home = __esm(() => {
+  init_dist();
+});
+
+// src/lib/config.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join5, dirname } from "path";
+import { homedir as homedir4 } from "os";
 function validKeys() {
   return [...Object.keys(ENUM_KEYS), ...STRING_KEYS];
 }
@@ -37928,19 +38046,19 @@ function allowedValues(key) {
   return ENUM_KEYS[key];
 }
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync3(sourceDir))
+  if (!existsSync4(sourceDir))
     return;
   mkdirSync(targetDir, { recursive: true });
   for (const entry of readdirSync(sourceDir)) {
-    const sourcePath = join3(sourceDir, entry);
-    const targetPath = join3(targetDir, entry);
+    const sourcePath = join5(sourceDir, entry);
+    const targetPath = join5(targetDir, entry);
     try {
       const sourceStat = statSync(sourcePath);
       if (sourceStat.isDirectory()) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync3(targetPath))
+      if (!existsSync4(targetPath))
         copyFileSync(sourcePath, targetPath);
     } catch {}
   }
@@ -37966,48 +38084,42 @@ function normalizeConfigValue(key, value) {
   return;
 }
 function isOwnerLayoutMigrated(appDir) {
-  return existsSync3(join3(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+  return existsSync4(join5(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"] || homedir2();
-  const newDir = join3(home, ".hasna", "skills");
-  const oldDir = join3(home, ".skills");
-  const oldConfigFile = join3(home, ".skillsrc");
-  mkdirSync(newDir, { recursive: true });
+  const root = getDataRoot();
+  try {
+    mkdirSync(root, { recursive: true });
+  } catch {}
+  if (hasOperatorOverride())
+    return root;
+  const home = effectiveHome();
+  const oldDir = join5(home, ".skills");
+  const oldConfigFile = join5(home, ".skillsrc");
   try {
-    mergeDirectoryContents(oldDir, newDir);
+    mergeDirectoryContents(oldDir, root);
   } catch {}
-  if (existsSync3(oldConfigFile) && !existsSync3(join3(newDir, "config.json"))) {
+  if (existsSync4(oldConfigFile) && !existsSync4(join5(root, "config.json"))) {
     try {
-      copyFileSync(oldConfigFile, join3(newDir, "config.json"));
+      copyFileSync(oldConfigFile, join5(root, "config.json"));
     } catch {}
   }
-  return newDir;
+  return root;
 }
 function getDataDirReadOnly() {
-  const override = process.env[DATA_DIR_ENV];
-  if (override)
-    return override;
-  return join3(process.env["HOME"] || process.env["USERPROFILE"] || homedir2(), ".hasna", "skills");
+  return getDataRoot();
 }
 function getConfigPathReadOnly(scope) {
   if (scope === "global")
-    return join3(getDataDirReadOnly(), "config.json");
-  return join3(process.cwd(), "skills.config.json");
+    return join5(getDataDirReadOnly(), "config.json");
+  return join5(process.cwd(), "skills.config.json");
 }
 function loadConfigReadOnly() {
   const canonicalConfigPath = getConfigPathReadOnly("global");
   let globalConfig;
-  if (existsSync3(canonicalConfigPath)) {
+  if (existsSync4(canonicalConfigPath)) {
     globalConfig = readConfigFile(canonicalConfigPath);
-  } else if (process.env[DATA_DIR_ENV] !== undefined) {
+  } else if (hasOperatorOverride()) {
     globalConfig = {};
   } else {
     globalConfig = readConfigFile(legacyConfigFilePath());
@@ -38016,16 +38128,16 @@ function loadConfigReadOnly() {
   return { ...globalConfig, ...projectConfig };
 }
 function legacyConfigFilePath() {
-  return join3(process.env["HOME"] || process.env["USERPROFILE"] || homedir2(), ".skillsrc");
+  return join5(process.env["HOME"] || process.env["USERPROFILE"] || homedir4(), ".skillsrc");
 }
 function getConfigPath(scope) {
   if (scope === "global") {
-    return join3(getDataDir(), "config.json");
+    return join5(getDataDir(), "config.json");
   }
-  return join3(process.cwd(), "skills.config.json");
+  return join5(process.cwd(), "skills.config.json");
 }
 function readConfigFile(path) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return {};
   let parsed;
   try {
@@ -38061,7 +38173,7 @@ function saveConfig(key, value, scope = "project") {
   }
   const filePath = getConfigPath(scope);
   let existing = {};
-  if (existsSync3(filePath)) {
+  if (existsSync4(filePath)) {
     try {
       existing = JSON.parse(readFileSync2(filePath, "utf-8"));
       if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
@@ -38072,7 +38184,7 @@ function saveConfig(key, value, scope = "project") {
     }
   } else {
     const dir = dirname(filePath);
-    if (!existsSync3(dir)) {
+    if (!existsSync4(dir)) {
       mkdirSync(dir, { recursive: true });
     }
   }
@@ -38086,7 +38198,7 @@ function unsetConfig(key, scope = "project") {
     throw new Error(`Unknown config key: ${key}. Valid keys: ${validKeys().join(", ")}`);
   }
   const filePath = getConfigPath(scope);
-  if (!existsSync3(filePath))
+  if (!existsSync4(filePath))
     return false;
   let existing;
   try {
@@ -38104,9 +38216,11 @@ function unsetConfig(key, scope = "project") {
 `);
   return true;
 }
-var ENUM_KEYS, STRING_KEYS, DATA_DIR_ENV = "HASNA_SKILLS_DIR", INSTALLED_SKILLS_DIRNAME = "installed", SKILLS_CACHE_DIRNAME = "skills", LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
+var ENUM_KEYS, STRING_KEYS, INSTALLED_SKILLS_DIRNAME = "installed", SKILLS_CACHE_DIRNAME = "skills", LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
 var init_config = __esm(() => {
   init_retired_settings();
+  init_app_home();
+  init_app_home();
   ENUM_KEYS = {
     defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
     defaultScope: ["global", "project"],
@@ -38904,8 +39018,8 @@ var init_registry_data = __esm(() => {
 });
 
 // src/lib/hosted-skill-set.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
 function normalizeMarker(value) {
   return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
@@ -38916,8 +39030,8 @@ function isHostedMetadataPackage(pkg) {
   return HOSTED_RUNTIMES.has(normalizeMarker(skills.runtime)) || HOSTED_SOURCES.has(normalizeMarker(skills.source));
 }
 function isHostedMetadataSkillDir(skillDir) {
-  const pkgPath = join4(skillDir, "package.json");
-  if (!existsSync4(pkgPath))
+  const pkgPath = join6(skillDir, "package.json");
+  if (!existsSync5(pkgPath))
     return false;
   try {
     return isHostedMetadataPackage(JSON.parse(readFileSync3(pkgPath, "utf8")));
@@ -38945,8 +39059,8 @@ var init_hosted_skill_set = __esm(() => {
 });
 
 // src/lib/skill-validation.ts
-import { existsSync as existsSync5, lstatSync, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { isAbsolute, join as join5, normalize } from "path";
+import { existsSync as existsSync6, lstatSync, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join7, normalize } from "path";
 function add2(target, code, message) {
   target.push({ code, message });
 }
@@ -39035,7 +39149,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     binCommands: [],
     docFiles: []
   };
-  if (!existsSync5(skillPath)) {
+  if (!existsSync6(skillPath)) {
     add2(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
     return {
       name: bareName,
@@ -39050,7 +39164,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     add2(issues, "skill.name_invalid", `Skill name '${bareName}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
   }
   for (const entry of readdirSync3(skillPath).sort()) {
-    const entryPath = join5(skillPath, entry);
+    const entryPath = join7(skillPath, entry);
     if (RESERVED_SKILL_ENTRIES.has(entry)) {
       add2(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
     }
@@ -39062,14 +39176,14 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync5(join5(skillPath, docFile)))
+    if (existsSync6(join7(skillPath, docFile)))
       metadata.docFiles.push(docFile);
   }
   if (metadata.docFiles.length === 0) {
     add2(issues, "skill.docs_missing", "Missing documentation file: expected SKILL.md, README.md, or CLAUDE.md");
   }
-  const skillMdPath = join5(skillPath, "SKILL.md");
-  if (existsSync5(skillMdPath)) {
+  const skillMdPath = join7(skillPath, "SKILL.md");
+  if (existsSync6(skillMdPath)) {
     const frontmatter = parseSkillFrontmatter(readFileSync4(skillMdPath, "utf-8"));
     if (!frontmatter) {
       add2(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
@@ -39112,8 +39226,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join5(skillPath, "package.json");
-  if (!existsSync5(pkgPath)) {
+  const pkgPath = join7(skillPath, "package.json");
+  if (!existsSync6(pkgPath)) {
     if (!isInstruction)
       add2(issues, "package.missing", "Missing package.json");
   } else {
@@ -39171,8 +39285,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
               add2(issues, "package.bin_target_unsafe", `package.json bin '${command}' target '${target}' must stay inside the skill directory`);
               continue;
             }
-            const targetPath = join5(skillPath, target);
-            if (!existsSync5(targetPath)) {
+            const targetPath = join7(skillPath, target);
+            if (!existsSync6(targetPath)) {
               add2(warnings, "package.bin_target_missing", `package.json bin '${command}' target '${target}' is not present before build`);
             } else if (statSync3(targetPath).isDirectory()) {
               add2(issues, "package.bin_target_directory", `package.json bin '${command}' target '${target}' must point to a file, not a directory`);
@@ -39189,17 +39303,17 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join5(skillPath, "src");
+    const srcDir = join7(skillPath, "src");
     if (hostedMetadata) {
-      if (existsSync5(srcDir)) {
+      if (existsSync6(srcDir)) {
         add2(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
       }
-    } else if (!existsSync5(srcDir)) {
+    } else if (!existsSync6(srcDir)) {
       add2(issues, "skill.src_missing", "Missing src/ directory");
-    } else if (!existsSync5(join5(srcDir, "index.ts")) && !existsSync5(join5(srcDir, "index.js"))) {
+    } else if (!existsSync6(join7(srcDir, "index.ts")) && !existsSync6(join7(srcDir, "index.js"))) {
       add2(issues, "skill.src_index_missing", "Missing src/index.ts or src/index.js");
     } else {
-      const indexPath = existsSync5(join5(srcDir, "index.ts")) ? join5(srcDir, "index.ts") : join5(srcDir, "index.js");
+      const indexPath = existsSync6(join7(srcDir, "index.ts")) ? join7(srcDir, "index.ts") : join7(srcDir, "index.js");
       const size2 = statSync3(indexPath).size;
       if (size2 < 50)
         add2(warnings, "skill.src_index_minimal", `Source entry point is very small (${size2}B)`);
@@ -39270,8 +39384,8 @@ var init_skill_validation = __esm(() => {
 
 // src/lib/skill-hash.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
-import { join as join6, sep } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { join as join8, sep } from "path";
 function normalizeLineEndings(content) {
   return content.replace(/\r\n/g, `
 `).replace(/\r/g, `
@@ -39317,8 +39431,8 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join6(skillPath, entry);
-    if (!existsSync6(absolute))
+    const absolute = join8(skillPath, entry);
+    if (!existsSync7(absolute))
       continue;
     if (statSync4(absolute).isDirectory())
       collectDirectory(files, absolute, entry);
@@ -39331,7 +39445,7 @@ function collectDirectory(files, dir, rel) {
   for (const entry of readdirSync4(dir).sort()) {
     if (entry.startsWith("."))
       continue;
-    const absolute = join6(dir, entry);
+    const absolute = join8(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
@@ -39586,14 +39700,14 @@ var init_skill_contract = __esm(() => {
 // src/lib/portable-skills-files.ts
 import {
   cpSync,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync6,
   realpathSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join7, relative } from "path";
+import { basename, dirname as dirname2, join as join9, relative } from "path";
 function defaultRuntimeContract(entrypoint = "src/index.ts") {
   return {
     runtime: "bun",
@@ -39617,12 +39731,12 @@ function normalizePortableSkillName(name) {
   return normalized;
 }
 function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
-  const skillJsonPath = join7(skillPath, "skill.json");
-  const skillMdPath = join7(skillPath, "SKILL.md");
-  const pkgPath = join7(skillPath, "package.json");
-  const jsonManifest = existsSync7(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync7(skillMdPath) ? parseSkillFrontmatter(readFileSync6(skillMdPath, "utf-8")) ?? undefined : undefined;
-  const pkg = existsSync7(pkgPath) ? readJsonObject(pkgPath) : undefined;
+  const skillJsonPath = join9(skillPath, "skill.json");
+  const skillMdPath = join9(skillPath, "SKILL.md");
+  const pkgPath = join9(skillPath, "package.json");
+  const jsonManifest = existsSync8(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
+  const frontmatter = existsSync8(skillMdPath) ? parseSkillFrontmatter(readFileSync6(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const pkg = existsSync8(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;
@@ -39668,7 +39782,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join7(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join9(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -39717,12 +39831,12 @@ function createPortableManifest(name, options) {
   };
 }
 function writePortableSkillTemplate(skillPath, manifest) {
-  mkdirSync2(join7(skillPath, "src"), { recursive: true });
-  writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync2(join7(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync2(join7(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync2(join7(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync2(join7(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+  mkdirSync2(join9(skillPath, "src"), { recursive: true });
+  writeFileSync2(join9(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync2(join9(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync2(join9(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync2(join9(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync2(join9(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -39747,7 +39861,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join7(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync2(join9(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash = computeContentHash(skillPath);
   const withHash = {
@@ -39757,13 +39871,13 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join7(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync2(join9(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
 `);
   return withHash;
 }
 function readExistingSkillJson(skillPath) {
-  const path = join7(skillPath, "skill.json");
-  if (!existsSync7(path))
+  const path = join9(skillPath, "skill.json");
+  if (!existsSync8(path))
     return {};
   try {
     const parsed = JSON.parse(readFileSync6(path, "utf-8"));
@@ -39796,28 +39910,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 && !existsSync7(join7(skillPath, entry))) {
-    mkdirSync2(dirname2(join7(skillPath, entry)), { recursive: true });
-    writeFileSync2(join7(skillPath, entry), renderEntrypoint(next));
+  if (entry && !existsSync8(join9(skillPath, entry))) {
+    mkdirSync2(dirname2(join9(skillPath, entry)), { recursive: true });
+    writeFileSync2(join9(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync7(join7(skillPath, "SKILL.md")))
-    writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync8(join9(skillPath, "SKILL.md")))
+    writeFileSync2(join9(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync2(join7(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync6(join7(skillPath, "SKILL.md"), "utf-8"), next));
-  if (!existsSync7(join7(skillPath, "AGENTS.md")))
-    writeFileSync2(join7(skillPath, "AGENTS.md"), renderAgentsMd(next));
+    writeFileSync2(join9(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync6(join9(skillPath, "SKILL.md"), "utf-8"), next));
+  if (!existsSync8(join9(skillPath, "AGENTS.md")))
+    writeFileSync2(join9(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
-  if (!existsSync7(join7(skillPath, "tsconfig.json")))
-    writeFileSync2(join7(skillPath, "tsconfig.json"), renderTsconfig());
+  if (!existsSync8(join9(skillPath, "tsconfig.json")))
+    writeFileSync2(join9(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
 function ensurePackageJson(skillPath, manifest) {
-  const pkgPath = join7(skillPath, "package.json");
+  const pkgPath = join9(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 (!existsSync7(pkgPath)) {
+  if (!existsSync8(pkgPath)) {
     writeFileSync2(pkgPath, renderPackageJson(manifest));
     return;
   }
@@ -39860,8 +39974,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync7(join7(skillPath, "SKILL.md"))) {
-    writeFileSync2(join7(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync8(join9(skillPath, "SKILL.md"))) {
+    writeFileSync2(join9(skillPath, "SKILL.md"), renderSkillMd(next));
   }
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
@@ -40168,7 +40282,7 @@ var init_portable_skills_files = __esm(() => {
 // src/lib/portable-skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync3,
   mkdtempSync,
   readdirSync as readdirSync5,
@@ -40177,22 +40291,22 @@ import {
   statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join8, normalize as normalize2 } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join10, normalize as normalize2 } from "path";
 function getPortableSkillsRoot(options = {}) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join8(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache3 = join8(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join10(options.homeDir, ".hasna", "skills") : getDataDir();
+  const cache3 = join10(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache3))
     return cache3;
-  const installed = join8(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join10(appDir, INSTALLED_SKILLS_DIRNAME);
   migrateLegacySkillLayout(appDir, installed);
   return installed;
 }
 function looksLikeSkillDirectory(path) {
   if (!safeIsDirectory(path))
     return false;
-  return existsSync8(join8(path, "SKILL.md")) || existsSync8(join8(path, "skill.json")) || existsSync8(join8(path, "package.json"));
+  return existsSync9(join10(path, "SKILL.md")) || existsSync9(join10(path, "skill.json")) || existsSync9(join10(path, "package.json"));
 }
 function migrateLegacySkillLayout(appDir, installed) {
   if (!safeIsDirectory(appDir))
@@ -40202,7 +40316,7 @@ function migrateLegacySkillLayout(appDir, installed) {
     for (const entry of readdirSync5(appDir)) {
       if (entry.startsWith(".") || entry === INSTALLED_SKILLS_DIRNAME)
         continue;
-      const path = join8(appDir, entry);
+      const path = join10(appDir, entry);
       if (entry === LEGACY_CUSTOM_DIRNAME) {
         if (!safeIsDirectory(path))
           continue;
@@ -40210,7 +40324,7 @@ function migrateLegacySkillLayout(appDir, installed) {
           for (const nested of readdirSync5(path)) {
             if (nested.startsWith("."))
               continue;
-            const nestedPath = join8(path, nested);
+            const nestedPath = join10(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -40224,10 +40338,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join8(installed, name);
-    if (existsSync8(target))
+    const target = join10(installed, name);
+    if (existsSync9(target))
       continue;
-    const staging = join8(installed, `.migrating-${name}-${process.pid}`);
+    const staging = join10(installed, `.migrating-${name}-${process.pid}`);
     try {
       rmSync(staging, { recursive: true, force: true });
       cpSync2(from, staging, { recursive: true, errorOnExist: false });
@@ -40240,7 +40354,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join8(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join10(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -40250,7 +40364,7 @@ function findPortableSkill(name, options = {}) {
     return null;
   }
   const path = getPortableSkillPath(normalized, options);
-  if (!existsSync8(path) || !statSync6(path).isDirectory())
+  if (!existsSync9(path) || !statSync6(path).isDirectory())
     return null;
   try {
     return summarizePortableSkill(path, normalized);
@@ -40266,7 +40380,7 @@ function listPortableSkills(options = {}) {
   for (const entry of readdirSync5(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join8(root, entry);
+    const path = join10(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -40299,8 +40413,8 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizePortableSkillName(name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join8(root, skillName);
-  if (existsSync8(skillPath)) {
+  const skillPath = join10(root, skillName);
+  if (existsSync9(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
     rmSync(skillPath, { recursive: true, force: true });
@@ -40318,7 +40432,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkillDirectory(sourceDir, options = {}) {
   const absoluteSource = normalize2(sourceDir);
-  if (!existsSync8(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
+  if (!existsSync9(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Import directory not found: ${sourceDir}`);
   }
   const continueOnError = options.continueOnError ?? true;
@@ -40331,7 +40445,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 = join8(absoluteSource, entryName);
+    const childPath = join10(absoluteSource, entryName);
     if (!safeIsDirectory(childPath))
       continue;
     if (!isSkillCandidate(childPath)) {
@@ -40360,11 +40474,11 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
 }
 function isSkillCandidate(dir) {
-  return existsSync8(join8(dir, "SKILL.md")) || existsSync8(join8(dir, "skill.json")) || existsSync8(join8(dir, "package.json"));
+  return existsSync9(join10(dir, "SKILL.md")) || existsSync9(join10(dir, "skill.json")) || existsSync9(join10(dir, "package.json"));
 }
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize2(sourcePath);
-  if (!existsSync8(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
+  if (!existsSync9(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Skill source directory not found: ${sourcePath}`);
   }
   const inferred = readPortableSkillManifest(absoluteSource, basename2(absoluteSource));
@@ -40376,8 +40490,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 = join8(root, skillName);
-  if (existsSync8(destination)) {
+  const destination = join10(root, skillName);
+  if (existsSync9(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync(destination, { recursive: true, force: true });
@@ -40419,19 +40533,19 @@ function buildCorpusManifest(input, name) {
 function installCorpusSkillAtomically(input, options = {}) {
   const name = normalizePortableSkillName(input.name);
   const root = getPortableSkillsRoot(options);
-  const target = join8(root, name);
-  const created = !existsSync8(target);
+  const target = join10(root, name);
+  const created = !existsSync9(target);
   mkdirSync3(root, { recursive: true });
-  const staging = mkdtempSync(join8(root, `.pull-${name}-`));
+  const staging = mkdtempSync(join10(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
-    writeFileSync3(join8(staging, "SKILL.md"), input.skillMd);
+    writeFileSync3(join10(staging, "SKILL.md"), input.skillMd);
     const manifest = buildCorpusManifest(input, name);
     writeSkillJsonWithHash(staging, manifest);
-    if (existsSync8(target)) {
-      backup = mkdtempSync(join8(root, `.pull-backup-${name}-`));
-      renameSync(target, join8(backup, name));
+    if (existsSync9(target)) {
+      backup = mkdtempSync(join10(root, `.pull-backup-${name}-`));
+      renameSync(target, join10(backup, name));
       moved = true;
     }
     renameSync(staging, target);
@@ -40440,9 +40554,9 @@ function installCorpusSkillAtomically(input, options = {}) {
     return { name, path: target, manifest, created };
   } catch (error) {
     rmSync(staging, { recursive: true, force: true });
-    if (moved && backup && existsSync8(join8(backup, name))) {
+    if (moved && backup && existsSync9(join10(backup, name))) {
       try {
-        renameSync(join8(backup, name), target);
+        renameSync(join10(backup, name), target);
       } catch {}
     }
     throw error;
@@ -40454,10 +40568,10 @@ function validatePortableSkillDirectory(name, skillPath) {
   const issues = [...base2.issues];
   const warnings = [...base2.warnings];
   let manifest;
-  if (existsSync8(skillPath)) {
-    const skillJsonPath = join8(skillPath, "skill.json");
-    const skillMdPath = join8(skillPath, "SKILL.md");
-    if (!existsSync8(skillJsonPath) && !existsSync8(skillMdPath)) {
+  if (existsSync9(skillPath)) {
+    const skillJsonPath = join10(skillPath, "skill.json");
+    const skillMdPath = join10(skillPath, "SKILL.md");
+    if (!existsSync9(skillJsonPath) && !existsSync9(skillMdPath)) {
       add4(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
     try {
@@ -40476,7 +40590,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add4(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync8(join8(skillPath, "skill.json")),
+        strict: existsSync9(join10(skillPath, "skill.json")),
         skillPath
       });
       for (const issue of contractIssues)
@@ -40512,8 +40626,8 @@ function validatePortableSkillDirectory(name, skillPath) {
               add4(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
               continue;
             }
-            const entryPath = join8(skillPath, command.entry);
-            if (!existsSync8(entryPath))
+            const entryPath = join10(skillPath, command.entry);
+            if (!existsSync9(entryPath))
               add4(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
             else if (statSync6(entryPath).isDirectory())
               add4(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
@@ -40523,7 +40637,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error) {
       add4(issues, "portable.manifest_invalid", error.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync8(join8(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync9(join10(skillPath, "AGENTS.md"))) {
       add4(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -40792,8 +40906,8 @@ __export(exports_registry, {
   CATEGORIES: () => CATEGORIES,
   BASIC_SKILL_NAMES: () => BASIC_SKILL_NAMES
 });
-import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync6 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7, readdirSync as readdirSync6 } from "fs";
+import { join as join11 } from "path";
 function isBasicSkillName(name) {
   return BASIC_SKILL_NAMES.includes(name);
 }
@@ -40829,7 +40943,7 @@ function parseSkillMdFrontmatter(content) {
   return Object.keys(result2).length > 0 ? result2 : null;
 }
 function discoverSkillsInDir(dir, source = "custom") {
-  if (!existsSync9(dir))
+  if (!existsSync10(dir))
     return [];
   const result2 = [];
   try {
@@ -40837,8 +40951,8 @@ function discoverSkillsInDir(dir, source = "custom") {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join9(dir, entry.name, "SKILL.md");
-      if (!existsSync9(skillMdPath))
+      const skillMdPath = join11(dir, entry.name, "SKILL.md");
+      if (!existsSync10(skillMdPath))
         continue;
       let content;
       try {
@@ -40857,7 +40971,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
-        ...isHostedMetadataSkillDir(join9(dir, entry.name)) ? { serverOwned: true } : {},
+        ...isHostedMetadataSkillDir(join11(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -40866,16 +40980,16 @@ function discoverSkillsInDir(dir, source = "custom") {
 }
 function findExtensionSkillPath(name) {
   const config = loadConfig();
-  if (!config.extensionsDir || !existsSync9(config.extensionsDir))
+  if (!config.extensionsDir || !existsSync10(config.extensionsDir))
     return null;
   try {
     const entries = readdirSync6(config.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join9(config.extensionsDir, entry.name);
-      const skillMdPath = join9(skillDir, "SKILL.md");
-      if (!existsSync9(skillMdPath))
+      const skillDir = join11(config.extensionsDir, entry.name);
+      const skillMdPath = join11(skillDir, "SKILL.md");
+      if (!existsSync10(skillMdPath))
         continue;
       let content;
       try {
@@ -40903,12 +41017,12 @@ function loadRegistry(cwd2) {
   if (registryCache && registryCacheKey === rootKey && now3 - 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(join9(dataDir, "custom"));
+  const legacyCustom = discoverSkillsInDir(join11(dataDir2, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now3;
@@ -42607,16 +42721,16 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/home-migration.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync7, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync7, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join12 } from "path";
 function layoutMigrationRecordPath(appDir) {
-  return join10(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
+  return join12(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
 }
 function resolveCorpusRoot(options = {}) {
   return getPortableSkillsRoot(options);
 }
 function migrationAppDir(homeDir) {
-  return homeDir ? join10(homeDir, ".hasna", "skills") : getDataDir();
+  return homeDir ? join12(homeDir, ".hasna", "skills") : getDataDir();
 }
 function looksLikeSkillDirectory2(path) {
   try {
@@ -42625,11 +42739,11 @@ function looksLikeSkillDirectory2(path) {
   } catch {
     return false;
   }
-  return existsSync10(join10(path, "SKILL.md")) || existsSync10(join10(path, "skill.json")) || existsSync10(join10(path, "package.json"));
+  return existsSync11(join12(path, "SKILL.md")) || existsSync11(join12(path, "skill.json")) || existsSync11(join12(path, "package.json"));
 }
 function listLegacyFlatSkillDirs(appDir) {
   const legacy = [];
-  if (!existsSync10(appDir))
+  if (!existsSync11(appDir))
     return legacy;
   let entries = [];
   try {
@@ -42643,15 +42757,15 @@ function listLegacyFlatSkillDirs(appDir) {
     if (entry === SKILLS_CACHE_DIRNAME || entry === INSTALLED_SKILLS_DIRNAME || entry === LEGACY_CUSTOM_DIRNAME2 || entry === LOGS_DIRNAME || entry === OUTPUTS_DIRNAME) {
       continue;
     }
-    if (looksLikeSkillDirectory2(join10(appDir, entry)))
+    if (looksLikeSkillDirectory2(join12(appDir, entry)))
       legacy.push(entry);
   }
   return legacy;
 }
 function createLazyDirs(appDir, created) {
   for (const name of [LOGS_DIRNAME, OUTPUTS_DIRNAME]) {
-    const dir = join10(appDir, name);
-    if (!existsSync10(dir)) {
+    const dir = join12(appDir, name);
+    if (!existsSync11(dir)) {
       mkdirSync4(dir, { recursive: true });
       created.push(dir);
     }
@@ -42659,14 +42773,14 @@ function createLazyDirs(appDir, created) {
 }
 function migrateOwnerLayout(options = {}) {
   const appDir = migrationAppDir(options.homeDir);
-  const cache3 = join10(appDir, SKILLS_CACHE_DIRNAME);
-  const installed = join10(appDir, INSTALLED_SKILLS_DIRNAME);
+  const cache3 = join12(appDir, SKILLS_CACHE_DIRNAME);
+  const installed = join12(appDir, INSTALLED_SKILLS_DIRNAME);
   const moved = [];
   const created = [];
   if (isOwnerLayoutMigrated(appDir)) {
     return { status: "already-migrated", moved, created };
   }
-  if (existsSync10(cache3)) {
+  if (existsSync11(cache3)) {
     let entries = [];
     try {
       entries = readdirSync7(cache3);
@@ -42680,7 +42794,7 @@ function migrateOwnerLayout(options = {}) {
       };
     }
   }
-  const installedPresent = existsSync10(installed);
+  const installedPresent = existsSync11(installed);
   const legacy = listLegacyFlatSkillDirs(appDir);
   const planned = [...installedPresent ? [INSTALLED_SKILLS_DIRNAME] : [], ...legacy];
   if (!installedPresent && legacy.length === 0) {
@@ -42693,7 +42807,7 @@ function migrateOwnerLayout(options = {}) {
   }
   const collisionNames = new Set;
   for (const dir of [cache3, ...installedPresent ? [installed] : []]) {
-    if (!existsSync10(dir))
+    if (!existsSync11(dir))
       continue;
     try {
       for (const entry of readdirSync7(dir))
@@ -42710,7 +42824,7 @@ function migrateOwnerLayout(options = {}) {
       };
     }
   }
-  if (existsSync10(cache3)) {
+  if (existsSync11(cache3)) {
     rmSync2(cache3, { recursive: true, force: true });
   }
   if (installedPresent) {
@@ -42720,7 +42834,7 @@ function migrateOwnerLayout(options = {}) {
     mkdirSync4(cache3, { recursive: true });
   }
   for (const name of legacy) {
-    renameSync2(join10(appDir, name), join10(cache3, name));
+    renameSync2(join12(appDir, name), join12(cache3, name));
     moved.push(name);
   }
   createLazyDirs(appDir, created);
@@ -42744,7 +42858,7 @@ var init_home_migration = __esm(() => {
 // src/lib/agent-sync.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync5,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync8,
@@ -42754,8 +42868,8 @@ import {
   statSync as statSync8,
   writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename3, dirname as dirname4, join as join11 } from "path";
+import { homedir as homedir5 } from "os";
+import { basename as basename3, dirname as dirname4, join as join13 } from "path";
 function isSyncAgent(value) {
   return SYNC_AGENTS.includes(value);
 }
@@ -42767,12 +42881,12 @@ function resolveSyncAgents(arg) {
   }
   return [arg];
 }
-function agentGlobalSkillsDir(agent, homeDir = homedir3()) {
+function agentGlobalSkillsDir(agent, homeDir = homedir5()) {
   switch (agent) {
     case "opencode":
-      return join11(homeDir, ".config", "opencode", "skills");
+      return join13(homeDir, ".config", "opencode", "skills");
     default:
-      return join11(homeDir, `.${agent}`, "skills");
+      return join13(homeDir, `.${agent}`, "skills");
   }
 }
 function adaptSkillMdForAgent(skillMd, agent) {
@@ -42830,8 +42944,8 @@ function resolveSyncCorpus(options = {}) {
 function packageSourceRoots(source) {
   const roots = [];
   for (const sub of ["skills"]) {
-    const candidate = join11(source, sub);
-    if (existsSync11(candidate) && isDirectory(candidate))
+    const candidate = join13(source, sub);
+    if (existsSync12(candidate) && isDirectory(candidate))
       roots.push(candidate);
   }
   if (roots.length > 0)
@@ -42846,10 +42960,10 @@ function containsSkillDirectories(path) {
     return false;
   }
   return entries.some((entry) => {
-    const candidate = join11(path, entry);
+    const candidate = join13(path, entry);
     if (!isDirectory(candidate))
       return false;
-    return existsSync11(join11(candidate, "SKILL.md")) || existsSync11(join11(candidate, "skill.json")) || existsSync11(join11(candidate, "package.json"));
+    return existsSync12(join13(candidate, "SKILL.md")) || existsSync12(join13(candidate, "skill.json")) || existsSync12(join13(candidate, "package.json"));
   });
 }
 function isDirectory(path) {
@@ -42862,7 +42976,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 ?? homedir3();
+  const homeDir = options.homeDir ?? homedir5();
   const { roots, source } = resolveSyncCorpus(options);
   const corpus = listPortableSkillsAcrossRoots(roots);
   const byName = new Map(corpus.map((skill) => [skill.name, skill]));
@@ -42888,7 +43002,7 @@ function syncSkillsToAgents(options = {}) {
         actions.push({
           skill: name,
           agent,
-          path: join11(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
+          path: join13(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
           action: "skip",
           reason: "not found in this machine's corpus"
         });
@@ -42917,8 +43031,8 @@ function syncSkillsToAgents(options = {}) {
   return { actions };
 }
 function writeManagedAgentSkill(params) {
-  const homeDir = params.homeDir ?? homedir3();
-  const dir = join11(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
+  const homeDir = params.homeDir ?? homedir5();
+  const dir = join13(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
   const result2 = writeManagedSkillDir(dir, params.skillMd, {
     skill: params.skill,
     source: params.source,
@@ -42935,11 +43049,11 @@ function writeManagedAgentSkill(params) {
   };
 }
 function writeManagedSkillDir(dir, skillMd, options) {
-  const skillMdPath = join11(dir, "SKILL.md");
-  const markerPath = join11(dir, SYNC_MARKER_FILE);
-  const dirExists = existsSync11(dir);
-  const managed = existsSync11(markerPath);
-  const hasSkillMd = existsSync11(skillMdPath);
+  const skillMdPath = join13(dir, "SKILL.md");
+  const markerPath = join13(dir, SYNC_MARKER_FILE);
+  const dirExists = existsSync12(dir);
+  const managed = existsSync12(markerPath);
+  const hasSkillMd = existsSync12(skillMdPath);
   if (dirExists && !managed && !hasSkillMd) {
     return {
       action: "skip",
@@ -42974,11 +43088,11 @@ function writeManagedSkillDir(dir, skillMd, options) {
     return { action, path: skillMdPath };
   const parentDir = dirname4(dir);
   mkdirSync5(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync2(join11(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
-  const candidateDir = join11(transactionDir, "candidate");
-  const backupDir = join11(transactionDir, "backup");
-  const candidateSkillMdPath = join11(candidateDir, "SKILL.md");
-  const candidateMarkerPath = join11(candidateDir, SYNC_MARKER_FILE);
+  const transactionDir = mkdtempSync2(join13(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
+  const candidateDir = join13(transactionDir, "candidate");
+  const backupDir = join13(transactionDir, "backup");
+  const candidateSkillMdPath = join13(candidateDir, "SKILL.md");
+  const candidateMarkerPath = join13(candidateDir, SYNC_MARKER_FILE);
   const marker = {
     managedBy: SYNC_MARKER_MANAGED_BY,
     skill: options.skill,
@@ -43005,9 +43119,9 @@ function writeManagedSkillDir(dir, skillMd, options) {
     }
     renameDirectory(candidateDir, dir);
   } catch (error) {
-    if (originalMoved && existsSync11(backupDir)) {
+    if (originalMoved && existsSync12(backupDir)) {
       try {
-        if (existsSync11(dir))
+        if (existsSync12(dir))
           rmSync3(dir, { recursive: true, force: true });
         renameDirectory(backupDir, dir);
         originalMoved = false;
@@ -43028,8 +43142,8 @@ function writeManagedSkillDir(dir, skillMd, options) {
 }
 function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = false) {
   if (kind === undefined || kind === "instruction" || preferBundledDocs) {
-    const skillMdPath = join11(skillPath, "SKILL.md");
-    if (existsSync11(skillMdPath))
+    const skillMdPath = join13(skillPath, "SKILL.md");
+    if (existsSync12(skillMdPath))
       return readFileSync8(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
@@ -43066,17 +43180,17 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join12(targetDir, SKILLS_PROJECT_DIR);
+  return join14(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join12(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join14(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync12(path))
+  if (!existsSync13(path))
     return null;
   try {
     return normalizeProjectConfig(JSON.parse(readFileSync9(path, "utf-8")));
@@ -43233,44 +43347,44 @@ __export(exports_installer, {
   AGENT_TARGETS: () => AGENT_TARGETS,
   AGENT_LABELS: () => AGENT_LABELS
 });
-import { existsSync as existsSync13, readFileSync as readFileSync10, rmSync as rmSync4 } from "fs";
-import { dirname as dirname5, join as join13 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync14, readFileSync as readFileSync10, rmSync as rmSync4 } from "fs";
+import { dirname as dirname5, join as join15 } from "path";
+import { homedir as homedir6 } from "os";
 import { fileURLToPath } from "url";
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join13(dir, "skills");
-    if (existsSync13(candidate) && !dir.includes(".skills"))
+    const candidate = join15(dir, "skills");
+    if (existsSync14(candidate) && !dir.includes(".skills"))
       return candidate;
     dir = dirname5(dir);
   }
-  return join13(__dirname2, "..", "skills");
+  return join15(__dirname2, "..", "skills");
 }
 function getSkillPath(name) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join13(getDataDir(), "custom", skillName);
-  if (existsSync13(legacyCustomPath))
+  const legacyCustomPath = join15(getDataDir(), "custom", skillName);
+  if (existsSync14(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join13(SKILLS_DIR, skillName);
+  return join15(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
 }
 function skillExists(name) {
-  return existsSync13(getSkillPath(name));
+  return existsSync14(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync13(getSkillPath(name))) {
+  if (!existsSync14(getSkillPath(name))) {
     const knownOfficial = Boolean(getSkill(name));
     return {
       skill: canonicalName,
@@ -43320,7 +43434,7 @@ function installRemoteSkill(skill, options = {}) {
 }
 function installSkillSource(name, _options = {}) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync13(getSkillPath(name))) {
+  if (!existsSync14(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found`, mode: "source" };
   }
   return {
@@ -43341,11 +43455,11 @@ function installSkillManifest(manifest, _options = {}) {
 }
 function createLocalSkillManifest(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync13(sourcePath))
+  if (!existsSync14(sourcePath))
     return null;
   let skillMd = "";
-  const skillMdPath = join13(sourcePath, "SKILL.md");
-  if (existsSync13(skillMdPath)) {
+  const skillMdPath = join15(sourcePath, "SKILL.md");
+  if (existsSync14(skillMdPath)) {
     skillMd = readFileSync10(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
@@ -43426,20 +43540,20 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base2 = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join13(base2, ".pi", "skills") : join13(homedir4(), ".pi", "agent", "skills");
+      return scope === "project" ? join15(base2, ".pi", "skills") : join15(homedir6(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join13(base2, ".opencode", "skills") : join13(homedir4(), ".config", "opencode", "skills");
+      return scope === "project" ? join15(base2, ".opencode", "skills") : join15(homedir6(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join13(base2, `.${agent}`, "skills") : join13(homedir4(), `.${agent}`, "skills");
+      return scope === "project" ? join15(base2, `.${agent}`, "skills") : join15(homedir6(), `.${agent}`, "skills");
   }
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
-  return join13(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join15(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync13(getSkillPath(name))) {
+  if (!existsSync14(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found` };
   }
   const scope = options.scope ?? "global";
@@ -43463,15 +43577,15 @@ function removeSkillForAgent(name, options) {
   const canonicalName = getCanonicalSkillName(name);
   const scope = options.scope ?? "global";
   const dir = getAgentSkillPath(canonicalName, options.agent, scope, options.projectDir);
-  if (!existsSync13(join13(dir, SYNC_MARKER_FILE)))
+  if (!existsSync14(join15(dir, SYNC_MARKER_FILE)))
     return false;
   rmSync4(dir, { recursive: true, force: true });
   return true;
 }
 function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  const skillMdPath = join13(sourcePath, "SKILL.md");
-  if (existsSync13(skillMdPath))
+  const skillMdPath = join15(sourcePath, "SKILL.md");
+  if (existsSync14(skillMdPath))
     return readFileSync10(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
@@ -43490,7 +43604,7 @@ function warnMissingDependencies(name, targetDir) {
 }
 function generateMinimalSkillMd(name) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync13(sourcePath))
+  if (!existsSync14(sourcePath))
     return null;
   const canonicalName = getCanonicalSkillName(name);
   const meta = getSkill(canonicalName);
@@ -43505,7 +43619,7 @@ function generateMinimalSkillMd(name) {
     "---",
     ""
   ].filter(Boolean);
-  const fallbackDoc = readFileIfExists(join13(sourcePath, "README.md")) || readFileIfExists(join13(sourcePath, "CLAUDE.md"));
+  const fallbackDoc = readFileIfExists(join15(sourcePath, "README.md")) || readFileIfExists(join15(sourcePath, "CLAUDE.md"));
   if (fallbackDoc)
     return `${frontmatter.join(`
 `)}${fallbackDoc.trim()}
@@ -43524,8 +43638,8 @@ skills run ${canonicalName}
 `;
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join13(getSkillPath(name), "package.json");
-  if (!existsSync13(pkgPath))
+  const pkgPath = join15(getSkillPath(name), "package.json");
+  if (!existsSync14(pkgPath))
     return "unknown";
   try {
     const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
@@ -43535,7 +43649,7 @@ function readBundledSkillVersion(name) {
   }
 }
 function readFileIfExists(path) {
-  return existsSync13(path) ? readFileSync10(path, "utf-8") : null;
+  return existsSync14(path) ? readFileSync10(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
@@ -47654,23 +47768,23 @@ __export(exports_auth_store, {
   getApiKey: () => getApiKey,
   clearAuthConfig: () => clearAuthConfig
 });
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7, unlinkSync } from "fs";
-import { dirname as dirname6, join as join14 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7, unlinkSync } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
+import { homedir as homedir7 } from "os";
 function getAuthFilePath() {
-  return join14(getDataDir(), "auth.json");
+  return join16(getDataDir(), "auth.json");
 }
 function getAuthFilePathReadOnly() {
-  return join14(getDataDirReadOnly(), "auth.json");
+  return join16(getDataDirReadOnly(), "auth.json");
 }
 function legacyAuthFilePath() {
-  return join14(process.env["HOME"] || process.env["USERPROFILE"] || homedir5(), ".skills", "auth.json");
+  return join16(process.env["HOME"] || process.env["USERPROFILE"] || homedir7(), ".skills", "auth.json");
 }
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const file = existsSync14(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
+    const file = existsSync15(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
     const raw = readFileSync11(file, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiKey) {
@@ -47709,7 +47823,7 @@ function getApiKey() {
 }
 function getAuthConfigReadOnly() {
   try {
-    const file = existsSync14(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
+    const file = existsSync15(getAuthFilePathReadOnly()) ? getAuthFilePathReadOnly() : legacyAuthFilePath();
     const raw = readFileSync11(file, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiKey)
@@ -48266,12 +48380,12 @@ function handleBrowseError(error) {
 async function writeJson(value, space) {
   const text = `${JSON.stringify(value, null, space)}
 `;
-  await new Promise((resolve, reject2) => {
+  await new Promise((resolve2, reject2) => {
     process.stdout.write(text, (error) => {
       if (error)
         reject2(error);
       else
-        resolve();
+        resolve2();
     });
   });
 }
@@ -48602,13 +48716,13 @@ __export(exports_skillinfo, {
   generateEnvExample: () => generateEnvExample,
   detectProjectSkills: () => detectProjectSkills
 });
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12 } from "fs";
+import { join as join17 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join15(skillPath, "SKILL.md");
-  if (!existsSync15(skillMdPath))
+  const skillMdPath = join17(skillPath, "SKILL.md");
+  if (!existsSync16(skillMdPath))
     return false;
   try {
     return parseSkillFrontmatter(readFileSync12(skillMdPath, "utf-8"))?.kind === "instruction";
@@ -48618,12 +48732,12 @@ function isInstructionSkillDir(skillPath, meta) {
 }
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync15(skillPath))
+  if (!existsSync16(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join15(skillPath, "SKILL.md")),
-    readme: readIfExists(join15(skillPath, "README.md")),
-    claudeMd: readIfExists(join15(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join17(skillPath, "SKILL.md")),
+    readme: readIfExists(join17(skillPath, "README.md")),
+    claudeMd: readIfExists(join17(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -48634,11 +48748,11 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync15(skillPath))
+  if (!existsSync16(skillPath))
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join15(skillPath, file));
+    const content = readIfExists(join17(skillPath, file));
     if (content)
       texts.push(content);
   }
@@ -48677,8 +48791,8 @@ function getSkillRequirements(name) {
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
   let dependencies = {};
-  const pkgPath = join15(skillPath, "package.json");
-  if (existsSync15(pkgPath)) {
+  const pkgPath = join17(skillPath, "package.json");
+  if (existsSync16(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
@@ -48697,9 +48811,9 @@ function isHostedPremiumSkill(skillName, meta) {
 function isPackageResolvable(pkgName, fromDir) {
   let dir = fromDir;
   while (true) {
-    if (existsSync15(join15(dir, "node_modules", pkgName, "package.json")))
+    if (existsSync16(join17(dir, "node_modules", pkgName, "package.json")))
       return true;
-    const parent = join15(dir, "..");
+    const parent = join17(dir, "..");
     if (parent === dir)
       return false;
     dir = parent;
@@ -48719,7 +48833,7 @@ async function runSkill(name, args, options = {}) {
   const meta = getSkill(name);
   const canonicalName = meta?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync15(skillPath)) {
+  if (!existsSync16(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
   if (isInstructionSkillDir(skillPath, meta)) {
@@ -48728,8 +48842,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 = join15(skillPath, "package.json");
-  if (!existsSync15(pkgPath)) {
+  const pkgPath = join17(skillPath, "package.json");
+  if (!existsSync16(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
@@ -48748,12 +48862,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join15(skillPath, entryPoint);
-  if (!existsSync15(entryPath)) {
+  const entryPath = join17(skillPath, entryPoint);
+  if (!existsSync16(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join15(skillPath, "node_modules");
-  if (!existsSync15(nodeModules)) {
+  const nodeModules = join17(skillPath, "node_modules");
+  if (!existsSync16(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -48780,8 +48894,8 @@ async function runSkill(name, args, options = {}) {
   return { exitCode };
 }
 function detectProjectSkills(cwd2 = process.cwd()) {
-  const pkgPath = join15(cwd2, "package.json");
-  if (!existsSync15(pkgPath)) {
+  const pkgPath = join17(cwd2, "package.json");
+  if (!existsSync16(pkgPath)) {
     const alwaysRecommend = ["market-research-report", "repo-onboarding-report", "blog-article"];
     const recommended2 = alwaysRecommend.map((name) => loadRegistry().find((s) => s.name === name)).filter((s) => s !== undefined);
     return { detected: [], recommended: recommended2 };
@@ -48908,7 +49022,7 @@ function generateSkillMd(name) {
   if (!meta)
     return null;
   const skillPath = getSkillPath(name);
-  if (!existsSync15(skillPath))
+  if (!existsSync16(skillPath))
     return null;
   const frontmatter = [
     "---",
@@ -48917,11 +49031,11 @@ function generateSkillMd(name) {
     "---"
   ].join(`
 `);
-  const readme = readIfExists(join15(skillPath, "README.md"));
-  const claudeMd = readIfExists(join15(skillPath, "CLAUDE.md"));
+  const readme = readIfExists(join17(skillPath, "README.md"));
+  const claudeMd = readIfExists(join17(skillPath, "CLAUDE.md"));
   let cliCommand = null;
-  const pkgPath = join15(skillPath, "package.json");
-  if (existsSync15(pkgPath)) {
+  const pkgPath = join17(skillPath, "package.json");
+  if (existsSync16(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (pkg.bin) {
@@ -48996,7 +49110,7 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync15(path)) {
+    if (existsSync16(path)) {
       return readFileSync12(path, "utf-8");
     }
   } catch {}
@@ -49032,8 +49146,8 @@ var exports_introspect = {};
 __export(exports_introspect, {
   registerIntrospect: () => registerIntrospect
 });
-import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { join as join18 } from "path";
 import { execSync } from "child_process";
 function registerIntrospect(parent) {
   parent.command("info").argument("<skill>", "Skill name").option("--json", "Output as JSON", false).option("--brief", "Single line: name \u2014 description [category] (tags: ...)", false).option("--remote", "Use remote registry from SKILLS_API_URL or config apiUrl", false).description("Show details about a specific skill").action((name, options) => {
@@ -49254,20 +49368,20 @@ function handleDiff(name, options) {
   const bare = name;
   const normalized = normalizePortableSkillName(bare);
   const sourcePath = getSkillPath(bare);
-  const canonicalDir = join16(resolveCorpusRoot(), normalized);
-  const canonicalSkillMd = join16(canonicalDir, "SKILL.md");
+  const canonicalDir = join18(resolveCorpusRoot(), normalized);
+  const canonicalSkillMd = join18(canonicalDir, "SKILL.md");
   const canonical = {
-    present: existsSync16(canonicalSkillMd),
+    present: existsSync17(canonicalSkillMd),
     path: canonicalDir,
-    ...existsSync16(canonicalSkillMd) ? { hash: hashSkillMarkdownFile(canonicalSkillMd) } : {},
-    ...existsSync16(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync13(canonicalSkillMd, "utf-8")) } : {}
+    ...existsSync17(canonicalSkillMd) ? { hash: hashSkillMarkdownFile(canonicalSkillMd) } : {},
+    ...existsSync17(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync13(canonicalSkillMd, "utf-8")) } : {}
   };
   const pinned = getInstalledSkills().includes(bare);
   const installMeta = getInstallMeta();
   const installedVersion = installMeta.skills[bare]?.version ?? "unknown";
-  const registryPkgPath = join16(sourcePath, "package.json");
+  const registryPkgPath = join18(sourcePath, "package.json");
   let registryVersion = "unknown";
-  if (existsSync16(registryPkgPath)) {
+  if (existsSync17(registryPkgPath)) {
     try {
       registryVersion = JSON.parse(readFileSync13(registryPkgPath, "utf-8")).version || "unknown";
     } catch {}
@@ -49275,13 +49389,13 @@ function handleDiff(name, options) {
   const upToDate = installedVersion === registryVersion;
   const homes = [];
   for (const agent of SYNC_AGENTS) {
-    const dir = join16(agentGlobalSkillsDir(agent), normalized);
-    const present = existsSync16(dir);
-    const managed = existsSync16(join16(dir, SYNC_MARKER_FILE));
-    const skillMdPath = join16(dir, "SKILL.md");
-    const hash = present && existsSync16(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : undefined;
+    const dir = join18(agentGlobalSkillsDir(agent), normalized);
+    const present = existsSync17(dir);
+    const managed = existsSync17(join18(dir, SYNC_MARKER_FILE));
+    const skillMdPath = join18(dir, "SKILL.md");
+    const hash = present && existsSync17(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : undefined;
     let stub;
-    if (present && existsSync16(skillMdPath)) {
+    if (present && existsSync17(skillMdPath)) {
       try {
         stub = isPointerSkillMd(readFileSync13(skillMdPath, "utf-8"));
       } catch {
@@ -49816,8 +49930,8 @@ var exports_init = {};
 __export(exports_init, {
   registerSetup: () => registerSetup
 });
-import { existsSync as existsSync17, readFileSync as readFileSync14, writeFileSync as writeFileSync8, appendFileSync } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync14, writeFileSync as writeFileSync8, appendFileSync } from "fs";
+import { join as join19 } from "path";
 function registerSetup(parent) {
   parent.command("init").option("--json", "Output as JSON", false).option("--for <agent>", "Detect project type and show MCP registration guidance for agent").option("--scope <scope>", "Deprecated; agent skill-folder installs are disabled", "global").description("Initialize project for pinned skills (.env.example, .gitignore)").action((options) => handleInit(options));
   parent.command("export").option("--json", "Output as JSON (default behavior)", false).description("Export pinned skills to JSON for sharing or backup").action((_options) => handleExport());
@@ -49901,7 +50015,7 @@ Use: skills render`));
       lines.push(`# Used by: ${skills.join(", ")}`);
       lines.push(`${envVar}=`);
     }
-    writeFileSync8(join17(cwd2, ".env.example"), lines.join(`
+    writeFileSync8(join19(cwd2, ".env.example"), lines.join(`
 `) + `
 `);
     envVarCount = envMap.size;
@@ -49909,9 +50023,9 @@ Use: skills render`));
       console.log(source_default.green(`\u2713 Generated .env.example (${envVarCount} variables from ${installed.length} skills)`));
   } else if (!options.json)
     console.log(source_default.dim("  No environment variables detected across pinned skills"));
-  const gitignorePath = join17(cwd2, ".gitignore");
+  const gitignorePath = join19(cwd2, ".gitignore");
   const gitignoreEntries = [".skills/runs/", ".skills/exports/", ".skills/tmp/"];
-  let gitignoreContent = existsSync17(gitignorePath) ? readFileSync14(gitignorePath, "utf-8") : "";
+  let gitignoreContent = existsSync18(gitignorePath) ? readFileSync14(gitignorePath, "utf-8") : "";
   let gitignoreUpdated = false;
   const missingEntries = gitignoreEntries.filter((entry) => !gitignoreContent.includes(entry));
   if (missingEntries.length > 0) {
@@ -49957,7 +50071,7 @@ async function handleImport(file, options) {
     if (file === "-")
       raw = await new Response(process.stdin).text();
     else {
-      if (!existsSync17(file)) {
+      if (!existsSync18(file)) {
         const error = `File not found: ${file}`;
         if (options.json)
           console.log(JSON.stringify({ imported: 0, error }));
@@ -50063,12 +50177,12 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync15, rmSync as rmSync5, statSync as statSync9, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join18 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync8, readdirSync as readdirSync9, readFileSync as readFileSync15, rmSync as rmSync5, statSync as statSync9, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join20 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
   const byName = new Map;
-  if (!existsSync18(corpusRoot))
+  if (!existsSync19(corpusRoot))
     return byName;
   let entries = [];
   try {
@@ -50079,8 +50193,8 @@ function indexCanonicalCorpus(corpusRoot) {
   for (const entry of entries.sort()) {
     if (entry.startsWith("."))
       continue;
-    const skillMd = join18(corpusRoot, entry, "SKILL.md");
-    if (!existsSync18(skillMd))
+    const skillMd = join20(corpusRoot, entry, "SKILL.md");
+    if (!existsSync19(skillMd))
       continue;
     try {
       byName.set(entry, hashSkillMarkdownFile(skillMd));
@@ -50089,14 +50203,14 @@ function indexCanonicalCorpus(corpusRoot) {
   return byName;
 }
 function scanUnmarkedHomes(options = {}) {
-  const homeDir = options.homeDir ?? homedir6();
+  const homeDir = options.homeDir ?? homedir8();
   const corpusRoot = resolveCorpusRoot(options);
   const index = indexCanonicalCorpus(corpusRoot);
   const agents = options.agents?.length ? options.agents : [...SYNC_AGENTS];
   const scan = { adoptable: [], conflicts: [], unknown: [], managed: 0 };
   for (const agent of agents) {
     const home = agentGlobalSkillsDir(agent, homeDir);
-    if (!existsSync18(home))
+    if (!existsSync19(home))
       continue;
     let entries = [];
     try {
@@ -50107,19 +50221,19 @@ function scanUnmarkedHomes(options = {}) {
     for (const skill of entries.sort()) {
       if (skill.startsWith("."))
         continue;
-      const dir = join18(home, skill);
+      const dir = join20(home, skill);
       try {
         if (!statSync9(dir).isDirectory())
           continue;
       } catch {
         continue;
       }
-      if (existsSync18(join18(dir, SYNC_MARKER_FILE))) {
+      if (existsSync19(join20(dir, SYNC_MARKER_FILE))) {
         scan.managed += 1;
         continue;
       }
-      const skillMdPath = join18(dir, "SKILL.md");
-      if (!existsSync18(skillMdPath))
+      const skillMdPath = join20(dir, "SKILL.md");
+      if (!existsSync19(skillMdPath))
         continue;
       const hash = hashSkillMarkdownFile(skillMdPath);
       const mtime = statSync9(skillMdPath).mtime.toISOString();
@@ -50139,9 +50253,9 @@ function scanUnmarkedHomes(options = {}) {
 function appendConflictsLedger(appDir, conflicts) {
   if (conflicts.length === 0)
     return;
-  const ledgerPath = join18(appDir, CONFLICTS_LEDGER_FILE);
+  const ledgerPath = join20(appDir, CONFLICTS_LEDGER_FILE);
   let ledger = { version: 1, entries: [] };
-  if (existsSync18(ledgerPath)) {
+  if (existsSync19(ledgerPath)) {
     try {
       const parsed = JSON.parse(readFileSync15(ledgerPath, "utf-8"));
       if (parsed && typeof parsed === "object" && Array.isArray(parsed.entries)) {
@@ -50159,9 +50273,9 @@ function appendConflictsLedger(appDir, conflicts) {
 `);
 }
 function writeRollbackRecord(mode, entries, appDir = getDataDir()) {
-  const dir = join18(appDir, ROLLBACK_DIRNAME);
+  const dir = join20(appDir, ROLLBACK_DIRNAME);
   mkdirSync8(dir, { recursive: true });
-  const file = join18(dir, `${mode}-${Date.now()}.json`);
+  const file = join20(dir, `${mode}-${Date.now()}.json`);
   const record = { version: 1, mode, timestamp: new Date().toISOString(), entries };
   writeFileSync9(file, `${JSON.stringify(record, null, 2)}
 `);
@@ -50172,7 +50286,7 @@ function adoptUnmarkedHomes(options = {}) {
   if (!options.apply) {
     return { ...scan, applied: false };
   }
-  const appDir = options.homeDir ? join18(options.homeDir, ".hasna", "skills") : getDataDir();
+  const appDir = options.homeDir ? join20(options.homeDir, ".hasna", "skills") : getDataDir();
   const markers = scan.adoptable.map((entry) => {
     const marker = {
       managedBy: SYNC_MARKER_MANAGED_BY,
@@ -50180,7 +50294,7 @@ function adoptUnmarkedHomes(options = {}) {
       source: "adopted",
       syncedAt: new Date().toISOString()
     };
-    writeFileSync9(join18(entry.path, SYNC_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+    writeFileSync9(join20(entry.path, SYNC_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
     return { agent: entry.agent, skill: entry.skill, path: entry.path, hash: entry.hash, marker };
   });
@@ -50192,14 +50306,14 @@ function adoptUnmarkedHomes(options = {}) {
   return { ...scan, applied: true, rollbackFile };
 }
 function pruneStrayHomes(options = {}) {
-  const homeDir = options.homeDir ?? homedir6();
+  const homeDir = options.homeDir ?? homedir8();
   const corpusRoot = resolveCorpusRoot(options);
   const index = indexCanonicalCorpus(corpusRoot);
   const agents = options.agents?.length ? options.agents : [...SYNC_AGENTS];
   const candidates = [];
   for (const agent of agents) {
     const home = agentGlobalSkillsDir(agent, homeDir);
-    if (!existsSync18(home))
+    if (!existsSync19(home))
       continue;
     let entries = [];
     try {
@@ -50210,15 +50324,15 @@ function pruneStrayHomes(options = {}) {
     for (const skill of entries.sort()) {
       if (skill.startsWith("."))
         continue;
-      const dir = join18(home, skill);
+      const dir = join20(home, skill);
       try {
         if (!statSync9(dir).isDirectory())
           continue;
       } catch {
         continue;
       }
-      const markerPath = join18(dir, SYNC_MARKER_FILE);
-      if (!existsSync18(markerPath))
+      const markerPath = join20(dir, SYNC_MARKER_FILE);
+      if (!existsSync19(markerPath))
         continue;
       if (index.has(skill))
         continue;
@@ -50231,15 +50345,15 @@ function pruneStrayHomes(options = {}) {
       } catch {
         continue;
       }
-      const skillMdPath = join18(dir, "SKILL.md");
-      const hash = existsSync18(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : "";
+      const skillMdPath = join20(dir, "SKILL.md");
+      const hash = existsSync19(skillMdPath) ? hashSkillMarkdownFile(skillMdPath) : "";
       candidates.push({ agent, skill, home, path: dir, hash, marker });
     }
   }
   if (!options.apply) {
     return { candidates, pruned: 0, dryRun: true };
   }
-  const appDir = options.homeDir ? join18(options.homeDir, ".hasna", "skills") : getDataDir();
+  const appDir = options.homeDir ? join20(options.homeDir, ".hasna", "skills") : getDataDir();
   const rollbackFile = writeRollbackRecord("prune", candidates.map(({ agent, skill, path, hash, marker }) => ({ agent, skill, path, hash, marker })), appDir);
   for (const candidate of candidates) {
     rmSync5(candidate.path, { recursive: true, force: true });
@@ -50255,9 +50369,9 @@ var init_home_adoption = __esm(() => {
 });
 
 // src/lib/home-census.ts
-import { existsSync as existsSync19, readFileSync as readFileSync16, readdirSync as readdirSync10, statSync as statSync10 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join19 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync16, readdirSync as readdirSync10, statSync as statSync10 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join21 } from "path";
 function sortEntries(entries) {
   return entries.sort((a, b) => {
     const left = `${a.agent}/${a.skill}/${a.kind}`;
@@ -50266,7 +50380,7 @@ function sortEntries(entries) {
   });
 }
 function censusHomeDrift(options = {}) {
-  const homeDir = options.homeDir ?? homedir7();
+  const homeDir = options.homeDir ?? homedir9();
   const corpusRoot = resolveCorpusRoot(options);
   const index = indexCanonicalCorpus(corpusRoot);
   const agents = options.agents?.length ? options.agents : [...SYNC_AGENTS];
@@ -50276,7 +50390,7 @@ function censusHomeDrift(options = {}) {
   let homesChecked = 0;
   for (const agent of agents) {
     const home = agentGlobalSkillsDir(agent, homeDir);
-    if (!existsSync19(home))
+    if (!existsSync20(home))
       continue;
     homesChecked += 1;
     const present = new Set;
@@ -50289,7 +50403,7 @@ function censusHomeDrift(options = {}) {
     for (const skill of dirEntries.sort()) {
       if (skill.startsWith("."))
         continue;
-      const dir = join19(home, skill);
+      const dir = join21(home, skill);
       try {
         if (!statSync10(dir).isDirectory())
           continue;
@@ -50297,8 +50411,8 @@ function censusHomeDrift(options = {}) {
         continue;
       }
       present.add(skill);
-      const markerPath = join19(dir, SYNC_MARKER_FILE);
-      if (!existsSync19(markerPath)) {
+      const markerPath = join21(dir, SYNC_MARKER_FILE);
+      if (!existsSync20(markerPath)) {
         unmarked += 1;
         continue;
       }
@@ -50308,8 +50422,8 @@ function censusHomeDrift(options = {}) {
         entries.push({ agent, skill, kind: "stray-in-home", path: dir });
         continue;
       }
-      const skillMdPath = join19(dir, "SKILL.md");
-      if (!existsSync19(skillMdPath)) {
+      const skillMdPath = join21(dir, "SKILL.md");
+      if (!existsSync20(skillMdPath)) {
         entries.push({ agent, skill, kind: "diverged", path: dir, canonicalHash });
         continue;
       }
@@ -50322,7 +50436,7 @@ function censusHomeDrift(options = {}) {
           homeStub = undefined;
         }
         let canonicalStub;
-        const canonicalSkillMd = join19(corpusRoot, skill, "SKILL.md");
+        const canonicalSkillMd = join21(corpusRoot, skill, "SKILL.md");
         try {
           canonicalStub = isPointerSkillMd(readFileSync16(canonicalSkillMd, "utf-8"));
         } catch {
@@ -50337,7 +50451,7 @@ function censusHomeDrift(options = {}) {
           agent,
           skill: name,
           kind: "missing-from-home",
-          path: join19(home, name),
+          path: join21(home, name),
           canonicalHash
         });
       }
@@ -50363,8 +50477,8 @@ var exports_diagnostic = {};
 __export(exports_diagnostic, {
   registerDiagnostic: () => registerDiagnostic
 });
-import { existsSync as existsSync20, readFileSync as readFileSync17, readdirSync as readdirSync11, statSync as statSync11, writeFileSync as writeFileSync10 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync17, readdirSync as readdirSync11, statSync as statSync11, writeFileSync as writeFileSync10 } from "fs";
+import { join as join22 } from "path";
 import { execSync as execSync2 } from "child_process";
 function registerDiagnostic(parent) {
   parent.command("doctor").option("--json", "Output as JSON", false).description("Check env vars, system deps, and readiness for pinned skills").action((options) => handleDoctor(options));
@@ -50480,7 +50594,7 @@ Skills Test (${results.length} skill${results.length === 1 ? "" : "s"}):
 }
 function handleAuth(name, options) {
   const cwd2 = process.cwd();
-  const envFilePath = join20(cwd2, ".env");
+  const envFilePath = join22(cwd2, ".env");
   if (options.set) {
     const eqIdx = options.set.indexOf("=");
     if (eqIdx === -1) {
@@ -50502,7 +50616,7 @@ function handleAuth(name, options) {
       process.exitCode = 1;
       return;
     }
-    let existing = existsSync20(envFilePath) ? readFileSync17(envFilePath, "utf-8") : "";
+    let existing = existsSync21(envFilePath) ? readFileSync17(envFilePath, "utf-8") : "";
     const keyPattern = new RegExp(`^${key}=.*$`, "m");
     const updated = keyPattern.test(existing) ? existing.replace(keyPattern, `${key}=${value}`) : existing.endsWith(`
 `) || existing === "" ? existing + `${key}=${value}
@@ -50568,11 +50682,11 @@ function handleWhoami(options) {
   const agentConfigs = [];
   for (const agent of AGENT_TARGETS) {
     const agentSkillsPath = getAgentSkillsDir(agent, "global");
-    const exists = existsSync20(agentSkillsPath);
+    const exists = existsSync21(agentSkillsPath);
     let skillCount = 0;
     if (exists)
       try {
-        skillCount = readdirSync11(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync11(join20(agentSkillsPath, f)).isDirectory()).length;
+        skillCount = readdirSync11(agentSkillsPath).filter((f) => !f.startsWith(".") && statSync11(join22(agentSkillsPath, f)).isDirectory()).length;
       } catch {}
     agentConfigs.push({ agent, label: AGENT_LABELS[agent], path: agentSkillsPath, exists, skillCount });
   }
@@ -50606,9 +50720,9 @@ function handleOutdated(options) {
   for (const name of installed) {
     const installedVersion = meta.skills[name]?.version ?? "unknown";
     const registryPath = getSkillPath(name);
-    const registryPkgPath = join20(registryPath, "package.json");
+    const registryPkgPath = join22(registryPath, "package.json");
     let registryVersion = "unknown";
-    if (existsSync20(registryPkgPath))
+    if (existsSync21(registryPkgPath))
       try {
         registryVersion = JSON.parse(readFileSync17(registryPkgPath, "utf-8")).version || "unknown";
       } catch {}
@@ -50874,20 +50988,20 @@ var init_runs = __esm(() => {
 
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync18, readdirSync as readdirSync12, statSync as statSync12, writeFileSync as writeFileSync11 } from "fs";
-import { extname, join as join21, relative as relative2 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync9, readFileSync as readFileSync18, readdirSync as readdirSync12, statSync as statSync12, writeFileSync as writeFileSync11 } from "fs";
+import { extname, join as join23, relative as relative2 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now3 = new Date;
   const id = createRunId(now3);
   const day = now3.toISOString().slice(0, 10);
   const skillName = normalizeSkillName(params.skill);
   const root = getProjectStateDir(targetDir);
-  const runDir = join21(root, "runs", day, id);
-  const logsDir = join21(runDir, "logs");
-  const exportDir = join21(root, "exports", skillName, id);
+  const runDir = join23(root, "runs", day, id);
+  const logsDir = join23(runDir, "logs");
+  const exportDir = join23(root, "exports", skillName, id);
   mkdirSync9(logsDir, { recursive: true });
   mkdirSync9(exportDir, { recursive: true });
-  mkdirSync9(join21(root, "tmp"), { recursive: true });
+  mkdirSync9(join23(root, "tmp"), { recursive: true });
   const record = {
     id,
     skill: skillName,
@@ -50938,27 +51052,27 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync11(join21(context.logsDir, "stdout.log"), stdout);
-  writeFileSync11(join21(context.logsDir, "stderr.log"), stderr);
+  writeFileSync11(join23(context.logsDir, "stdout.log"), stdout);
+  writeFileSync11(join23(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join21(context.runDir, "events.ndjson");
-  const previous = existsSync21(path) ? readFileSync18(path, "utf-8") : "";
+  const path = join23(context.runDir, "events.ndjson");
+  const previous = existsSync22(path) ? readFileSync18(path, "utf-8") : "";
   writeFileSync11(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
-  const runsRoot = join21(getProjectStateDir(targetDir), "runs");
-  if (!existsSync21(runsRoot))
+  const runsRoot = join23(getProjectStateDir(targetDir), "runs");
+  if (!existsSync22(runsRoot))
     return [];
   const records = [];
   for (const day of readdirSync12(runsRoot).sort().reverse()) {
-    const dayDir = join21(runsRoot, day);
+    const dayDir = join23(runsRoot, day);
     if (!statSync12(dayDir).isDirectory())
       continue;
     for (const runId of readdirSync12(dayDir).sort().reverse()) {
-      const record = readRunRecord(join21(dayDir, runId));
+      const record = readRunRecord(join23(dayDir, runId));
       if (record)
         records.push(record);
       if (records.length >= limit)
@@ -50968,11 +51082,11 @@ function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   return records;
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join21(getProjectStateDir(targetDir), "runs");
-  if (!existsSync21(runsRoot))
+  const runsRoot = join23(getProjectStateDir(targetDir), "runs");
+  if (!existsSync22(runsRoot))
     return null;
   for (const day of readdirSync12(runsRoot)) {
-    const record = readRunRecord(join21(runsRoot, day, runId));
+    const record = readRunRecord(join23(runsRoot, day, runId));
     if (record)
       return record;
   }
@@ -50989,18 +51103,18 @@ function skillRunEnv(context) {
   };
 }
 function getRunExportDir(runId, skill, targetDir = process.cwd()) {
-  return join21(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
+  return join23(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
 }
 function writeRunRecord(context) {
-  writeFileSync11(join21(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync11(join23(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync11(join21(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync11(join23(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
-  if (!existsSync21(context.exportDir))
+  if (!existsSync22(context.exportDir))
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
@@ -51016,8 +51130,8 @@ function collectRunArtifacts(context) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join21(runDir, "run.json");
-  if (!existsSync21(path))
+  const path = join23(runDir, "run.json");
+  if (!existsSync22(path))
     return null;
   try {
     return JSON.parse(readFileSync18(path, "utf-8"));
@@ -51028,7 +51142,7 @@ function readRunRecord(runDir) {
 function walkFiles(dir) {
   const files = [];
   for (const entry of readdirSync12(dir)) {
-    const full = join21(dir, entry);
+    const full = join23(dir, entry);
     if (statSync12(full).isDirectory())
       files.push(...walkFiles(full));
     else
@@ -56598,12 +56712,12 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -58778,7 +58892,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -58790,7 +58904,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject2) => {
+    return new Promise((resolve2, reject2) => {
       const earlyReject = (error2) => {
         reject2(error2);
       };
@@ -58868,7 +58982,7 @@ class Protocol {
           if (!parseResult.success) {
             reject2(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject2(error2);
@@ -59059,12 +59173,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve, reject2) => {
+    return new Promise((resolve2, reject2) => {
       if (signal.aborted) {
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -62049,7 +62163,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve.call(this, root, ref);
+    let _sch = resolve2.call(this, root, ref);
     if (_sch === undefined) {
       const schema = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -62076,7 +62190,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve(root, ref) {
+  function resolve2(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -62368,8 +62482,8 @@ var require_utils = __commonJS((exports, module) => {
   var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
   var HOST_DELIM_RE = /[@/?#:]/g;
   var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
-  function reescapeHostDelimiters(host, isIP2) {
-    const re = isIP2 ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+  function reescapeHostDelimiters(host, isIP) {
+    const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
     re.lastIndex = 0;
     return host.replace(re, (ch) => HOST_DELIMS[ch]);
   }
@@ -62662,7 +62776,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve(baseURI, relativeURI, options) {
+  function resolve2(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
     const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
@@ -62818,7 +62932,7 @@ var require_fast_uri = __commonJS((exports, module) => {
       fragment: undefined
     };
     let malformedAuthorityOrPort = false;
-    let isIP2 = false;
+    let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
         uri = options.scheme + ":" + uri;
@@ -62867,9 +62981,9 @@ var require_fast_uri = __commonJS((exports, module) => {
         if (ipv4result === false) {
           const ipv6result = normalizeIPv6(parsed.host);
           parsed.host = ipv6result.host.toLowerCase();
-          isIP2 = ipv6result.isIPV6;
+          isIP = ipv6result.isIPV6;
         } else {
-          isIP2 = true;
+          isIP = true;
         }
       }
       if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) {
@@ -62886,7 +63000,7 @@ var require_fast_uri = __commonJS((exports, module) => {
       }
       const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
       if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP2 === false && nonSimpleDomain(parsed.host)) {
+        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
           try {
             parsed.host = new URL("http://" + parsed.host).hostname;
           } catch (e) {
@@ -62900,7 +63014,7 @@ var require_fast_uri = __commonJS((exports, module) => {
             parsed.scheme = unescape(parsed.scheme);
           }
           if (parsed.host !== undefined) {
-            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP2);
+            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
           }
         }
         if (parsed.path) {
@@ -62947,7 +63061,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize: normalize3,
-    resolve,
+    resolve: resolve2,
     resolveComponent,
     equal,
     serialize,
@@ -66733,7 +66847,7 @@ class McpServer {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5000;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -68679,8 +68793,8 @@ var init_remote_client = __esm(() => {
 });
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync22, readdirSync as readdirSync13, statSync as statSync13 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync13, statSync as statSync13 } from "fs";
+import { join as join24 } from "path";
 function registerOperationTools(server) {
   server.registerTool("scaffold_skill", {
     title: "Scaffold Skill",
@@ -69077,12 +69191,12 @@ function registerOperationTools(server) {
     const agents = [];
     for (const agent of AGENT_TARGETS) {
       const agentSkillsPath = getAgentSkillsDir(agent, "global");
-      const exists = existsSync22(agentSkillsPath);
+      const exists = existsSync23(agentSkillsPath);
       let skillCount = 0;
       if (exists) {
         try {
           skillCount = readdirSync13(agentSkillsPath).filter((f) => {
-            const full = join22(agentSkillsPath, f);
+            const full = join24(agentSkillsPath, f);
             return !f.startsWith(".") && statSync13(full).isDirectory();
           }).length;
         } catch {}
@@ -69139,16 +69253,16 @@ var init_operation_tools = __esm(() => {
 });
 
 // src/lib/feedback.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname7, join as join23 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname7, join as join25 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join23(getDataDir(), "skills.db");
+  return join25(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
   const dir = dirname7(dbPath);
-  if (!existsSync23(dir))
+  if (!existsSync24(dir))
     mkdirSync10(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
@@ -69322,14 +69436,14 @@ var init_resource_meta_tools = __esm(() => {
 });
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync24, readFileSync as readFileSync19, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync19, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
+import { join as join26 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join24(targetDir, ".skills", "schedules.json");
+  return join26(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  if (existsSync24(path)) {
+  if (existsSync25(path)) {
     try {
       return JSON.parse(readFileSync19(path, "utf-8"));
     } catch {}
@@ -69338,8 +69452,8 @@ function loadSchedules(targetDir = process.cwd()) {
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join24(targetDir, ".skills");
-  if (!existsSync24(dir))
+  const dir = join26(targetDir, ".skills");
+  if (!existsSync25(dir))
     mkdirSync11(dir, { recursive: true });
   writeFileSync12(path, JSON.stringify(data, null, 2));
 }
@@ -69639,14 +69753,14 @@ var init_schedule_tools = __esm(() => {
 // src/lib/native-storage.ts
 import { createHash as createHash3, createHmac as createHmac2 } from "crypto";
 import {
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync20,
   readdirSync as readdirSync14,
   statSync as statSync14,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname8, join as join25, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
+import { dirname as dirname8, join as join27, normalize as normalize3, relative as relative3, sep as sep2 } from "path";
 function resolveSkillsNativeStorageConfig(env3 = process.env) {
   assertNoRetiredModeEnvVars(env3, {
     app: SKILLS_ENV_NAMESPACE,
@@ -69687,7 +69801,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join25(getDataDir(), "skills.db")
+      feedbackDbPath: join27(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config2.databaseUrl),
@@ -69707,7 +69821,7 @@ function getStorageStatus(options = {}) {
 function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const projectStateDir = getProjectStateDir(targetDir);
   const files = [];
-  if (existsSync25(projectStateDir)) {
+  if (existsSync26(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
       const bytes = readFileSync20(filePath);
       const relativePath = toPosix(relative3(targetDir, filePath));
@@ -69768,7 +69882,7 @@ function parsePositiveInteger(value) {
 function walkFiles2(dir) {
   const files = [];
   for (const entry of readdirSync14(dir)) {
-    const full = join25(dir, entry);
+    const full = join27(dir, entry);
     const stats = statSync14(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
@@ -69976,7 +70090,7 @@ var GlobalRequest, Request, newHeadersFromIncoming = (incoming) => {
   }
   return new Request(url, init);
 }, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, outgoingEnded, incomingDraining, MAX_DRAIN_BYTES;
-var init_dist = __esm(() => {
+var init_dist2 = __esm(() => {
   GlobalRequest = global.Request;
   Request = class extends GlobalRequest {
     constructor(input, options) {
@@ -70266,7 +70380,7 @@ var init_webStandardStreamableHttp = __esm(() => {
 
 // ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
 var init_streamableHttp = __esm(() => {
-  init_dist();
+  init_dist2();
   init_webStandardStreamableHttp();
 });
 
@@ -70317,9 +70431,9 @@ var init_mcp2 = __esm(() => {
 });
 
 // src/cli/commands/runtime-mcp.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname9, join as join26 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname9, join as join28 } from "path";
 async function handleMcp(options) {
   if (options.register) {
     let agents;
@@ -70362,24 +70476,24 @@ async function registerMcpForAgent(agent, command) {
     case "codex":
       return registerCodexMcp(command);
     case "gemini":
-      return registerJsonMcpServer(agent, join26(homedir8(), ".gemini", "settings.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join28(homedir10(), ".gemini", "settings.json"), "mcpServers", {
         command,
         args: []
       });
     case "pi":
-      return registerJsonMcpServer(agent, join26(homedir8(), ".pi", "agent", "mcp.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join28(homedir10(), ".pi", "agent", "mcp.json"), "mcpServers", {
         command,
         args: []
       });
     case "opencode":
       return registerOpenCodeMcp(command);
     case "cursor":
-      return registerJsonMcpServer(agent, join26(homedir8(), ".cursor", "mcp.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join28(homedir10(), ".cursor", "mcp.json"), "mcpServers", {
         command,
         args: []
       });
     case "windsurf":
-      return registerJsonMcpServer(agent, join26(homedir8(), ".windsurf", "mcp.json"), "mcpServers", {
+      return registerJsonMcpServer(agent, join28(homedir10(), ".windsurf", "mcp.json"), "mcpServers", {
         command,
         args: []
       });
@@ -70402,7 +70516,7 @@ async function registerClaudeMcp(command) {
     if (exitCode === 0) {
       return { agent: "claude", success: true, command: cliCommand };
     }
-    const fallback = registerJsonMcpServer("claude", join26(homedir8(), ".claude", ".mcp.json"), "mcpServers", {
+    const fallback = registerJsonMcpServer("claude", join28(homedir10(), ".claude", ".mcp.json"), "mcpServers", {
       command,
       args: []
     });
@@ -70412,7 +70526,7 @@ async function registerClaudeMcp(command) {
       error: fallback.success ? undefined : `claude exited with ${exitCode}: ${(stderr || stdout).trim()}`
     };
   } catch (err) {
-    const fallback = registerJsonMcpServer("claude", join26(homedir8(), ".claude", ".mcp.json"), "mcpServers", {
+    const fallback = registerJsonMcpServer("claude", join28(homedir10(), ".claude", ".mcp.json"), "mcpServers", {
       command,
       args: []
     });
@@ -70424,11 +70538,11 @@ async function registerClaudeMcp(command) {
   }
 }
 function registerCodexMcp(command) {
-  const path = join26(homedir8(), ".codex", "config.toml");
+  const path = join28(homedir10(), ".codex", "config.toml");
   const config2 = `[mcp_servers.${MCP_SERVER_NAME}]
 command = ${JSON.stringify(command)}`;
   try {
-    const current = existsSync26(path) ? readFileSync21(path, "utf-8") : "";
+    const current = existsSync27(path) ? readFileSync21(path, "utf-8") : "";
     writeTextFile(path, upsertTomlSection(current, `[mcp_servers.${MCP_SERVER_NAME}]`, `command = ${JSON.stringify(command)}`));
     return { agent: "codex", success: true, path, config: config2 };
   } catch (err) {
@@ -70436,7 +70550,7 @@ command = ${JSON.stringify(command)}`;
   }
 }
 function registerOpenCodeMcp(command) {
-  const path = join26(homedir8(), ".config", "opencode", "opencode.json");
+  const path = join28(homedir10(), ".config", "opencode", "opencode.json");
   const config2 = JSON.stringify({
     $schema: "https://opencode.ai/config.json",
     mcp: {
@@ -70478,7 +70592,7 @@ function registerJsonMcpServer(agent, path, containerKey, server2) {
   }
 }
 function readJsonObject2(path) {
-  if (!existsSync26(path))
+  if (!existsSync27(path))
     return {};
   const raw = readFileSync21(path, "utf-8").trim();
   if (!raw)
@@ -70524,8 +70638,8 @@ function findCommandOnPath(command) {
   for (const dir of pathValue.split(":")) {
     if (!dir)
       continue;
-    const candidate = join26(dir, command);
-    if (existsSync26(candidate))
+    const candidate = join28(dir, command);
+    if (existsSync27(candidate))
       return candidate;
   }
   return command;
@@ -70545,7 +70659,7 @@ __export(exports_runtime, {
   registerRuntime: () => registerRuntime
 });
 import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname10, join as join27 } from "path";
+import { dirname as dirname10, join as join29 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
   parent.command("run").argument("<skill>", "Skill name").argument("[args...]", "Arguments to pass to the skill").allowUnknownOption(true).passThroughOptions(true).option("--json", "Output result as JSON", false).option("--wait", "Poll remote runs until a terminal status", false).option("--poll-interval-ms <ms>", "Remote polling interval in milliseconds", "1000").option("--poll-timeout-ms <ms>", "Maximum time to wait for a remote run", "300000").description("Run a skill directly").action(async (name, args2, options) => handleRun(name, args2, options));
@@ -70670,10 +70784,10 @@ async function handleSetup(options) {
 }
 function promptLine(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(source_default.bold(question), (answer) => {
       rl.close();
-      resolve(answer.trim());
+      resolve2(answer.trim());
     });
   });
 }
@@ -71034,7 +71148,7 @@ async function handleExportsDownload(runId, options) {
       if (!response.ok)
         throw new Error(`download failed for artifact ${artifactId}: ${response.status}`);
       const relativePath = safeArtifactRelativePath(typeof artifact.relativePath === "string" ? artifact.relativePath : artifact.fileName, String(artifact.fileName || artifactId));
-      const outputPath = join27(exportDir, relativePath);
+      const outputPath = join29(exportDir, relativePath);
       mkdirSync14(dirname10(outputPath), { recursive: true });
       const bytes = new Uint8Array(await response.arrayBuffer());
       writeFileSync15(outputPath, bytes);
@@ -71094,7 +71208,7 @@ async function pollRemoteRun(client, runId, options) {
     const remaining = deadline - Date.now();
     if (remaining <= 0)
       break;
-    await new Promise((resolve) => setTimeout(resolve, Math.min(options.intervalMs, remaining)));
+    await new Promise((resolve2) => setTimeout(resolve2, Math.min(options.intervalMs, remaining)));
   }
   return {
     run: current ?? { id: runId, status: "queued" },
@@ -71395,13 +71509,345 @@ var init_completion = __esm(() => {
   categoryNames = CATEGORIES.map((c) => c);
 });
 
+// src/lib/portable-snapshot-filter.ts
+import { readdirSync as readdirSync15, statSync as statSync15 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join30, sep as sep3 } from "path";
+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 ?? homedir11();
+  if (definition.subClass === "skills" || definition.subClass === "custom") {
+    return join30(skillsDataRootForHome(home), definition.name);
+  }
+  if (definition.agent === "opencode") {
+    return join30(home, ".config", "opencode", "skills");
+  }
+  return join30(home, `.${definition.agent}`, "skills");
+}
+function destinationFor(definition, stationId, relativePath) {
+  const category = definition.subClass === "agent-homes" ? join30("agent-homes", definition.agent ?? "") : definition.name;
+  return join30("resources", stationId, "skills", category, ...relativePath.split(sep3));
+}
+function walkEntries(absoluteRoot) {
+  let entries;
+  try {
+    entries = readdirSync15(absoluteRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const output = [];
+  for (const entry of entries) {
+    const childFull = join30(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: join30(entry.name, item.relativePath) });
+      }
+      continue;
+    }
+    if (entry.isFile()) {
+      output.push({ kind: "file", relativePath: entry.name, fullPath: childFull });
+    }
+  }
+  return output;
+}
+function isRegularFile(filePath) {
+  try {
+    return statSync15(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+var SYNC_HOMES, EXCLUDE_DIR_NAMES, EXCLUDE_DIR_PATTERNS, EXCLUDE_FILE_NAMES, EXCLUDE_FILE_PATTERNS, PORTABLE_TOP_LEVEL, PORTABLE_SUBDIRS, REFUSED_SCANNER_FLAGGED;
+var init_portable_snapshot_filter = __esm(() => {
+  init_app_home();
+  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" }
+  ];
+  EXCLUDE_DIR_NAMES = new Set([
+    ".git",
+    "node_modules",
+    "__pycache__",
+    ".cache",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache"
+  ]);
+  EXCLUDE_DIR_PATTERNS = [
+    /^\.merge-pr\.rollback-/
+  ];
+  EXCLUDE_FILE_NAMES = new Set([
+    ".DS_Store",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "Cargo.lock"
+  ]);
+  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/
+  ];
+  PORTABLE_TOP_LEVEL = new Set(["SKILL.md", "skill.json"]);
+  PORTABLE_SUBDIRS = new Set(["scripts", "assets", "references"]);
+  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"
+  ]);
+});
+
+// src/lib/station-snapshot.ts
+import { createHash as createHash4 } from "crypto";
+import {
+  copyFileSync as copyFileSync2,
+  mkdirSync as mkdirSync15,
+  readFileSync as readFileSync22,
+  statSync as statSync16,
+  writeFileSync as writeFileSync16
+} from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3, relative as relative4, resolve as resolve2, sep as sep4 } from "path";
+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 createHash4("sha256").update(readFileSync22(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 = statSync16(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((sum2, item) => sum2 + 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((sum2, plan) => sum2 + 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 base2 = {
+    stationId: options.stationId,
+    mode: "dry-run",
+    repoRoot,
+    stats: { files: plans.length, bytes: totalBytes },
+    homes: humanHomes(scanned),
+    files: manifestFiles
+  };
+  if (options.dryRun !== false) {
+    return base2;
+  }
+  const conflicts = [];
+  const untouched = [];
+  for (const plan of plans) {
+    const destination = resolve2(repoRoot, plan.destination);
+    const destinationRelative = relative4(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);
+    mkdirSync15(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");
+  mkdirSync15(dirname11(manifestPath), { recursive: true });
+  writeFileSync16(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  return {
+    ...base2,
+    mode: "populate",
+    stats: { files: plans.length, bytes: totalBytes, written, unchanged },
+    manifestPath
+  };
+}
+var STATION_SYNC_MANIFEST_SCHEMA = "hasna.fleet-resources.skills-sync-manifest/v1", STATION_SNAPSHOT_PRODUCER, StationSnapshotError;
+var init_station_snapshot = __esm(() => {
+  init_package();
+  init_portable_snapshot_filter();
+  STATION_SNAPSHOT_PRODUCER = { name: "@hasna/skills", version: package_default.version };
+  StationSnapshotError = class StationSnapshotError extends Error {
+    code;
+    detail;
+    constructor(code, message, detail = []) {
+      super(message);
+      this.name = "StationSnapshotError";
+      this.code = code;
+      this.detail = detail;
+    }
+  };
+});
+
 // src/cli/commands/create-sync-config.ts
 var exports_create_sync_config = {};
 __export(exports_create_sync_config, {
   registerCreateSync: () => registerCreateSync
 });
-import { existsSync as existsSync27, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync28, writeFileSync as writeFileSync17, mkdirSync as mkdirSync16 } from "fs";
+import { join as join31 } from "path";
 function registerCreateSync(parent) {
   const configCmd = parent.command("config").description("Manage skills configuration");
   configCmd.command("show", { isDefault: true }).option("--json", "Output as JSON", false).description("Show current merged configuration").action((options) => {
@@ -71467,23 +71913,23 @@ function registerCreateSync(parent) {
     const pp = getConfigPath("project");
     if (options.json) {
       console.log(JSON.stringify({
-        global: { path: gp, exists: existsSync27(gp) },
-        project: { path: pp, exists: existsSync27(pp) }
+        global: { path: gp, exists: existsSync28(gp) },
+        project: { path: pp, exists: existsSync28(pp) }
       }, null, 2));
       return;
     }
-    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync27(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
-    console.log(`${source_default.cyan("project")}: ${pp}${existsSync27(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync28(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("project")}: ${pp}${existsSync28(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
   });
   parent.command("create").argument("<name>", "Skill name (e.g. my-tool)").option("--category <category>", "Skill category", "Development Tools").option("--description <description>", "Short description of what the skill does").option("--tags <tags>", "Comma-separated tags (e.g. api,testing,automation)").option("--global", "Deprecated; custom skills are always global", false).option("--json", "Output result as JSON", false).description("Scaffold a new custom skill directory").action((name, options) => handleCreate(name, options));
-  parent.command("sync").alias("render").argument("[names...]", "Skills to sync (default: every skill in this machine's corpus)").option("--for <agent>", `Target one agent (${SYNC_AGENTS.join(", ")}, or all)`, "all").option("--all", "Sync every corpus skill (the default)", false).option("--source <path>", "Canonical corpus source: a directory of skill folders, or a package root with skills/ (overrides $SKILLS_SOURCE)").option("--dry-run", "Show what would be written without touching any agent folder", false).option("--force", "Adopt an unmanaged skill that already has SKILL.md; other unmarked directories are never overwritten", false).option("--check", "Home drift census (missing-from-home / stray-in-home / diverged); exits non-zero on drift, writes nothing", false).option("--adopt", "Unmarked-home adoption mode: hash unmarked home skills against the corpus; exact matches are marked (dry-run by default)", false).option("--prune", "Prune mode: list (or with --apply, remove) marked home skill dirs that have no canonical corpus entry", false).option("--apply", "Write adoption markers / conflicts ledger, or perform prune removals", false).option("--json", "Output as JSON", false).description("Write corpus skills into each coding agent's global skills folder, per-tool adapted").action((names, options) => handleSync(names, options));
+  parent.command("sync").alias("render").argument("[names...]", "Skills to sync (default: every skill in this machine's corpus)").option("--for <agent>", `Target one agent (${SYNC_AGENTS.join(", ")}, or all)`, "all").option("--all", "Sync every corpus skill (the default)", false).option("--source <path>", "Canonical corpus source: a directory of skill folders, or a package root with skills/ (overrides $SKILLS_SOURCE)").option("--dry-run", "Show what would be written without touching any agent folder", false).option("--force", "Adopt an unmanaged skill that already has SKILL.md; other unmarked directories are never overwritten", false).option("--check", "Home drift census (missing-from-home / stray-in-home / diverged); exits non-zero on drift, writes nothing", false).option("--adopt", "Unmarked-home adoption mode: hash unmarked home skills against the corpus; exact matches are marked (dry-run by default)", false).option("--prune", "Prune mode: list (or with --apply, remove) marked home skill dirs that have no canonical corpus entry", false).option("--apply", "Write adoption markers / conflicts ledger, or perform prune removals", false).option("--json", "Output as JSON", false).option("--station <id>", "Per-station snapshot mode: snapshot the installed skill homes into resources/<station>/skills with a v3 sync-manifest (dry-run by default; --populate writes)").option("--populate", "Write the per-station snapshot (station mode; the default is dry-run)", false).option("--repo-root <path>", "Station snapshot destination repo root (default: cwd)").option("--homes-root <dir>", "Build the station snapshot from a staged mirror of the skill homes instead of this machine's $HOME").description("Write corpus skills into each coding agent's global skills folder, per-tool adapted; with --station, snapshot the homes into a reviewed snapshot repo instead").action((names, options) => handleSync(names, options));
 }
 function handleCreate(name, options) {
   const bare = name.trim();
   const dirName = bare;
-  const baseDir = getPortableSkillsRoot();
-  const skillDir = join28(baseDir, dirName);
-  if (existsSync27(skillDir)) {
+  const baseDir2 = getPortableSkillsRoot();
+  const skillDir = join31(baseDir2, dirName);
+  if (existsSync28(skillDir)) {
     console.log(options.json ? JSON.stringify({ error: `Skill '${bare}' already exists at ${skillDir}` }) : source_default.red(`Skill '${bare}' already exists at ${skillDir}`));
     process.exitCode = 1;
     return;
@@ -71491,8 +71937,8 @@ function handleCreate(name, options) {
   const description = options.description || `${bare} skill`;
   const tags = options.tags ? options.tags.split(",").map((t) => t.trim()).filter(Boolean) : [bare];
   const displayName2 = bare.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-  mkdirSync15(join28(skillDir, "src"), { recursive: true });
-  writeFileSync16(join28(skillDir, "SKILL.md"), [
+  mkdirSync16(join31(skillDir, "src"), { recursive: true });
+  writeFileSync17(join31(skillDir, "SKILL.md"), [
     "---",
     `name: ${bare}`,
     `description: ${description}`,
@@ -71512,11 +71958,11 @@ function handleCreate(name, options) {
     ""
   ].join(`
 `));
-  writeFileSync16(join28(skillDir, "src", "index.ts"), [`#!/usr/bin/env bun`, `/**`, ` * ${displayName2} \u2014 ${description}`, ` */`, "", `console.log("${displayName2}");`, ""].join(`
+  writeFileSync17(join31(skillDir, "src", "index.ts"), [`#!/usr/bin/env bun`, `/**`, ` * ${displayName2} \u2014 ${description}`, ` */`, "", `console.log("${displayName2}");`, ""].join(`
 `));
-  writeFileSync16(join28(skillDir, "package.json"), JSON.stringify({ name: bare, version: "0.1.0", description, bin: { [bare]: "./src/index.ts" }, scripts: { dev: `bun src/index.ts` }, dependencies: {} }, null, 2) + `
+  writeFileSync17(join31(skillDir, "package.json"), JSON.stringify({ name: bare, version: "0.1.0", description, bin: { [bare]: "./src/index.ts" }, scripts: { dev: `bun src/index.ts` }, dependencies: {} }, null, 2) + `
 `);
-  writeFileSync16(join28(skillDir, "tsconfig.json"), JSON.stringify({ compilerOptions: { target: "ES2022", module: "ESNext", moduleResolution: "bundler", strict: true, outDir: "dist" }, include: ["src/**/*.ts"] }, null, 2) + `
+  writeFileSync17(join31(skillDir, "tsconfig.json"), JSON.stringify({ compilerOptions: { target: "ES2022", module: "ESNext", moduleResolution: "bundler", strict: true, outDir: "dist" }, include: ["src/**/*.ts"] }, null, 2) + `
 `);
   clearRegistryCache();
   if (options.json)
@@ -71525,11 +71971,15 @@ function handleCreate(name, options) {
     console.log(source_default.green(`\u2713 Created custom skill '${bare}' at ${skillDir}`));
     console.log(source_default.dim(`  Category: ${options.category}`));
     console.log(source_default.dim(`  Tags: ${tags.join(", ")}`));
-    console.log(`  ${source_default.cyan("Edit:")} ${join28(skillDir, "src", "index.ts")}`);
-    console.log(`  ${source_default.cyan("Run:")}  bun ${join28(skillDir, "src", "index.ts")}`);
+    console.log(`  ${source_default.cyan("Edit:")} ${join31(skillDir, "src", "index.ts")}`);
+    console.log(`  ${source_default.cyan("Run:")}  bun ${join31(skillDir, "src", "index.ts")}`);
   }
 }
 function handleSync(names, options) {
+  if (options.station) {
+    handleStationSnapshot(names, options);
+    return;
+  }
   const modes = [options.check, options.adopt, options.prune].filter(Boolean).length;
   if (modes > 1) {
     const message = "--check, --adopt, and --prune are mutually exclusive";
@@ -71590,6 +72040,68 @@ function handleSync(names, options) {
     process.exitCode = 1;
   }
 }
+function handleStationSnapshot(names, options) {
+  const station = options.station;
+  if (!station)
+    return;
+  if (options.populate && options.dryRun) {
+    const message = "--populate and --dry-run are mutually exclusive";
+    if (options.json)
+      console.log(JSON.stringify({ error: message }));
+    else
+      console.error(source_default.red(message));
+    process.exitCode = 1;
+    return;
+  }
+  const incompatible = names.length > 0 || options.check || options.adopt || options.prune || options.force || options.all || options.source !== undefined;
+  if (incompatible) {
+    const message = "--station (per-station snapshot mode) cannot be combined with corpus->home sync names, --check, --adopt, --prune, --force, --all, or --source";
+    if (options.json)
+      console.log(JSON.stringify({ error: message }));
+    else
+      console.error(source_default.red(message));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const result2 = writeStationSnapshot({
+      stationId: station,
+      repoRoot: options.repoRoot,
+      homesRoot: options.homesRoot,
+      dryRun: !options.populate
+    });
+    if (result2.mode === "dry-run") {
+      if (options.json) {
+        console.log(JSON.stringify({
+          stationId: result2.stationId,
+          mode: "dry-run",
+          stats: { files: result2.stats.files, bytes: result2.stats.bytes },
+          homes: Object.fromEntries(result2.homes.map((home) => [
+            home.name,
+            { homePath: home.homePath, files: home.files, skipped: home.skipped }
+          ]))
+        }, null, 2));
+        return;
+      }
+      console.log(`DRY-RUN station=${result2.stationId} files=${result2.stats.files} bytes=${result2.stats.bytes}`);
+      for (const home of result2.homes) {
+        console.log(`  ${home.name}: ${home.files} files, ${home.skipped} skipped`);
+      }
+      return;
+    }
+    console.log(`POPULATE station=${result2.stationId} written=${result2.stats.written} unchanged=${result2.stats.unchanged} total=${result2.stats.files} bytes=${result2.stats.bytes}`);
+  } catch (error2) {
+    if (error2 instanceof StationSnapshotError) {
+      for (const line of error2.detail)
+        console.error(`CONFLICT ${line}`);
+      console.error(`FAIL ${error2.message}`);
+      process.exitCode = 2;
+    } else {
+      console.error(`FAIL ${error2.stack ?? error2.message}`);
+      process.exitCode = 1;
+    }
+  }
+}
 function handleSyncCheck(json) {
   const census = censusHomeDrift();
   if (json) {
@@ -71701,6 +72213,367 @@ var init_create_sync_config = __esm(() => {
   init_agent_sync();
   init_home_adoption();
   init_home_census();
+  init_station_snapshot();
+});
+
+// src/lib/station-hydrate.ts
+import { createHash as createHash5 } from "crypto";
+import {
+  copyFileSync as copyFileSync3,
+  mkdirSync as mkdirSync17,
+  readdirSync as readdirSync16,
+  readFileSync as readFileSync23,
+  statSync as statSync17,
+  writeFileSync as writeFileSync18
+} from "fs";
+import { dirname as dirname12, join as join32, resolve as resolve3, sep as sep5 } from "path";
+function fail2(code, message, detail = []) {
+  throw new StationSnapshotError(code, message, detail);
+}
+function snapshotRootFor(repoRoot, stationId) {
+  return join32(repoRoot, "resources", stationId, "skills");
+}
+function readSnapshotManifest(repoRoot, stationId) {
+  const snapshotRoot = snapshotRootFor(repoRoot, stationId);
+  const manifestPath = join32(snapshotRoot, "sync-manifest.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync23(manifestPath, "utf8"));
+  } catch (error2) {
+    fail2("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error2.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 = join32(snapshotRoot, "agent-homes", agent);
+    let identEntries;
+    try {
+      identEntries = readdirSync16(agentRoot, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const identEntry of identEntries) {
+      if (!identEntry.isDirectory() || identEntry.name.startsWith(".")) {
+        continue;
+      }
+      const identRoot = join32(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 = statSync17(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) {
+    fail2("SYMLINKS_REFUSED", `${symlinks.length} symlink(s) inside the snapshot; symlinks are refused (fail closed)`);
+  }
+  if (hashMismatches.length > 0) {
+    fail2("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(readFileSync23(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((sum2, skill) => sum2 + skill.files.length, 0);
+  const totalBytes = winners.reduce((sum2, skill) => sum2 + 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 createHash5("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 base2 = {
+    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 base2;
+  }
+  const conflicts = [];
+  const toWrite = [];
+  for (const skill of plan.winners) {
+    for (const file of skill.files) {
+      const destination = join32(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) {
+    fail2("CONFLICT", `${conflicts.length} conflict(s); terminal non-acceptance, nothing written`, conflicts);
+  }
+  let written = 0;
+  for (const entry of toWrite) {
+    mkdirSync17(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 = join32(dirname12(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync17(dirname12(hydrationManifestPath), { recursive: true });
+  writeFileSync18(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
+`);
+  return {
+    ...base2,
+    mode: "apply",
+    stats: { ...base2.stats, written, unchanged },
+    manifestPath: hydrationManifestPath
+  };
+}
+var STATION_HYDRATION_MANIFEST_SCHEMA = "hasna.fleet-resources.skills-hydration-manifest/v1", STATION_HYDRATION_PRODUCER, MANIFEST_HASH_KEY_SEP;
+var init_station_hydrate = __esm(() => {
+  init_package();
+  init_agent_sync();
+  init_home_migration();
+  init_portable_snapshot_filter();
+  init_station_snapshot();
+  STATION_HYDRATION_PRODUCER = { name: "@hasna/skills", version: package_default.version };
+  MANIFEST_HASH_KEY_SEP = String.fromCharCode(0);
+});
+
+// src/cli/commands/hydrate.ts
+var exports_hydrate = {};
+__export(exports_hydrate, {
+  registerHydrate: () => registerHydrate
+});
+function registerHydrate(parent) {
+  parent.command("hydrate").description("Hydrate the canonical dedup corpus cache from a reviewed per-station skills snapshot").requiredOption("--station <id>", "Station id (slug) naming the snapshot under resources/<id>/skills").option("--apply", "Write into the corpus cache (the default is dry-run)", false).option("--dry-run", "Report without writing anything (the default)", false).option("--cache-root <dir>", "Override the destination corpus cache (used to stage another station's cache before rsync)").option("--repo-root <path>", "Repo root holding resources/<station>/skills (default: cwd)").action((options) => {
+    handleHydrate(options);
+  });
+}
+function handleHydrate(options) {
+  if (options.apply && options.dryRun) {
+    console.error(source_default.red("--apply and --dry-run are mutually exclusive"));
+    process.exitCode = 2;
+    return;
+  }
+  let result2;
+  try {
+    result2 = writeStationHydration({
+      stationId: options.station,
+      repoRoot: options.repoRoot,
+      cacheRoot: options.cacheRoot,
+      dryRun: !options.apply
+    });
+  } catch (error2) {
+    if (error2 instanceof StationSnapshotError) {
+      for (const line of error2.detail)
+        console.error(`CONFLICT ${line}`);
+      console.error(`FAIL ${error2.message}`);
+      process.exitCode = 2;
+    } else {
+      console.error(`FAIL ${error2.stack ?? error2.message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (result2.mode === "dry-run") {
+    console.log(`DRY-RUN station=${result2.stationId} idents=${result2.stats.idents} files=${result2.stats.files} bytes=${result2.stats.bytes}`);
+    console.log(`  cache-root=${result2.cacheRoot} snapshot-sha=${result2.sourceSnapshotSha.slice(0, 12)}`);
+    for (const skill of result2.winners) {
+      const merged = skill.files.length > 1 ? ` (${skill.files.length} files, alternates: ${skill.files.map((file) => file.alternates.length > 0 ? `${file.withinIdent}<-${file.alternates.join(",")}` : null).filter(Boolean).join("; ") || "none"})` : "";
+      console.log(`  ${skill.ident}${merged}`);
+    }
+    return;
+  }
+  console.log(`HYDRATE station=${result2.stationId} idents=${result2.stats.idents} written=${result2.stats.written} unchanged=${result2.stats.unchanged} files=${result2.stats.files} bytes=${result2.stats.bytes}`);
+  console.log(`  manifest=${result2.manifestPath} snapshot-sha=${result2.sourceSnapshotSha}`);
+}
+var init_hydrate = __esm(() => {
+  init_source();
+  init_station_snapshot();
+  init_station_hydrate();
 });
 
 // src/cli/commands/portable-skills.ts
@@ -72031,8 +72904,8 @@ var init_schedule = __esm(() => {
 });
 
 // src/lib/registry-sync.ts
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname11, relative as relative4 } from "path";
+import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname13, relative as relative5 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
   const includeDocs = options.includeDocs ?? true;
@@ -72044,7 +72917,7 @@ function createRegistrySyncArtifact(options = {}) {
   const registry2 = [...loadRegistryProfile(profile)].sort((a, b) => a.name.localeCompare(b.name));
   const skills = registry2.map((skill) => {
     const skillPath = getSkillPath(skill.name);
-    const directory = relative4(process.cwd(), skillPath) || skillPath;
+    const directory = relative5(process.cwd(), skillPath) || skillPath;
     const validation = includeValidation ? validateSkillDirectory(skill.name, skillPath, skill) : undefined;
     const docs = includeDocs ? buildDocs(skill.name) : undefined;
     return {
@@ -72089,8 +72962,8 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync16(dirname11(path), { recursive: true });
-  writeFileSync17(path, `${JSON.stringify(artifact, null, 2)}
+  mkdirSync18(dirname13(path), { recursive: true });
+  writeFileSync19(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
 function buildDocs(name) {
@@ -72109,7 +72982,7 @@ var init_registry_sync = __esm(() => {
 });
 
 // src/lib/revision.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 function revisionIdOf(content) {
   const canonical = JSON.stringify({
     slug: content.slug,
@@ -72124,7 +72997,7 @@ function revisionIdOf(content) {
     bundleSha256: content.bundleSha256 ?? null,
     bundleByteSize: content.bundleByteSize ?? null
   });
-  return createHash4("sha256").update(canonical).digest("hex");
+  return createHash6("sha256").update(canonical).digest("hex");
 }
 var REVISION_ID_PATTERN;
 var init_revision = __esm(() => {
@@ -72132,9 +73005,9 @@ var init_revision = __esm(() => {
 });
 
 // src/lib/skill-bundle.ts
-import { createHash as createHash5 } from "crypto";
-import { readFileSync as readFileSync22, readdirSync as readdirSync15, statSync as statSync15 } from "fs";
-import { join as join29, relative as relative5 } from "path";
+import { createHash as createHash7 } from "crypto";
+import { readFileSync as readFileSync24, readdirSync as readdirSync17, statSync as statSync18 } from "fs";
+import { join as join33, relative as relative6 } from "path";
 function isDotenvFile(lower) {
   if (lower === ".env" || lower.startsWith(".env."))
     return true;
@@ -72163,7 +73036,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash5("sha256").update(bytes).digest("hex");
+  return createHash7("sha256").update(bytes).digest("hex");
 }
 function collectSkillBundleEntries(dir) {
   const entries = [];
@@ -72171,9 +73044,9 @@ function collectSkillBundleEntries(dir) {
   return entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
 }
 function walk(root, current, out) {
-  for (const entry of readdirSync15(current, { withFileTypes: true })) {
-    const absolute = join29(current, entry.name);
-    const rel = relative5(root, absolute).split("\\").join("/");
+  for (const entry of readdirSync17(current, { withFileTypes: true })) {
+    const absolute = join33(current, entry.name);
+    const rel = relative6(root, absolute).split("\\").join("/");
     const isRootLevel = !rel.includes("/");
     if (ANY_SEGMENT_EXCLUDES.has(entry.name.toLowerCase()))
       continue;
@@ -72193,10 +73066,10 @@ function walk(root, current, out) {
       continue;
     if (isCredentialFile(entry.name))
       continue;
-    const stats = statSync15(absolute);
+    const stats = statSync18(absolute);
     out.push({
       path: rel,
-      bytes: ownBytes(readFileSync22(absolute)),
+      bytes: ownBytes(readFileSync24(absolute)),
       mode: stats.mode & 64 ? 493 : 420
     });
   }
@@ -72482,8 +73355,8 @@ var init_skill_bundles = __esm(() => {
 });
 
 // src/lib/pull.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync3, readFileSync as readFileSync23, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname12, join as join30 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync19, mkdtempSync as mkdtempSync3, readFileSync as readFileSync25, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname14, join as join34 } from "path";
 async function pullSkills(options = {}) {
   const client = options.client !== undefined ? options.client : createRemoteSkillsClient();
   if (!client) {
@@ -72528,7 +73401,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
       return reconcileTombstone(slug, corpusOptions);
     }
     if (bundleResponse.status === 404) {
-      const marker = readPullMarker(join30(getPortableSkillsRoot(corpusOptions), slug));
+      const marker = readPullMarker(join34(getPortableSkillsRoot(corpusOptions), slug));
       if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
         return { name: slug, success: true, purged: true, removed: false };
       }
@@ -72559,7 +73432,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(join30(getPortableSkillsRoot(corpusOptions), slug));
+    const marker = readPullMarker(join34(getPortableSkillsRoot(corpusOptions), slug));
     if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
       return { name: slug, success: true, purged: true, removed: false };
     }
@@ -72616,8 +73489,8 @@ function provenRevision(meta, slug, bundle) {
   return declared;
 }
 function reconcileTombstone(slug, corpusOptions) {
-  const target = join30(getPortableSkillsRoot(corpusOptions), slug);
-  if (!existsSync28(join30(target, PULL_MARKER_FILE))) {
+  const target = join34(getPortableSkillsRoot(corpusOptions), slug);
+  if (!existsSync29(join34(target, PULL_MARKER_FILE))) {
     return { name: slug, success: true, tombstoned: true, removed: false, leftInPlace: true };
   }
   rmSync6(target, { recursive: true, force: true });
@@ -72625,7 +73498,7 @@ function reconcileTombstone(slug, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync23(join30(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync25(join34(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -72745,17 +73618,17 @@ function verifyBundleResponseBytes(buffer, response, verify = {}) {
 }
 function installBundleAtomically(name, entries, options = {}, marker = {}) {
   const root = getPortableSkillsRoot(options);
-  mkdirSync17(root, { recursive: true });
-  const target = join30(root, name);
-  const created = !existsSync28(target);
-  const staging = mkdtempSync3(join30(root, `.pull-${name}-`));
+  mkdirSync19(root, { recursive: true });
+  const target = join34(root, name);
+  const created = !existsSync29(target);
+  const staging = mkdtempSync3(join34(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
     for (const entry of entries) {
-      const destination = join30(staging, entry.path);
-      mkdirSync17(dirname12(destination), { recursive: true });
-      writeFileSync18(destination, entry.bytes, { mode: entry.mode });
+      const destination = join34(staging, entry.path);
+      mkdirSync19(dirname14(destination), { recursive: true });
+      writeFileSync20(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
       skill: name,
@@ -72765,9 +73638,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       ...marker.signature ? { signature: marker.signature } : {},
       ...marker.revisionId ? { revisionId: marker.revisionId } : {}
     });
-    if (existsSync28(target)) {
-      backup = mkdtempSync3(join30(root, `.pull-backup-${name}-`));
-      renameSync4(target, join30(backup, name));
+    if (existsSync29(target)) {
+      backup = mkdtempSync3(join34(root, `.pull-backup-${name}-`));
+      renameSync4(target, join34(backup, name));
       moved = true;
     }
     renameSync4(staging, target);
@@ -72775,9 +73648,9 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       rmSync6(backup, { recursive: true, force: true });
   } catch (error2) {
     rmSync6(staging, { recursive: true, force: true });
-    if (moved && backup && existsSync28(join30(backup, name))) {
+    if (moved && backup && existsSync29(join34(backup, name))) {
       try {
-        renameSync4(join30(backup, name), target);
+        renameSync4(join34(backup, name), target);
       } catch {}
     }
     throw error2;
@@ -72796,7 +73669,7 @@ function writePullMarker(dir, record3) {
     ...record3.revisionId ? { revisionId: record3.revisionId } : {},
     syncedAt: new Date().toISOString()
   };
-  writeFileSync18(join30(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+  writeFileSync20(join34(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function safeMeta(client, slug) {
@@ -72870,12 +73743,12 @@ function registerRegistry(parent) {
 async function writeJson2(value, space) {
   const text = `${JSON.stringify(value, null, space)}
 `;
-  await new Promise((resolve, reject2) => {
+  await new Promise((resolve4, reject2) => {
     process.stdout.write(text, (error2) => {
       if (error2)
         reject2(error2);
       else
-        resolve();
+        resolve4();
     });
   });
 }
@@ -72967,8 +73840,8 @@ __export(exports_publish, {
   pushSkill: () => pushSkill,
   PushSkillError: () => PushSkillError
 });
-import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
+import { join as join35 } from "path";
 function registerPublish(parent) {
   parent.command("push").argument("<name>", "Name of a skill in the local corpus (~/.hasna/skills/installed or the migrated ~/.hasna/skills/skills)").option("--version <version>", "Override the version recorded on the instance").option("--dry-run", "Pack and validate without uploading", false).option("--json", "Output result as JSON", false).description("Publish a local skill to the configured skills instance").action(async (name, options) => {
     try {
@@ -73009,8 +73882,8 @@ async function pushSkill(name, options = {}) {
   }
   const manifest = readPortableSkillManifest(skill.path, skill.name);
   const packed = packSkillBundle(skill.path, { maxUnpackedBytes: MAX_UNPACKED_BYTES });
-  const skillMdPath = join31(skill.path, "SKILL.md");
-  const skillMd = existsSync29(skillMdPath) ? readFileSync24(skillMdPath, "utf-8") : undefined;
+  const skillMdPath = join35(skill.path, "SKILL.md");
+  const skillMd = existsSync30(skillMdPath) ? readFileSync26(skillMdPath, "utf-8") : undefined;
   const base2 = {
     slug: skill.name,
     path: skill.path,
@@ -73127,10 +74000,10 @@ __export(exports_auth, {
 import { createInterface as createInterface2 } from "readline";
 function prompt(question) {
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
+  return new Promise((resolve4) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve(answer.trim());
+      resolve4(answer.trim());
     });
   });
 }
@@ -73280,7 +74153,7 @@ function printWhoami(payload) {
     console.log(source_default.dim("(offline \u2014 showing cached info)"));
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function browserCommand(url) {
   if (process.platform === "darwin")
@@ -73781,11 +74654,11 @@ var init_storage = __esm(() => {
 });
 
 // src/lib/registry-reconcile.ts
-import { existsSync as existsSync30, readFileSync as readFileSync25, statSync as statSync16, writeFileSync as writeFileSync19 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync27, statSync as statSync19, writeFileSync as writeFileSync21 } from "fs";
+import { join as join36 } from "path";
 function isDirectory2(path) {
   try {
-    return statSync16(path).isDirectory();
+    return statSync19(path).isDirectory();
   } catch {
     return false;
   }
@@ -73793,15 +74666,15 @@ function isDirectory2(path) {
 function migrationNeeded(options) {
   if (options.rootDir)
     return false;
-  const appDir = options.homeDir ? join32(options.homeDir, ".hasna", "skills") : getDataDir();
-  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join32(appDir, SKILLS_CACHE_DIRNAME)));
+  const appDir = options.homeDir ? join36(options.homeDir, ".hasna", "skills") : getDataDir();
+  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join36(appDir, SKILLS_CACHE_DIRNAME)));
 }
 function readBaseline(skillDir) {
-  const markerPath = join32(skillDir, PULL_MARKER_FILE);
-  if (!existsSync30(markerPath))
+  const markerPath = join36(skillDir, PULL_MARKER_FILE);
+  if (!existsSync31(markerPath))
     return;
   try {
-    const marker = JSON.parse(readFileSync25(markerPath, "utf-8"));
+    const marker = JSON.parse(readFileSync27(markerPath, "utf-8"));
     return {
       ...typeof marker.contentHash === "string" && marker.contentHash ? { contentHash: marker.contentHash } : {},
       ...typeof marker.version === "string" && marker.version ? { version: marker.version } : {}
@@ -73811,11 +74684,11 @@ function readBaseline(skillDir) {
   }
 }
 function readCursor(root) {
-  const path = join32(root, SYNC_CURSOR_FILE);
-  if (!existsSync30(path))
+  const path = join36(root, SYNC_CURSOR_FILE);
+  if (!existsSync31(path))
     return { runCount: 0 };
   try {
-    const cursor = JSON.parse(readFileSync25(path, "utf-8"));
+    const cursor = JSON.parse(readFileSync27(path, "utf-8"));
     return { runCount: typeof cursor.runCount === "number" ? cursor.runCount : 0 };
   } catch {
     return { runCount: 0 };
@@ -73824,12 +74697,12 @@ function readCursor(root) {
 function resolveCorpusRootReadOnly(options) {
   if (options.rootDir)
     return { root: options.rootDir, migrationPending: false };
-  const appDir = options.homeDir ? join32(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
-  const cache3 = join32(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join36(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
+  const cache3 = join36(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && isDirectory2(cache3)) {
     return { root: cache3, migrationPending: false };
   }
-  return { root: join32(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
+  return { root: join36(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
 }
 function remoteRowToSkill(record3) {
   const slug = typeof record3.slug === "string" ? record3.slug : typeof record3.name === "string" ? record3.name : undefined;
@@ -73843,7 +74716,7 @@ function remoteRowToSkill(record3) {
 }
 function recheckLocalSide(plannedLocal, localDir, ops = {
   pack: (dir) => packSkillBundle(dir).sha256,
-  exists: existsSync30
+  exists: existsSync31
 }) {
   let localNow;
   try {
@@ -73961,7 +74834,7 @@ async function reconcileRegistry(options = {}) {
   for (const slug of allSlugs) {
     const local = locals.get(slug);
     const remote = remotes.get(slug);
-    const baseline = local ? readBaseline(join32(root, slug)) : undefined;
+    const baseline = local ? readBaseline(join36(root, slug)) : undefined;
     const { state, reason } = classifySkill(local, remote, baseline);
     let { action, reason: actionReason } = resolveAction(state, direction, conflict);
     if (state === "remote-only" && isDigestless(remote)) {
@@ -74020,7 +74893,7 @@ async function reconcileRegistry(options = {}) {
       try {
         await pushSkill(slug, { rootDir: root, client });
         const pushed = locals.get(slug);
-        writePullMarker(join32(root, slug), {
+        writePullMarker(join36(root, slug), {
           skill: slug,
           ...pushed?.version ? { version: pushed.version } : {},
           ...pushed?.sha256 ? { contentHash: pushed.sha256 } : {},
@@ -74092,7 +74965,7 @@ async function reconcileRegistry(options = {}) {
         runCount: readCursor(root).runCount + 1,
         summary
       };
-      writeFileSync19(join32(root, SYNC_CURSOR_FILE), `${JSON.stringify(cursor, null, 2)}
+      writeFileSync21(join36(root, SYNC_CURSOR_FILE), `${JSON.stringify(cursor, null, 2)}
 `);
       return {
         corpusRoot: root,
@@ -79222,19 +80095,15 @@ var import_react21 = __toESM(require_react(), 1);
 // src/cli/index.tsx
 init_esm();
 
-// ../events/dist/commander.js
+// ../../node_modules/.bun/@hasna+events@0.1.16/node_modules/@hasna/events/dist/commander.js
 import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
 import { Buffer as Buffer22 } from "buffer";
 import { existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
 import { createHmac, timingSafeEqual } from "crypto";
-import { lookup as dnsLookup } from "dns/promises";
-import { isIP } from "net";
 import { randomUUID } from "crypto";
 import { spawn } from "child_process";
-import { request as nodeHttpRequest } from "http";
-import { request as nodeHttpsRequest } from "https";
 import { randomUUID as randomUUID2 } from "crypto";
 function getPathValue(input, path) {
   return path.split(".").reduce((value, part) => {
@@ -79637,214 +80506,6 @@ function signPayload(secret, timestamp, body) {
   const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
   return `sha256=${digest}`;
 }
-var DEFAULT_MAX_REDIRECTS = 5;
-var IPV4_PRIVATE_RANGES = [
-  [0, 16777215],
-  [167772160, 184549375],
-  [1681915904, 1686110207],
-  [2130706432, 2147483647],
-  [2851995648, 2852061183],
-  [2886729728, 2887778303],
-  [3221225472, 3221225727],
-  [3221225984, 3221226239],
-  [3227017984, 3227018239],
-  [3232235520, 3232301055],
-  [3323068416, 3323199487],
-  [3325256704, 3325256959],
-  [3405803776, 3405804031],
-  [3758096384, 4294967295]
-];
-var IPV6_SPECIAL_PREFIXES = [
-  { groups: [0, 0, 0, 0, 0, 0, 0, 0], bits: 128 },
-  { groups: [0, 0, 0, 0, 0, 0, 0, 1], bits: 128 },
-  { groups: [0, 0, 0, 0, 0, 65535, 0, 0], bits: 96 },
-  { groups: [100, 65435, 0, 0, 0, 0, 0, 0], bits: 96 },
-  { groups: [256, 0, 0, 0, 0, 0, 0, 0], bits: 64 },
-  { groups: [8193, 0, 0, 0, 0, 0, 0, 0], bits: 32 },
-  { groups: [8193, 2, 0, 0, 0, 0, 0, 0], bits: 48 },
-  { groups: [8193, 16, 0, 0, 0, 0, 0, 0], bits: 28 },
-  { groups: [8193, 3512, 0, 0, 0, 0, 0, 0], bits: 32 },
-  { groups: [8194, 0, 0, 0, 0, 0, 0, 0], bits: 16 },
-  { groups: [16383, 0, 0, 0, 0, 0, 0, 0], bits: 20 },
-  { groups: [64512, 0, 0, 0, 0, 0, 0, 0], bits: 7 },
-  { groups: [65152, 0, 0, 0, 0, 0, 0, 0], bits: 10 },
-  { groups: [65216, 0, 0, 0, 0, 0, 0, 0], bits: 10 },
-  { groups: [65280, 0, 0, 0, 0, 0, 0, 0], bits: 8 }
-];
-function isPrivateAddress(address) {
-  const normalized = stripZoneId(address);
-  const version = isIP(normalized);
-  if (version === 4) {
-    const integer = ipv4ToInt(normalized);
-    if (integer === undefined)
-      return true;
-    return IPV4_PRIVATE_RANGES.some(([low, high]) => integer >= low && integer <= high);
-  }
-  if (version === 6) {
-    const groups = ipv6Groups(normalized);
-    if (!groups)
-      return true;
-    for (const prefix of IPV6_SPECIAL_PREFIXES) {
-      if (!ipv6MatchesPrefix(groups, prefix.groups, prefix.bits))
-        continue;
-      if (prefix.bits === 96 && groups[5] === 65535) {
-        return isPrivateAddress(ipv4IntToString(groups[6] << 16 | groups[7]));
-      }
-      if (prefix.bits === 16 && groups[0] === 8194) {
-        return isPrivateAddress(ipv4IntToString(groups[1] << 16 | groups[2]));
-      }
-      return true;
-    }
-    return false;
-  }
-  return true;
-}
-async function resolveWebhookTarget(url, policy = {}) {
-  const hostname = normalizeHostname(url.hostname);
-  const allowlist = (policy.allowPrivateHosts ?? []).map((entry) => normalizeHostname(entry.toLowerCase()));
-  if (allowlist.includes(hostname)) {
-    const version2 = isIP(hostname);
-    if (version2 === 4 || version2 === 6) {
-      return { hostname, addresses: [hostname] };
-    }
-    const lookup2 = policy.lookup ?? defaultTargetLookup;
-    let resolved2;
-    try {
-      resolved2 = await lookup2(hostname);
-    } catch {
-      throw new Error(`Webhook target ${hostname} could not be resolved`);
-    }
-    if (!Array.isArray(resolved2) || resolved2.length === 0) {
-      throw new Error(`Webhook target ${hostname} resolved to no addresses`);
-    }
-    const addresses = resolved2.map((entry) => normalizeHostname(entry.address));
-    return { hostname, addresses };
-  }
-  const version = isIP(hostname);
-  if (version === 4 || version === 6) {
-    if (isPrivateAddress(hostname)) {
-      throw new Error(`Webhook target ${hostname} is a private or special-use address`);
-    }
-    return { hostname, addresses: [hostname] };
-  }
-  const lookup = policy.lookup ?? defaultTargetLookup;
-  let resolved;
-  try {
-    resolved = await lookup(hostname);
-  } catch {
-    throw new Error(`Webhook target ${hostname} could not be resolved`);
-  }
-  if (!Array.isArray(resolved) || resolved.length === 0) {
-    throw new Error(`Webhook target ${hostname} resolved to no addresses`);
-  }
-  const allowed = [];
-  for (const entry of resolved) {
-    const address = normalizeHostname(entry.address);
-    if (isPrivateAddress(address)) {
-      if (allowlist.includes(address)) {
-        allowed.push(address);
-        continue;
-      }
-      throw new Error(`Webhook target ${hostname} resolves to private or special-use address ${address}`);
-    }
-    allowed.push(address);
-  }
-  if (allowed.length === 0) {
-    throw new Error(`Webhook target ${hostname} resolved to no public addresses`);
-  }
-  return { hostname, addresses: allowed };
-}
-function normalizeMaxRedirects(value) {
-  if (value === undefined)
-    return DEFAULT_MAX_REDIRECTS;
-  if (!Number.isInteger(value) || value < 0)
-    throw new Error("webhookTargetPolicy.maxRedirects must be a non-negative integer");
-  return value;
-}
-var defaultTargetLookup = async (hostname) => {
-  return dnsLookup(hostname, { all: true, verbatim: false });
-};
-function normalizeHostname(hostname) {
-  const lower = hostname.toLowerCase();
-  if (lower.startsWith("[") && lower.endsWith("]"))
-    return lower.slice(1, -1);
-  return lower;
-}
-function stripZoneId(address) {
-  const percent = address.indexOf("%");
-  return percent === -1 ? address : address.slice(0, percent);
-}
-function ipv4ToInt(address) {
-  const parts = address.split(".");
-  if (parts.length !== 4)
-    return;
-  let value = 0;
-  for (const part of parts) {
-    if (!/^\d{1,3}$/.test(part))
-      return;
-    const octet = Number(part);
-    if (octet > 255)
-      return;
-    value = value << 8 | octet;
-  }
-  return value >>> 0;
-}
-function ipv4IntToString(integer) {
-  return [
-    integer >>> 24 & 255,
-    integer >>> 16 & 255,
-    integer >>> 8 & 255,
-    integer & 255
-  ].join(".");
-}
-function ipv6Groups(address) {
-  const raw = stripZoneId(address);
-  const doubleColon = raw.indexOf("::");
-  const headText = doubleColon === -1 ? raw : raw.slice(0, doubleColon);
-  const tailText = doubleColon === -1 ? "" : raw.slice(doubleColon + 2);
-  const parseGroups = (text) => {
-    if (text === "")
-      return [];
-    const out = [];
-    for (const part of text.split(":")) {
-      if (part.includes(".")) {
-        const v4 = ipv4ToInt(part);
-        if (v4 === undefined)
-          return;
-        out.push(v4 >>> 16 & 65535, v4 & 65535);
-      } else {
-        if (!/^[0-9a-fA-F]{1,4}$/.test(part))
-          return;
-        out.push(parseInt(part, 16));
-      }
-    }
-    return out;
-  };
-  const head2 = parseGroups(headText);
-  if (!head2)
-    return;
-  const tail2 = parseGroups(tailText);
-  if (!tail2)
-    return;
-  const total = head2.length + tail2.length;
-  if (doubleColon === -1) {
-    return total === 8 ? head2 : undefined;
-  }
-  if (total >= 8)
-    return;
-  return [...head2, ...new Array(8 - total).fill(0), ...tail2];
-}
-function ipv6MatchesPrefix(groups, prefixGroups, prefixBits) {
-  let remaining = prefixBits;
-  for (let index = 0;index < prefixGroups.length && remaining > 0; index += 1) {
-    const take2 = Math.min(16, remaining);
-    const mask = 65535 << 16 - take2 & 65535;
-    if ((groups[index] & mask) !== (prefixGroups[index] & mask))
-      return false;
-    remaining -= take2;
-  }
-  return true;
-}
 function now2() {
   return new Date().toISOString();
 }
@@ -79875,18 +80536,9 @@ function buildWebhookRequest(event, channel, options = {}) {
   }
   return { body, headers };
 }
-function normalizeWebhookUrl(raw) {
-  const url = new URL(raw);
-  if (url.username !== "" || url.password !== "") {
-    url.username = "";
-    url.password = "";
-  }
-  return url.toString();
-}
 async function dispatchWebhook(event, channel, options = {}) {
   if (!channel.webhook)
     throw new Error(`Channel ${channel.id} has no webhook config`);
-  const webhookUrl = normalizeWebhookUrl(channel.webhook.url);
   const startedAt = now2();
   let secret = channel.webhook.secret;
   if (channel.webhook.secretRef) {
@@ -79903,14 +80555,10 @@ async function dispatchWebhook(event, channel, options = {}) {
   }
   const timestamp = (options.now?.() ?? new Date).toISOString();
   const { body, headers } = buildWebhookRequest(event, channel, { secret, timestamp });
-  const validateTargets = options.webhookTargetPolicy !== undefined || options.fetchImpl === undefined;
-  if (validateTargets) {
-    return dispatchValidatedWebhook(event, channel, { body, headers, startedAt, options });
-  }
   const controller = new AbortController;
   const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
   try {
-    const response = await (options.fetchImpl ?? fetch)(webhookUrl, {
+    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
       method: "POST",
       headers,
       body,
@@ -79938,130 +80586,6 @@ async function dispatchWebhook(event, channel, options = {}) {
     clearTimeout(timeout);
   }
 }
-function isRedirectStatus(status) {
-  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-function redirectKeepsBody(status) {
-  return status === 307 || status === 308;
-}
-async function pinnedNativeRequest(target, addresses, method2, headers, body, signal, tls) {
-  const isHttps = target.protocol === "https:";
-  if (!isHttps && target.protocol !== "http:") {
-    throw new Error(`Webhook target uses unsupported protocol ${target.protocol}`);
-  }
-  const defaultPort = isHttps ? 443 : 80;
-  const port = target.port ? Number(target.port) : defaultPort;
-  const requestOptions = {
-    hostname: target.hostname,
-    port,
-    path: `${target.pathname}${target.search}`,
-    method: method2,
-    headers,
-    ...tls?.ca ? { ca: tls.ca } : {},
-    lookup: (hostname, _options, callback) => {
-      const entries = addresses.map((address) => ({
-        address,
-        family: address.includes(":") ? 6 : 4
-      }));
-      callback(null, entries);
-    }
-  };
-  return new Promise((resolve, reject2) => {
-    const request = isHttps ? nodeHttpsRequest(requestOptions, onResponse) : nodeHttpRequest(requestOptions, onResponse);
-    const onAbort = () => {
-      const error = new Error("The operation was aborted.");
-      error.name = "AbortError";
-      request.destroy(error);
-    };
-    if (signal.aborted)
-      onAbort();
-    else
-      signal.addEventListener("abort", onAbort, { once: true });
-    request.on("error", reject2);
-    if (body !== undefined)
-      request.write(body);
-    request.end();
-    function onResponse(response) {
-      const chunks = [];
-      response.on("data", (chunk2) => chunks.push(Buffer.from(chunk2)));
-      response.on("error", reject2);
-      response.on("end", () => {
-        const headersRecord = {};
-        for (const [name, value] of Object.entries(response.headers)) {
-          if (typeof value === "string")
-            headersRecord[name] = value;
-          else if (Array.isArray(value))
-            headersRecord[name] = value.join(", ");
-        }
-        resolve(new Response(Buffer.concat(chunks), { status: response.statusCode ?? 200, headers: headersRecord }));
-      });
-    }
-  });
-}
-async function dispatchValidatedWebhook(event, channel, input) {
-  const { body, headers, startedAt, options } = input;
-  const webhook = channel.webhook;
-  if (!webhook)
-    throw new Error(`Channel ${channel.id} has no webhook config`);
-  const policy = options.webhookTargetPolicy ?? {};
-  const maxRedirects = normalizeMaxRedirects(policy.maxRedirects);
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), webhook.timeoutMs ?? 15000);
-  try {
-    let target = new URL(normalizeWebhookUrl(webhook.url));
-    let requestHeaders = headers;
-    let method2 = "POST";
-    let requestBody = body;
-    let redirectsFollowed = 0;
-    for (;; ) {
-      const resolved = await resolveWebhookTarget(target, policy).catch((error) => {
-        throw new Error(`Webhook target rejected by SSRF guard: ${error.message}`);
-      });
-      const response = options.fetchImpl ? await options.fetchImpl(target, {
-        method: method2,
-        headers: requestHeaders,
-        body: requestBody,
-        signal: controller.signal,
-        redirect: "manual"
-      }) : await pinnedNativeRequest(target, resolved.addresses, method2, requestHeaders, requestBody, controller.signal, options.tls);
-      const location = response.headers.get("location");
-      if (isRedirectStatus(response.status) && location) {
-        if (redirectsFollowed >= maxRedirects) {
-          return failedAttempt(startedAt, `Webhook target exceeded ${maxRedirects} redirects`);
-        }
-        redirectsFollowed += 1;
-        const next = new URL(location, target);
-        target = next;
-        if (!redirectKeepsBody(response.status)) {
-          method2 = "GET";
-          requestBody = undefined;
-          requestHeaders = Object.fromEntries(Object.entries(requestHeaders).filter(([name]) => name.toLowerCase() !== "content-type" && name.toLowerCase() !== "content-length"));
-        }
-        continue;
-      }
-      const responseBody = truncate2(await response.text());
-      return {
-        attempt: 1,
-        status: response.ok ? "success" : "failed",
-        startedAt,
-        completedAt: now2(),
-        responseStatus: response.status,
-        responseBody,
-        error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
-      };
-    }
-  } catch (error) {
-    return {
-      attempt: 1,
-      status: "failed",
-      startedAt,
-      completedAt: now2(),
-      error: error instanceof Error ? error.message : String(error)
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
 function failedAttempt(startedAt, error) {
   return {
     attempt: 1,
@@ -80271,9 +80795,7 @@ class EventsClient {
     this.transportOptions = {
       fetchImpl: options.fetchImpl,
       secretResolver: options.secretResolver,
-      now: options.now,
-      tls: options.tls,
-      webhookTargetPolicy: options.webhookTargetPolicy
+      now: options.now
     };
     this.catalog = options.catalog ?? defaultEventTypeCatalog;
     this.validateCatalogTypes = options.validateCatalogTypes ?? false;
@@ -81904,6 +82426,8 @@ var { registerCompletion: registerCompletion2 } = await Promise.resolve().then((
 registerCompletion2(program2);
 var { registerCreateSync: registerCreateSync2 } = await Promise.resolve().then(() => (init_create_sync_config(), exports_create_sync_config));
 registerCreateSync2(program2);
+var { registerHydrate: registerHydrate2 } = await Promise.resolve().then(() => (init_hydrate(), exports_hydrate));
+registerHydrate2(program2);
 var { registerPortableSkillCommands: registerPortableSkillCommands2 } = await Promise.resolve().then(() => (init_portable_skills2(), exports_portable_skills));
 registerPortableSkillCommands2(program2);
 var { registerSchedule: registerSchedule2 } = await Promise.resolve().then(() => (init_schedule(), exports_schedule));