@hasna/skills 0.1.63 → 0.1.66

package/dist/index.js

@@ -47,8 +47,8 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/lib/registry.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync6 } from "fs";
+import { join as join7 } from "path";
 
 // src/lib/config.ts
 import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
@@ -154,6 +154,11 @@ function normalizeConfigValue(key, value) {
 }
 var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
 var INSTALLED_SKILLS_DIRNAME = "installed";
+var SKILLS_CACHE_DIRNAME = "skills";
+var LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
+function isOwnerLayoutMigrated(appDir) {
+  return existsSync(join(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+}
 function getDataDir() {
   const override = process.env[DATA_DIR_ENV];
   if (override) {
@@ -267,15 +272,16 @@ function unsetConfig(key, scope = "project") {
 // src/lib/portable-skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
-  readdirSync as readdirSync4,
+  mkdtempSync,
+  readdirSync as readdirSync5,
   renameSync,
   rmSync,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, normalize as normalize2 } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join6, normalize as normalize2 } from "path";
 
 // src/lib/registry-data/development-tools.ts
 var DEVELOPMENT_TOOLS_SKILLS = [
@@ -435,7 +441,7 @@ var DEVELOPMENT_TOOLS_SKILLS = [
   {
     name: "monitor",
     displayName: "Monitor",
-    description: "Operate the open-monitor MCP for machine health, processes, cron jobs, and cleanup workflows",
+    description: "Operate the monitor MCP for machine health, processes, cron jobs, and cleanup workflows",
     category: "Development Tools",
     tags: ["monitoring", "mcp", "processes", "operations"]
   },
@@ -481,6 +487,14 @@ var DEVELOPMENT_TOOLS_SKILLS = [
     description: "Validate configuration files for syntax and schema compliance",
     category: "Development Tools",
     tags: ["config", "validation", "schema", "linting"]
+  },
+  {
+    name: "session-inject-monitor",
+    displayName: "Session Inject Monitor",
+    description: "Set up a declarative monitor that injects a prompt into a live coding-agent session when a watched source (conversations, email, todos, knowledge, command output) has new content",
+    category: "Development Tools",
+    tags: ["monitor", "session", "injection", "automation", "wake"],
+    kind: "instruction"
   }
 ];
 
@@ -868,7 +882,7 @@ var DESIGN_BRANDING_SKILLS = [
     displayName: "Site Analyze",
     description: "Analyze any website's design system \u2014 detects shadcn/ui, Tailwind, extracts colors, typography, and components via Playwright + Claude Vision.",
     category: "Design & Branding",
-    tags: ["design", "shadcn", "tailwind", "colors", "typography", "playwright", "analysis", "open-styles"]
+    tags: ["design", "shadcn", "tailwind", "colors", "typography", "playwright", "analysis", "styles"]
   }
 ];
 
@@ -978,11 +992,9 @@ var SKILLS = [
   ...EVENT_MANAGEMENT_SKILLS
 ];
 
-// src/lib/skill-validation.ts
-import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { isAbsolute, join as join2, normalize } from "path";
-
 // src/lib/hosted-skill-set.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
 var HOSTED_RUNTIMES = new Set(["hosted"]);
 var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
 function normalizeMarker(value) {
@@ -994,6 +1006,16 @@ function isHostedMetadataPackage(pkg) {
     return false;
   return HOSTED_RUNTIMES.has(normalizeMarker(skills.runtime)) || HOSTED_SOURCES.has(normalizeMarker(skills.source));
 }
+function isHostedMetadataSkillDir(skillDir) {
+  const pkgPath = join2(skillDir, "package.json");
+  if (!existsSync2(pkgPath))
+    return false;
+  try {
+    return isHostedMetadataPackage(JSON.parse(readFileSync2(pkgPath, "utf8")));
+  } catch {
+    return false;
+  }
+}
 var HOSTED_METADATA_SET_EMPTY_ERROR = [
   "The hosted metadata skill set is empty, but the packaging guards that depend on it",
   "only mean anything while it is non-empty: an empty set makes every one of them pass",
@@ -1010,6 +1032,8 @@ var BRACE_SOURCE_EXCLUSION = new RegExp(`^!skills/\\{(${SLUG}(?:,${SLUG})+)\\}/s
 var SINGLE_SOURCE_EXCLUSION = new RegExp(`^!skills/(${SLUG})/src$`);
 
 // src/lib/skill-validation.ts
+import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join3, normalize } from "path";
 var VALID_SKILL_KINDS = ["executable", "instruction"];
 var DOC_FILES = ["SKILL.md", "README.md", "CLAUDE.md"];
 var RESERVED_SKILL_ENTRIES = new Set([
@@ -1063,7 +1087,7 @@ function add(target, code, message) {
   target.push({ code, message });
 }
 function readJsonFile(path) {
-  return JSON.parse(readFileSync2(path, "utf-8"));
+  return JSON.parse(readFileSync3(path, "utf-8"));
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -1147,7 +1171,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     binCommands: [],
     docFiles: []
   };
-  if (!existsSync2(skillPath)) {
+  if (!existsSync3(skillPath)) {
     add(issues, "skill.dir_missing", `Skill directory not found: ${skillPath}`);
     return {
       name: bareName,
@@ -1161,8 +1185,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   if (!VALID_BIN_COMMAND.test(bareName)) {
     add(issues, "skill.name_invalid", `Skill name '${bareName}' must use lowercase letters, numbers, dots, underscores, or hyphens`);
   }
-  for (const entry of readdirSync2(skillPath).sort()) {
-    const entryPath = join2(skillPath, entry);
+  for (const entry of readdirSync3(skillPath).sort()) {
+    const entryPath = join3(skillPath, entry);
     if (RESERVED_SKILL_ENTRIES.has(entry)) {
       add(issues, "skill.reserved_file", `Reserved file '${entry}' is not allowed in skill packages`);
     }
@@ -1174,15 +1198,15 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     }
   }
   for (const docFile of DOC_FILES) {
-    if (existsSync2(join2(skillPath, docFile)))
+    if (existsSync3(join3(skillPath, docFile)))
       metadata.docFiles.push(docFile);
   }
   if (metadata.docFiles.length === 0) {
     add(issues, "skill.docs_missing", "Missing documentation file: expected SKILL.md, README.md, or CLAUDE.md");
   }
-  const skillMdPath = join2(skillPath, "SKILL.md");
-  if (existsSync2(skillMdPath)) {
-    const frontmatter = parseSkillFrontmatter(readFileSync2(skillMdPath, "utf-8"));
+  const skillMdPath = join3(skillPath, "SKILL.md");
+  if (existsSync3(skillMdPath)) {
+    const frontmatter = parseSkillFrontmatter(readFileSync3(skillMdPath, "utf-8"));
     if (!frontmatter) {
       add(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
     } else {
@@ -1224,8 +1248,8 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   metadata.kind = resolvedKind;
   const isInstruction = resolvedKind === "instruction";
-  const pkgPath = join2(skillPath, "package.json");
-  if (!existsSync2(pkgPath)) {
+  const pkgPath = join3(skillPath, "package.json");
+  if (!existsSync3(pkgPath)) {
     if (!isInstruction)
       add(issues, "package.missing", "Missing package.json");
   } else {
@@ -1283,10 +1307,10 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
               add(issues, "package.bin_target_unsafe", `package.json bin '${command}' target '${target}' must stay inside the skill directory`);
               continue;
             }
-            const targetPath = join2(skillPath, target);
-            if (!existsSync2(targetPath)) {
+            const targetPath = join3(skillPath, target);
+            if (!existsSync3(targetPath)) {
               add(warnings, "package.bin_target_missing", `package.json bin '${command}' target '${target}' is not present before build`);
-            } else if (statSync2(targetPath).isDirectory()) {
+            } else if (statSync3(targetPath).isDirectory()) {
               add(issues, "package.bin_target_directory", `package.json bin '${command}' target '${target}' must point to a file, not a directory`);
             }
           }
@@ -1301,18 +1325,18 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
     metadata.runtime = "none";
   } else {
     metadata.runtime = hostedMetadata ? "hosted" : "local";
-    const srcDir = join2(skillPath, "src");
+    const srcDir = join3(skillPath, "src");
     if (hostedMetadata) {
-      if (existsSync2(srcDir)) {
+      if (existsSync3(srcDir)) {
         add(issues, "skill.hosted_source_forbidden", "Hosted metadata skills must not include local implementation source");
       }
-    } else if (!existsSync2(srcDir)) {
+    } else if (!existsSync3(srcDir)) {
       add(issues, "skill.src_missing", "Missing src/ directory");
-    } else if (!existsSync2(join2(srcDir, "index.ts")) && !existsSync2(join2(srcDir, "index.js"))) {
+    } else if (!existsSync3(join3(srcDir, "index.ts")) && !existsSync3(join3(srcDir, "index.js"))) {
       add(issues, "skill.src_index_missing", "Missing src/index.ts or src/index.js");
     } else {
-      const indexPath = existsSync2(join2(srcDir, "index.ts")) ? join2(srcDir, "index.ts") : join2(srcDir, "index.js");
-      const size = statSync2(indexPath).size;
+      const indexPath = existsSync3(join3(srcDir, "index.ts")) ? join3(srcDir, "index.ts") : join3(srcDir, "index.js");
+      const size = statSync3(indexPath).size;
       if (size < 50)
         add(warnings, "skill.src_index_minimal", `Source entry point is very small (${size}B)`);
     }
@@ -1335,9 +1359,9 @@ function validateRegistryConsistency(registry, skillsDir) {
     seen.add(name);
     return false;
   })));
-  const skillDirs = existsSync2(skillsDir) ? readdirSync2(skillsDir).filter((entry) => {
-    const fullPath = join2(skillsDir, entry);
-    return !entry.startsWith(".") && entry !== "_common" && statSync2(fullPath).isDirectory();
+  const skillDirs = existsSync3(skillsDir) ? readdirSync3(skillsDir).filter((entry) => {
+    const fullPath = join3(skillsDir, entry);
+    return !entry.startsWith(".") && entry !== "_common" && statSync3(fullPath).isDirectory();
   }) : [];
   const directoryNames = new Set(skillDirs);
   const registryNameSet = new Set(registryNames);
@@ -1353,8 +1377,8 @@ function validateRegistryConsistency(registry, skillsDir) {
 
 // src/lib/skill-hash.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { join as join3, sep } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { join as join4, sep } from "path";
 var CONTENT_HASH_ALGORITHM = "sha256";
 var HASH_EXCLUDE_DIRS = new Set([".git", "node_modules", "dist", "build", ".turbo"]);
 var HASH_COVERAGE = [
@@ -1413,10 +1437,10 @@ function collectBundleFiles(skillPath) {
     if (seen.has(entry))
       continue;
     seen.add(entry);
-    const absolute = join3(skillPath, entry);
-    if (!existsSync3(absolute))
+    const absolute = join4(skillPath, entry);
+    if (!existsSync4(absolute))
       continue;
-    if (statSync3(absolute).isDirectory())
+    if (statSync4(absolute).isDirectory())
       collectDirectory(files, absolute, entry);
     else
       collectFile(files, absolute, entry);
@@ -1424,14 +1448,14 @@ function collectBundleFiles(skillPath) {
   return files.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
 }
 function collectDirectory(files, dir, rel) {
-  for (const entry of readdirSync3(dir).sort()) {
+  for (const entry of readdirSync4(dir).sort()) {
     if (entry.startsWith("."))
       continue;
-    const absolute = join3(dir, entry);
+    const absolute = join4(dir, entry);
     const childRel = `${rel}/${entry}`;
     let stats;
     try {
-      stats = statSync3(absolute);
+      stats = statSync4(absolute);
     } catch {
       continue;
     }
@@ -1447,7 +1471,7 @@ function collectDirectory(files, dir, rel) {
   }
 }
 function collectFile(files, absolute, rel) {
-  const buffer = readFileSync3(absolute);
+  const buffer = readFileSync4(absolute);
   if (rel === "skill.json") {
     files.push({ rel: rel.split(sep).join("/"), content: new TextEncoder().encode(canonicalizeManifest(new TextDecoder().decode(buffer))) });
     return;
@@ -1647,14 +1671,14 @@ function validateRuntimeContract(manifest, issues, strict) {
 // src/lib/portable-skills-files.ts
 import {
   cpSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   realpathSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join4, relative } from "path";
+import { basename, dirname as dirname2, join as join5, relative } from "path";
 var ANY_SEGMENT_COPY_EXCLUDES = new Set([
   ".git",
   ".DS_Store",
@@ -1697,12 +1721,12 @@ function normalizePortableSkillName(name) {
   return normalized;
 }
 function readPortableSkillManifest(skillPath, fallbackName = basename(skillPath)) {
-  const skillJsonPath = join4(skillPath, "skill.json");
-  const skillMdPath = join4(skillPath, "SKILL.md");
-  const pkgPath = join4(skillPath, "package.json");
-  const jsonManifest = existsSync4(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync4(skillMdPath) ? parseSkillFrontmatter(readFileSync4(skillMdPath, "utf-8")) ?? undefined : undefined;
-  const pkg = existsSync4(pkgPath) ? readJsonObject(pkgPath) : undefined;
+  const skillJsonPath = join5(skillPath, "skill.json");
+  const skillMdPath = join5(skillPath, "SKILL.md");
+  const pkgPath = join5(skillPath, "package.json");
+  const jsonManifest = existsSync5(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
+  const frontmatter = existsSync5(skillMdPath) ? parseSkillFrontmatter(readFileSync5(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const pkg = existsSync5(pkgPath) ? readJsonObject(pkgPath) : undefined;
   const 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;
@@ -1748,7 +1772,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync2(skillPath, { recursive: true });
-  writeFileSync2(join4(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync2(join5(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -1797,12 +1821,12 @@ function createPortableManifest(name, options) {
   };
 }
 function writePortableSkillTemplate(skillPath, manifest) {
-  mkdirSync2(join4(skillPath, "src"), { recursive: true });
-  writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync2(join4(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync2(join4(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync2(join4(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync2(join4(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+  mkdirSync2(join5(skillPath, "src"), { recursive: true });
+  writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync2(join5(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync2(join5(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -1827,7 +1851,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync2(join4(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash = computeContentHash(skillPath);
   const withHash = {
@@ -1837,16 +1861,16 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash
     }
   };
-  writeFileSync2(join4(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync2(join5(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
 `);
   return withHash;
 }
 function readExistingSkillJson(skillPath) {
-  const path = join4(skillPath, "skill.json");
-  if (!existsSync4(path))
+  const path = join5(skillPath, "skill.json");
+  if (!existsSync5(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
     return isRecord2(parsed) ? parsed : {};
   } catch {
     return {};
@@ -1876,28 +1900,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 && !existsSync4(join4(skillPath, entry))) {
-    mkdirSync2(dirname2(join4(skillPath, entry)), { recursive: true });
-    writeFileSync2(join4(skillPath, entry), renderEntrypoint(next));
+  if (entry && !existsSync5(join5(skillPath, entry))) {
+    mkdirSync2(dirname2(join5(skillPath, entry)), { recursive: true });
+    writeFileSync2(join5(skillPath, entry), renderEntrypoint(next));
   }
-  if (!existsSync4(join4(skillPath, "SKILL.md")))
-    writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync5(join5(skillPath, "SKILL.md")))
+    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync2(join4(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync4(join4(skillPath, "SKILL.md"), "utf-8"), next));
-  if (!existsSync4(join4(skillPath, "AGENTS.md")))
-    writeFileSync2(join4(skillPath, "AGENTS.md"), renderAgentsMd(next));
+    writeFileSync2(join5(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync5(join5(skillPath, "SKILL.md"), "utf-8"), next));
+  if (!existsSync5(join5(skillPath, "AGENTS.md")))
+    writeFileSync2(join5(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
-  if (!existsSync4(join4(skillPath, "tsconfig.json")))
-    writeFileSync2(join4(skillPath, "tsconfig.json"), renderTsconfig());
+  if (!existsSync5(join5(skillPath, "tsconfig.json")))
+    writeFileSync2(join5(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
 function ensurePackageJson(skillPath, manifest) {
-  const pkgPath = join4(skillPath, "package.json");
+  const pkgPath = join5(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 (!existsSync4(pkgPath)) {
+  if (!existsSync5(pkgPath)) {
     writeFileSync2(pkgPath, renderPackageJson(manifest));
     return;
   }
@@ -1940,8 +1964,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     inputs: [],
     commands: []
   };
-  if (!existsSync4(join4(skillPath, "SKILL.md"))) {
-    writeFileSync2(join4(skillPath, "SKILL.md"), renderSkillMd(next));
+  if (!existsSync5(join5(skillPath, "SKILL.md"))) {
+    writeFileSync2(join5(skillPath, "SKILL.md"), renderSkillMd(next));
   }
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
@@ -2192,7 +2216,7 @@ function inferPackageCommands(pkg, fallbackName) {
   return;
 }
 function readJsonObject(path) {
-  const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+  const parsed = JSON.parse(readFileSync5(path, "utf-8"));
   if (!isRecord2(parsed))
     throw new Error(`${basename(path)} must contain a JSON object`);
   return parsed;
@@ -2233,33 +2257,36 @@ var LEGACY_CUSTOM_DIRNAME = "custom";
 function getPortableSkillsRoot(options = {}) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join5(options.homeDir, ".hasna", "skills") : getDataDir();
-  const installed = join5(appDir, INSTALLED_SKILLS_DIRNAME);
+  const appDir = options.homeDir ? join6(options.homeDir, ".hasna", "skills") : getDataDir();
+  const cache = join6(appDir, SKILLS_CACHE_DIRNAME);
+  if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
+    return cache;
+  const installed = join6(appDir, INSTALLED_SKILLS_DIRNAME);
   migrateLegacySkillLayout(appDir, installed);
   return installed;
 }
 function looksLikeSkillDirectory(path) {
   if (!safeIsDirectory(path))
     return false;
-  return existsSync5(join5(path, "SKILL.md")) || existsSync5(join5(path, "skill.json")) || existsSync5(join5(path, "package.json"));
+  return existsSync6(join6(path, "SKILL.md")) || existsSync6(join6(path, "skill.json")) || existsSync6(join6(path, "package.json"));
 }
 function migrateLegacySkillLayout(appDir, installed) {
   if (!safeIsDirectory(appDir))
     return;
   const candidates = [];
   try {
-    for (const entry of readdirSync4(appDir)) {
+    for (const entry of readdirSync5(appDir)) {
       if (entry.startsWith(".") || entry === INSTALLED_SKILLS_DIRNAME)
         continue;
-      const path = join5(appDir, entry);
+      const path = join6(appDir, entry);
       if (entry === LEGACY_CUSTOM_DIRNAME) {
         if (!safeIsDirectory(path))
           continue;
         try {
-          for (const nested of readdirSync4(path)) {
+          for (const nested of readdirSync5(path)) {
             if (nested.startsWith("."))
               continue;
-            const nestedPath = join5(path, nested);
+            const nestedPath = join6(path, nested);
             if (looksLikeSkillDirectory(nestedPath))
               candidates.push({ from: nestedPath, name: nested });
           }
@@ -2273,10 +2300,10 @@ function migrateLegacySkillLayout(appDir, installed) {
     return;
   }
   for (const { from, name } of candidates) {
-    const target = join5(installed, name);
-    if (existsSync5(target))
+    const target = join6(installed, name);
+    if (existsSync6(target))
       continue;
-    const staging = join5(installed, `.migrating-${name}-${process.pid}`);
+    const staging = join6(installed, `.migrating-${name}-${process.pid}`);
     try {
       rmSync(staging, { recursive: true, force: true });
       cpSync2(from, staging, { recursive: true, errorOnExist: false });
@@ -2289,7 +2316,7 @@ function migrateLegacySkillLayout(appDir, installed) {
   }
 }
 function getPortableSkillPath(name, options = {}) {
-  return join5(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join6(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -2299,7 +2326,7 @@ function findPortableSkill(name, options = {}) {
     return null;
   }
   const path = getPortableSkillPath(normalized, options);
-  if (!existsSync5(path) || !statSync5(path).isDirectory())
+  if (!existsSync6(path) || !statSync6(path).isDirectory())
     return null;
   try {
     return summarizePortableSkill(path, normalized);
@@ -2312,10 +2339,10 @@ function listPortableSkills(options = {}) {
   if (!safeIsDirectory(root))
     return [];
   const skills = [];
-  for (const entry of readdirSync4(root).sort()) {
+  for (const entry of readdirSync5(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join5(root, entry);
+    const path = join6(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -2337,7 +2364,8 @@ function listPortableSkillMetas(options = {}) {
       tags: manifest.tags || ["custom"],
       version: skill.version,
       ...manifest.kind ? { kind: manifest.kind } : {},
-      source: "custom"
+      source: "custom",
+      ...isHostedMetadataSkillDir(skill.path) ? { serverOwned: true } : {}
     };
   });
 }
@@ -2348,8 +2376,8 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizePortableSkillName(name);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join5(root, skillName);
-  if (existsSync5(skillPath)) {
+  const skillPath = join6(root, skillName);
+  if (existsSync6(skillPath)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${skillPath}`);
     rmSync(skillPath, { recursive: true, force: true });
@@ -2367,7 +2395,7 @@ function scaffoldPortableSkill(name, options = {}) {
 }
 function portPortableSkillDirectory(sourceDir, options = {}) {
   const absoluteSource = normalize2(sourceDir);
-  if (!existsSync5(absoluteSource) || !statSync5(absoluteSource).isDirectory()) {
+  if (!existsSync6(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Import directory not found: ${sourceDir}`);
   }
   const continueOnError = options.continueOnError ?? true;
@@ -2378,9 +2406,9 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
   const imported = [];
   const skipped = [];
-  const entries = readdirSync4(absoluteSource, { withFileTypes: true }).map((entry) => entry.name).filter((entryName) => !entryName.startsWith(".")).sort();
+  const entries = readdirSync5(absoluteSource, { withFileTypes: true }).map((entry) => entry.name).filter((entryName) => !entryName.startsWith(".")).sort();
   for (const entryName of entries) {
-    const childPath = join5(absoluteSource, entryName);
+    const childPath = join6(absoluteSource, entryName);
     if (!safeIsDirectory(childPath))
       continue;
     if (!isSkillCandidate(childPath)) {
@@ -2409,11 +2437,11 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
   };
 }
 function isSkillCandidate(dir) {
-  return existsSync5(join5(dir, "SKILL.md")) || existsSync5(join5(dir, "skill.json")) || existsSync5(join5(dir, "package.json"));
+  return existsSync6(join6(dir, "SKILL.md")) || existsSync6(join6(dir, "skill.json")) || existsSync6(join6(dir, "package.json"));
 }
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize2(sourcePath);
-  if (!existsSync5(absoluteSource) || !statSync5(absoluteSource).isDirectory()) {
+  if (!existsSync6(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
     throw new Error(`Skill source directory not found: ${sourcePath}`);
   }
   const inferred = readPortableSkillManifest(absoluteSource, basename2(absoluteSource));
@@ -2425,8 +2453,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 = join5(root, skillName);
-  if (existsSync5(destination)) {
+  const destination = join6(root, skillName);
+  if (existsSync6(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync(destination, { recursive: true, force: true });
@@ -2448,19 +2476,10 @@ function safeNormalizeName(name) {
     return;
   }
 }
-function writeCorpusSkill(input, options = {}) {
-  const name = normalizePortableSkillName(input.name);
-  const root = getPortableSkillsRoot(options);
-  const skillPath = join5(root, name);
-  const created = !existsSync5(skillPath);
-  mkdirSync3(skillPath, { recursive: true });
-  const skillMd = input.skillMd.endsWith(`
-`) ? input.skillMd : `${input.skillMd}
-`;
-  writeFileSync3(join5(skillPath, "SKILL.md"), skillMd);
+function buildCorpusManifest(input, name) {
   const frontmatter = parseSkillFrontmatter(input.skillMd) ?? undefined;
   const kind = input.meta?.kind ?? parseSkillKind(frontmatter?.kind) ?? "instruction";
-  const manifest = {
+  return {
     $schema: PORTABLE_SKILL_SCHEMA,
     standard: PORTABLE_SKILL_STANDARD,
     name,
@@ -2473,19 +2492,60 @@ function writeCorpusSkill(input, options = {}) {
     inputs: [],
     commands: []
   };
+}
+function writeCorpusSkill(input, options = {}) {
+  const name = normalizePortableSkillName(input.name);
+  const root = getPortableSkillsRoot(options);
+  const skillPath = join6(root, name);
+  const created = !existsSync6(skillPath);
+  mkdirSync3(skillPath, { recursive: true });
+  writeFileSync3(join6(skillPath, "SKILL.md"), input.skillMd);
+  const manifest = buildCorpusManifest(input, name);
   writeSkillJsonWithHash(skillPath, manifest);
   return { name, path: skillPath, manifest, created };
 }
+function installCorpusSkillAtomically(input, options = {}) {
+  const name = normalizePortableSkillName(input.name);
+  const root = getPortableSkillsRoot(options);
+  const target = join6(root, name);
+  const created = !existsSync6(target);
+  mkdirSync3(root, { recursive: true });
+  const staging = mkdtempSync(join6(root, `.pull-${name}-`));
+  let moved = false;
+  let backup = null;
+  try {
+    writeFileSync3(join6(staging, "SKILL.md"), input.skillMd);
+    const manifest = buildCorpusManifest(input, name);
+    writeSkillJsonWithHash(staging, manifest);
+    if (existsSync6(target)) {
+      backup = mkdtempSync(join6(root, `.pull-backup-${name}-`));
+      renameSync(target, join6(backup, name));
+      moved = true;
+    }
+    renameSync(staging, target);
+    if (moved && backup)
+      rmSync(backup, { recursive: true, force: true });
+    return { name, path: target, manifest, created };
+  } catch (error) {
+    rmSync(staging, { recursive: true, force: true });
+    if (moved && backup && existsSync6(join6(backup, name))) {
+      try {
+        renameSync(join6(backup, name), target);
+      } catch {}
+    }
+    throw error;
+  }
+}
 function validatePortableSkillDirectory(name, skillPath) {
   const normalizedName = normalizePortableSkillName(name);
   const base = validateSkillDirectory(normalizedName, skillPath);
   const issues = [...base.issues];
   const warnings = [...base.warnings];
   let manifest;
-  if (existsSync5(skillPath)) {
-    const skillJsonPath = join5(skillPath, "skill.json");
-    const skillMdPath = join5(skillPath, "SKILL.md");
-    if (!existsSync5(skillJsonPath) && !existsSync5(skillMdPath)) {
+  if (existsSync6(skillPath)) {
+    const skillJsonPath = join6(skillPath, "skill.json");
+    const skillMdPath = join6(skillPath, "SKILL.md");
+    if (!existsSync6(skillJsonPath) && !existsSync6(skillMdPath)) {
       add3(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
     try {
@@ -2504,7 +2564,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add3(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync5(join5(skillPath, "skill.json")),
+        strict: existsSync6(join6(skillPath, "skill.json")),
         skillPath
       });
       for (const issue of contractIssues)
@@ -2540,10 +2600,10 @@ function validatePortableSkillDirectory(name, skillPath) {
               add3(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
               continue;
             }
-            const entryPath = join5(skillPath, command.entry);
-            if (!existsSync5(entryPath))
+            const entryPath = join6(skillPath, command.entry);
+            if (!existsSync6(entryPath))
               add3(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
-            else if (statSync5(entryPath).isDirectory())
+            else if (statSync6(entryPath).isDirectory())
               add3(issues, "portable.command_entry_directory", `Command '${command.name}' entry '${command.entry}' must be a file`);
           }
         }
@@ -2551,7 +2611,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error) {
       add3(issues, "portable.manifest_invalid", error.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync5(join5(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync6(join6(skillPath, "AGENTS.md"))) {
       add3(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -2587,13 +2647,13 @@ async function runPortableSkill(name, args, options = {}) {
   if (!isSafeRelativePath2(command.entry)) {
     return { exitCode: 1, error: `Portable skill '${name}' command entry is unsafe` };
   }
-  const entryPath = join5(skill.path, command.entry);
-  if (!existsSync5(entryPath)) {
+  const entryPath = join6(skill.path, command.entry);
+  if (!existsSync6(entryPath)) {
     return { exitCode: 1, error: `Entry point '${command.entry}' not found in portable skill '${name}'` };
   }
-  const pkgPath = join5(skill.path, "package.json");
-  const nodeModules = join5(skill.path, "node_modules");
-  if (existsSync5(pkgPath) && !existsSync5(nodeModules) && hasPackageDependencies(pkgPath)) {
+  const pkgPath = join6(skill.path, "package.json");
+  const nodeModules = join6(skill.path, "node_modules");
+  if (existsSync6(pkgPath) && !existsSync6(nodeModules) && hasPackageDependencies(pkgPath)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skill.path,
       stdout: "pipe",
@@ -2633,7 +2693,7 @@ function summarizePortableSkill(skillPath, fallbackName) {
 }
 function safeIsDirectory(path) {
   try {
-    return statSync5(path).isDirectory();
+    return statSync6(path).isDirectory();
   } catch {
     return false;
   }
@@ -2862,20 +2922,20 @@ function parseSkillMdFrontmatter(content) {
   return Object.keys(result).length > 0 ? result : null;
 }
 function discoverSkillsInDir(dir, source = "custom") {
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return [];
   const result = [];
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join6(dir, entry.name, "SKILL.md");
-      if (!existsSync6(skillMdPath))
+      const skillMdPath = join7(dir, entry.name, "SKILL.md");
+      if (!existsSync7(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync5(skillMdPath, "utf-8");
+        content = readFileSync6(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -2890,6 +2950,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
+        ...isHostedMetadataSkillDir(join7(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -2898,20 +2959,20 @@ function discoverSkillsInDir(dir, source = "custom") {
 }
 function findExtensionSkillPath(name) {
   const config = loadConfig();
-  if (!config.extensionsDir || !existsSync6(config.extensionsDir))
+  if (!config.extensionsDir || !existsSync7(config.extensionsDir))
     return null;
   try {
-    const entries = readdirSync5(config.extensionsDir, { withFileTypes: true });
+    const entries = readdirSync6(config.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join6(config.extensionsDir, entry.name);
-      const skillMdPath = join6(skillDir, "SKILL.md");
-      if (!existsSync6(skillMdPath))
+      const skillDir = join7(config.extensionsDir, entry.name);
+      const skillMdPath = join7(skillDir, "SKILL.md");
+      if (!existsSync7(skillMdPath))
         continue;
       let content;
       try {
-        content = readFileSync5(skillMdPath, "utf-8");
+        content = readFileSync6(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -2944,7 +3005,7 @@ function loadRegistry(cwd) {
   const official = SKILLS.map((s) => ({ ...s, source: "official" }));
   const extensions = config.extensionsDir ? discoverSkillsInDir(config.extensionsDir, "extension") : [];
   const portableCustom = listPortableSkillMetas();
-  const legacyCustom = discoverSkillsInDir(join6(dataDir, "custom"));
+  const legacyCustom = discoverSkillsInDir(join7(dataDir, "custom"));
   const globalCustom = mergeCustomSkills([...legacyCustom, ...portableCustom]);
   registryCache = mergeSkillRegistryLists(official, extensions, globalCustom);
   registryCacheTime = now;
@@ -2991,7 +3052,7 @@ function getAllTags() {
   return Array.from(tagSet).sort();
 }
 // src/lib/installer.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9, rmSync as rmSync3 } from "fs";
 import { dirname as dirname5, join as join10 } from "path";
 import { homedir as homedir3 } from "os";
 import { fileURLToPath } from "url";
@@ -3000,36 +3061,19 @@ import { fileURLToPath } from "url";
 import {
   cpSync as cpSync3,
   existsSync as existsSync8,
-  mkdirSync as mkdirSync5,
-  mkdtempSync,
-  readFileSync as readFileSync6,
+  mkdirSync as mkdirSync4,
+  mkdtempSync as mkdtempSync2,
+  readFileSync as readFileSync7,
   readdirSync as readdirSync7,
-  renameSync as renameSync3,
-  rmSync as rmSync3,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
   statSync as statSync7,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir2 } from "os";
 import { basename as basename3, dirname as dirname4, join as join8 } from "path";
-
 // src/lib/home-migration.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync6, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
-var SKILLS_CACHE_DIRNAME = "skills";
-var LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
-function layoutMigrationRecordPath(appDir) {
-  return join7(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD);
-}
-function isOwnerLayoutMigrated(appDir) {
-  return existsSync7(layoutMigrationRecordPath(appDir));
-}
 function resolveCorpusRoot(options = {}) {
-  if (options.rootDir)
-    return options.rootDir;
-  const appDir = options.homeDir ? join7(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache = join7(appDir, SKILLS_CACHE_DIRNAME);
-  if (isOwnerLayoutMigrated(appDir) && existsSync7(cache))
-    return cache;
   return getPortableSkillsRoot(options);
 }
 
@@ -3075,6 +3119,10 @@ ${lines.join(`
 ---
 ${body}`;
 }
+var POINTER_MARKER_PHRASE = "This is an executable skill from the @hasna/skills catalog";
+function isPointerSkillMd(markdown) {
+  return markdown.includes(POINTER_MARKER_PHRASE) && /^kind:\s*executable\b/m.test(markdown);
+}
 function pointerSkillMd(name, description) {
   const display = name.replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
   return [
@@ -3100,7 +3148,7 @@ function resolveSyncCorpus(options = {}) {
   if (explicit) {
     const roots = packageSourceRoots(explicit);
     if (roots.length === 0) {
-      throw new Error(`SKILLS_SOURCE '${explicit}' contains no skills: expected a corpus directory or a package root with skills/ and/or agent-skills/`);
+      throw new Error(`SKILLS_SOURCE '${explicit}' contains no skills: expected a corpus directory or a package root with skills/`);
     }
     return { roots, source: "source" };
   }
@@ -3108,7 +3156,7 @@ function resolveSyncCorpus(options = {}) {
 }
 function packageSourceRoots(source) {
   const roots = [];
-  for (const sub of ["skills", "agent-skills"]) {
+  for (const sub of ["skills"]) {
     const candidate = join8(source, sub);
     if (existsSync8(candidate) && isDirectory(candidate))
       roots.push(candidate);
@@ -3177,7 +3225,7 @@ function syncSkillsToAgents(options = {}) {
   }
   for (const skill of targets) {
     const manifest = readPortableSkillManifest(skill.path, skill.name);
-    const kind = manifest.kind ?? "executable";
+    const kind = manifest.kind;
     const sourceMd = sourceSkillMd(skill.path, skill.name, manifest.description, kind, source === "source");
     for (const agent of agents) {
       const adapted = adaptSkillMdForAgent(sourceMd, agent);
@@ -3233,12 +3281,27 @@ function writeManagedSkillDir(dir, skillMd, options) {
       reason: "an unmanaged SKILL.md already exists here (hand-authored); pass --force to overwrite"
     };
   }
+  if (dirExists && managed && hasSkillMd && !options.force && isPointerSkillMd(skillMd)) {
+    let existingIsStub = false;
+    try {
+      existingIsStub = isPointerSkillMd(readFileSync7(skillMdPath, "utf-8"));
+    } catch {
+      existingIsStub = false;
+    }
+    if (!existingIsStub) {
+      return {
+        action: "skip",
+        path: skillMdPath,
+        reason: "refusing to replace a content-bearing managed home with an executable pointer stub (the corpus entry lacks kind: instruction); pass --force to overwrite"
+      };
+    }
+  }
   const action = dirExists ? "update" : "create";
   if (options.dryRun)
     return { action, path: skillMdPath };
   const parentDir = dirname4(dir);
-  mkdirSync5(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync(join8(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
+  mkdirSync4(parentDir, { recursive: true });
+  const transactionDir = mkdtempSync2(join8(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
   const candidateDir = join8(transactionDir, "candidate");
   const backupDir = join8(transactionDir, "backup");
   const candidateSkillMdPath = join8(candidateDir, "SKILL.md");
@@ -3249,19 +3312,19 @@ function writeManagedSkillDir(dir, skillMd, options) {
     source: options.source ?? "corpus",
     syncedAt: new Date().toISOString()
   };
-  const renameDirectory = options.renameDirectory ?? renameSync3;
+  const renameDirectory = options.renameDirectory ?? renameSync2;
   let originalMoved = false;
   let preserveTransaction = false;
   try {
     if (options.resourceDir) {
       cpSync3(options.resourceDir, candidateDir, { recursive: true, force: true });
     } else {
-      mkdirSync5(candidateDir, { recursive: true });
+      mkdirSync4(candidateDir, { recursive: true });
     }
-    writeFileSync5(candidateSkillMdPath, skillMd.endsWith(`
+    writeFileSync4(candidateSkillMdPath, skillMd.endsWith(`
 `) ? skillMd : `${skillMd}
 `);
-    writeFileSync5(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
+    writeFileSync4(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
 `);
     if (dirExists) {
       originalMoved = true;
@@ -3272,7 +3335,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
     if (originalMoved && existsSync8(backupDir)) {
       try {
         if (existsSync8(dir))
-          rmSync3(dir, { recursive: true, force: true });
+          rmSync2(dir, { recursive: true, force: true });
         renameDirectory(backupDir, dir);
         originalMoved = false;
       } catch (rollbackError) {
@@ -3284,7 +3347,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
   } finally {
     if (!preserveTransaction) {
       try {
-        rmSync3(transactionDir, { recursive: true, force: true });
+        rmSync2(transactionDir, { recursive: true, force: true });
       } catch {}
     }
   }
@@ -3294,14 +3357,14 @@ function removeManagedAgentSkill(skill, agent, homeDir = homedir2()) {
   const dir = join8(agentGlobalSkillsDir(agent, homeDir), skill);
   if (!existsSync8(join8(dir, SYNC_MARKER_FILE)))
     return false;
-  rmSync3(dir, { recursive: true, force: true });
+  rmSync2(dir, { recursive: true, force: true });
   return true;
 }
 function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = false) {
-  if (kind === "instruction" || preferBundledDocs) {
+  if (kind === undefined || kind === "instruction" || preferBundledDocs) {
     const skillMdPath = join8(skillPath, "SKILL.md");
     if (existsSync8(skillMdPath))
-      return readFileSync6(skillMdPath, "utf-8");
+      return readFileSync7(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -3331,7 +3394,7 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { join as join9 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
@@ -3357,7 +3420,7 @@ function loadProjectConfig(targetDir = process.cwd()) {
   if (!existsSync9(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync7(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync8(path, "utf-8")));
   } catch {
     return null;
   }
@@ -3378,9 +3441,9 @@ function ensureProjectConfig(targetDir = process.cwd()) {
 }
 function saveProjectConfig(config, targetDir = process.cwd()) {
   const dir = getProjectStateDir(targetDir);
-  mkdirSync6(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const normalized = normalizeProjectConfig({ ...config, updatedAt: new Date().toISOString() });
-  writeFileSync6(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
+  writeFileSync5(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
 `);
 }
 function pinProjectSkill(name, details = {}, targetDir = process.cwd()) {
@@ -3559,7 +3622,7 @@ function createLocalSkillManifest(name, generateSkillMd) {
   let skillMd = "";
   const skillMdPath = join10(sourcePath, "SKILL.md");
   if (existsSync10(skillMdPath)) {
-    skillMd = readFileSync8(skillMdPath, "utf-8");
+    skillMd = readFileSync9(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -3670,14 +3733,14 @@ function removeSkillForAgent(name, options) {
   const dir = getAgentSkillPath(canonicalName, options.agent, scope, options.projectDir);
   if (!existsSync10(join10(dir, SYNC_MARKER_FILE)))
     return false;
-  rmSync4(dir, { recursive: true, force: true });
+  rmSync3(dir, { recursive: true, force: true });
   return true;
 }
 function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
   const skillMdPath = join10(sourcePath, "SKILL.md");
   if (existsSync10(skillMdPath))
-    return readFileSync8(skillMdPath, "utf-8");
+    return readFileSync9(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -3733,21 +3796,21 @@ function readBundledSkillVersion(name) {
   if (!existsSync10(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync10(path) ? readFileSync8(path, "utf-8") : null;
+  return existsSync10(path) ? readFileSync9(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
 }
 // src/lib/run-state.ts
 import { createHash as createHash2, randomBytes } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync9, readdirSync as readdirSync8, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync as readdirSync8, statSync as statSync8, writeFileSync as writeFileSync6 } from "fs";
 import { extname, join as join11, relative as relative2 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now = new Date;
@@ -3758,9 +3821,9 @@ function createSkillRun(params, targetDir = process.cwd()) {
   const runDir = join11(root, "runs", day, id);
   const logsDir = join11(runDir, "logs");
   const exportDir = join11(root, "exports", skillName, id);
-  mkdirSync7(logsDir, { recursive: true });
-  mkdirSync7(exportDir, { recursive: true });
-  mkdirSync7(join11(root, "tmp"), { recursive: true });
+  mkdirSync6(logsDir, { recursive: true });
+  mkdirSync6(exportDir, { recursive: true });
+  mkdirSync6(join11(root, "tmp"), { recursive: true });
   const record = {
     id,
     skill: skillName,
@@ -3811,15 +3874,15 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync7(join11(context.logsDir, "stdout.log"), stdout);
-  writeFileSync7(join11(context.logsDir, "stderr.log"), stderr);
+  writeFileSync6(join11(context.logsDir, "stdout.log"), stdout);
+  writeFileSync6(join11(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
   const path = join11(context.runDir, "events.ndjson");
-  const previous = existsSync11(path) ? readFileSync9(path, "utf-8") : "";
-  writeFileSync7(path, previous + line);
+  const previous = existsSync11(path) ? readFileSync10(path, "utf-8") : "";
+  writeFileSync6(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   const runsRoot = join11(getProjectStateDir(targetDir), "runs");
@@ -3855,11 +3918,11 @@ function getRunExportDir(runId, skill, targetDir = process.cwd()) {
   return join11(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
 }
 function writeRunRecord(context) {
-  writeFileSync7(join11(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync6(join11(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync7(join11(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync6(join11(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
@@ -3868,7 +3931,7 @@ function collectRunArtifacts(context) {
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
     const stat = statSync8(path);
-    const bytes = readFileSync9(path);
+    const bytes = readFileSync10(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
@@ -3883,7 +3946,7 @@ function readRunRecord(runDir) {
   if (!existsSync11(path))
     return null;
   try {
-    return JSON.parse(readFileSync9(path, "utf-8"));
+    return JSON.parse(readFileSync10(path, "utf-8"));
   } catch {
     return null;
   }
@@ -3937,7 +4000,7 @@ function mimeForPath(path) {
   }
 }
 // src/lib/skillinfo.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
 import { join as join12 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
@@ -3946,7 +4009,7 @@ function isInstructionSkillDir(skillPath, meta) {
   if (!existsSync12(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync10(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync11(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -4031,7 +4094,7 @@ function getSkillRequirements(name) {
   const pkgPath = join12(skillPath, "package.json");
   if (existsSync12(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       dependencies = pkg.dependencies || {};
     } catch {}
   }
@@ -4064,7 +4127,7 @@ async function runSkill(name, args, options = {}) {
   }
   let entryPoint;
   try {
-    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint = binValues[0];
@@ -4170,7 +4233,7 @@ function generateSkillMd(name) {
   const pkgPath = join12(skillPath, "package.json");
   if (existsSync12(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -4246,7 +4309,7 @@ function extractEnvVars(text) {
 function readIfExists(path) {
   try {
     if (existsSync12(path)) {
-      return readFileSync10(path, "utf-8");
+      return readFileSync11(path, "utf-8");
     }
   } catch {}
   return null;
@@ -8249,18 +8312,22 @@ function requireApiUrl(action = "This command", config, env) {
 }
 
 // src/lib/auth-store.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8, unlinkSync } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
 import { homedir as homedir4 } from "os";
-var AUTH_DIR = join13(homedir4(), ".hasna", "skills");
-var AUTH_FILE = join13(AUTH_DIR, "auth.json");
-var LEGACY_AUTH_FILE = join13(homedir4(), ".skills", "auth.json");
+function getAuthFilePath() {
+  return join13(getDataDir(), "auth.json");
+}
+function legacyAuthFilePath() {
+  return join13(process.env["HOME"] || process.env["USERPROFILE"] || homedir4(), ".skills", "auth.json");
+}
 var cachedConfig;
 function getAuthConfig() {
   if (cachedConfig !== undefined)
     return cachedConfig;
   try {
-    const raw = readFileSync11(existsSync13(AUTH_FILE) ? AUTH_FILE : LEGACY_AUTH_FILE, "utf-8");
+    const file = existsSync13(getAuthFilePath()) ? getAuthFilePath() : legacyAuthFilePath();
+    const raw = readFileSync12(file, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiKey) {
       cachedConfig = null;
@@ -9084,6 +9151,30 @@ function pickNumber(record, key) {
 }
 
 // src/lib/remote-client.ts
+class RemoteRouteUnsupportedError extends Error {
+  path;
+  status;
+  instance;
+  constructor(path, status, instance) {
+    super(`The configured Skills instance does not support ${path} (HTTP ${status}). ` + `The instance at ${instance} predates this client feature \u2014 upgrade the server, or ` + `use a client version that matches it.`);
+    this.path = path;
+    this.status = status;
+    this.instance = instance;
+    this.name = "RemoteRouteUnsupportedError";
+  }
+}
+
+class RemoteRequestError extends Error {
+  path;
+  status;
+  constructor(path, status, statusText) {
+    super(`Remote request to ${path} failed: HTTP ${status}${statusText ? ` ${statusText}` : ""}`);
+    this.path = path;
+    this.status = status;
+    this.name = "RemoteRequestError";
+  }
+}
+
 class RemoteSkillsClient {
   apiUrl;
   apiKey;
@@ -9101,6 +9192,20 @@ class RemoteSkillsClient {
       }
     });
   }
+  async requestNewRoute(path, options, opts = {}) {
+    const response = await this.request(path, options);
+    const routePath = path.split("?")[0];
+    if (response.status === 404 || response.status === 405) {
+      if (response.status === 404 && opts.domainNotFoundCodes?.length && await responseBodyCarriesCode(response, opts.domainNotFoundCodes)) {
+        return response;
+      }
+      throw new RemoteRouteUnsupportedError(routePath, response.status, this.apiUrl);
+    }
+    if (!response.ok) {
+      throw new RemoteRequestError(routePath, response.status, response.statusText);
+    }
+    return response;
+  }
   async listSkills() {
     const res = await this.request("/api/v1/skills");
     return res.json();
@@ -9117,6 +9222,14 @@ class RemoteSkillsClient {
       return null;
     return res.json();
   }
+  async getSkillStatus(slug) {
+    const res = await this.request(`/api/v1/skills/${encodeURIComponent(slug)}`, { method: "GET" });
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {}
+    return { status: res.status, body };
+  }
   async submitRun(slug, input, args) {
     const res = await this.request(`/api/v1/runs/${slug}`, {
       method: "POST",
@@ -9150,15 +9263,18 @@ class RemoteSkillsClient {
       method: "GET"
     });
   }
-  async publishSkill(manifest, bundle) {
+  async publishSkill(manifest, bundle, ifMatch) {
     const form = new FormData;
     form.set("manifest", JSON.stringify(manifest));
     if (bundle) {
       form.set("bundle", new Blob([bundle], { type: "application/gzip" }), `${String(manifest.slug ?? "skill")}.tar.gz`);
     }
+    const headers = { Authorization: `Bearer ${this.apiKey}` };
+    if (ifMatch)
+      headers["If-Match"] = ifMatch;
     return fetch(`${this.apiUrl}/api/v1/skills`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${this.apiKey}` },
+      headers,
       body: form
     });
   }
@@ -9174,6 +9290,135 @@ class RemoteSkillsClient {
       return null;
     return response;
   }
+  async listPins() {
+    const response = await this.requestNewRoute("/api/v1/pins");
+    return normalizePinList(await response.json());
+  }
+  async pin(slug, metadata) {
+    const path = `/api/v1/pins/${encodeURIComponent(slug)}`;
+    const response = await this.requestNewRoute(path, {
+      method: "PUT",
+      body: JSON.stringify({ ...metadata ? { metadata } : {} })
+    });
+    return normalizePin(await response.json());
+  }
+  async unpin(slug) {
+    const path = `/api/v1/pins/${encodeURIComponent(slug)}`;
+    const response = await this.requestNewRoute(path, { method: "DELETE" }, { domainNotFoundCodes: ["PIN_NOT_FOUND"] });
+    return response.status !== 404;
+  }
+  async listTags() {
+    const response = await this.requestNewRoute("/api/v1/tags");
+    const payload = await response.json();
+    if (!Array.isArray(payload)) {
+      throw new Error("Remote tags payload did not match the expected contract (expected an array of tag names)");
+    }
+    for (const tag of payload) {
+      if (typeof tag !== "string" || tag.trim().length === 0) {
+        throw new Error("Remote tags payload did not match the expected contract (every element must be a non-empty tag name)");
+      }
+    }
+    return payload;
+  }
+  async skillsByTag(tag) {
+    const path = `/api/v1/tags/${encodeURIComponent(tag)}/skills`;
+    const response = await this.requestNewRoute(path);
+    return normalizeSkillSummaryList(await response.json());
+  }
+  async listUpdatedSince(since, options = {}) {
+    const params = new URLSearchParams({ since });
+    if (options.cursor)
+      params.set("cursor", options.cursor);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    const response = await this.requestNewRoute(`/api/v1/skills/updated?${params.toString()}`);
+    return normalizeUpdatedSincePage(await response.json());
+  }
+}
+function requireOptionalString(record, field) {
+  if (record[field] === undefined)
+    return;
+  if (typeof record[field] !== "string") {
+    throw new Error(`Remote payload did not match the expected contract (${field} must be a string when present)`);
+  }
+  return record[field];
+}
+function normalizePin(entry) {
+  if (!entry || typeof entry !== "object") {
+    throw new Error("Remote pin payload did not match the expected contract (expected an object)");
+  }
+  const record = entry;
+  const slug = typeof record.slug === "string" && record.slug.trim() ? record.slug.trim() : undefined;
+  if (!slug) {
+    throw new Error("Remote pin payload did not match the expected contract (missing slug)");
+  }
+  let metadata;
+  if (record.metadata !== undefined) {
+    if (!record.metadata || typeof record.metadata !== "object" || Array.isArray(record.metadata)) {
+      throw new Error("Remote pin payload did not match the expected contract (metadata must be a JSON object when present)");
+    }
+    metadata = record.metadata;
+  }
+  const pinnedAt = requireOptionalString(record, "pinnedAt");
+  return {
+    slug,
+    ...pinnedAt !== undefined ? { pinnedAt } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function normalizePinList(payload) {
+  if (!Array.isArray(payload)) {
+    throw new Error("Remote pins payload did not match the expected contract (expected an array of pins)");
+  }
+  return payload.map(normalizePin);
+}
+function normalizeSkillSummary(entry) {
+  if (!entry || typeof entry !== "object") {
+    throw new Error("Remote skill payload did not match the expected contract (expected an object)");
+  }
+  const record = entry;
+  const slug = typeof record.slug === "string" && record.slug.trim() ? record.slug.trim() : undefined;
+  if (!slug) {
+    throw new Error("Remote skill payload did not match the expected contract (missing slug)");
+  }
+  return {
+    slug,
+    ...requireOptionalString(record, "name") !== undefined ? { name: requireOptionalString(record, "name") } : {},
+    ...requireOptionalString(record, "version") !== undefined ? { version: requireOptionalString(record, "version") } : {},
+    ...requireOptionalString(record, "updatedAt") !== undefined ? { updatedAt: requireOptionalString(record, "updatedAt") } : {}
+  };
+}
+function normalizeSkillSummaryList(payload) {
+  if (!Array.isArray(payload)) {
+    throw new Error("Remote skills payload did not match the expected contract (expected an array of skills)");
+  }
+  return payload.map(normalizeSkillSummary);
+}
+async function responseBodyCarriesCode(response, codes) {
+  try {
+    const payload = await response.clone().json();
+    if (!payload || typeof payload !== "object")
+      return false;
+    const code = payload.code;
+    return typeof code === "string" && codes.includes(code);
+  } catch {
+    return false;
+  }
+}
+function normalizeUpdatedSincePage(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("Updated-since payload did not match the expected contract (expected an object)");
+  }
+  const record = payload;
+  if (!Array.isArray(record.skills)) {
+    throw new Error("Updated-since payload did not match the expected contract (missing skills array)");
+  }
+  const skills = record.skills.map(normalizeSkillSummary);
+  const nextCursor = record.nextCursor === undefined || record.nextCursor === null ? null : record.nextCursor;
+  if (nextCursor !== null && typeof nextCursor !== "string") {
+    throw new Error("Updated-since payload did not match the expected contract (nextCursor must be a string or absent)");
+  }
+  return { skills, nextCursor };
 }
 function createRemoteSkillsClient() {
   const apiKey = getApiKey();
@@ -9182,7 +9427,7 @@ function createRemoteSkillsClient() {
   return new RemoteSkillsClient(apiKey);
 }
 // src/lib/scheduler.ts
-import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
 import { join as join14 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
   return join14(targetDir, ".skills", "schedules.json");
@@ -9191,7 +9436,7 @@ function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
   if (existsSync14(path)) {
     try {
-      return JSON.parse(readFileSync12(path, "utf-8"));
+      return JSON.parse(readFileSync13(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
@@ -9200,8 +9445,8 @@ function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
   const dir = join14(targetDir, ".skills");
   if (!existsSync14(dir))
-    mkdirSync9(dir, { recursive: true });
-  writeFileSync9(path, JSON.stringify(data, null, 2));
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync8(path, JSON.stringify(data, null, 2));
 }
 function validateCronField(expr, min, max, label) {
   for (const part of expr.split(",")) {
@@ -9386,11 +9631,34 @@ function recordScheduleRun(id, status, targetDir) {
   saveSchedules(data, targetDir);
 }
 // src/lib/pull.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname6, join as join15 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync14, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname7, join as join15 } from "path";
 
-// src/lib/skill-bundle.ts
+// src/lib/revision.ts
 import { createHash as createHash3 } from "crypto";
+var REVISION_ID_PATTERN = /^[0-9a-f]{64}$/;
+function revisionIdOf(content) {
+  const canonical = JSON.stringify({
+    slug: content.slug,
+    displayName: content.displayName,
+    description: content.description,
+    category: content.category,
+    tags: content.tags,
+    source: content.source,
+    kind: content.kind,
+    version: content.version ?? null,
+    skillMd: content.skillMd ?? null,
+    bundleSha256: content.bundleSha256 ?? null,
+    bundleByteSize: content.bundleByteSize ?? null
+  });
+  return createHash3("sha256").update(canonical).digest("hex");
+}
+function revisionIdOfRecord(record) {
+  return revisionIdOf(record);
+}
+
+// src/lib/skill-bundle.ts
+import { createHash as createHash4 } from "crypto";
 var BLOCK = 512;
 var ANY_SEGMENT_EXCLUDES = new Set([
   ".git",
@@ -9403,6 +9671,7 @@ var ANY_SEGMENT_EXCLUDES = new Set([
   ".docker"
 ]);
 var ROOT_EXCLUDES = new Set(["dist", "build", ".turbo"]);
+var TOOL_SIDECAR_FILENAMES = new Set([".hasna-skills.json"]);
 var CREDENTIAL_FILENAMES = new Set([
   ".npmrc",
   ".pypirc",
@@ -9519,7 +9788,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash3("sha256").update(bytes).digest("hex");
+  return createHash4("sha256").update(bytes).digest("hex");
 }
 function unpackSkillBundle(bundle) {
   return readTar(ownBytes(Bun.gunzipSync(ownBytes(bundle))));
@@ -9598,9 +9867,9 @@ function verifyBundleSignature(bytes, signature, key) {
 // src/lib/pull.ts
 var BUNDLE_DIGEST_HEADER = "X-Skill-Bundle-Sha256";
 var BUNDLE_SIGNATURE_HEADER = "X-Skill-Bundle-Signature";
+var BUNDLE_REVISION_ID_HEADER = "X-Skill-Revision-Id";
+var BUNDLE_REVISION_NUMBER_HEADER = "X-Skill-Revision-Number";
 var PULL_MARKER_FILE = ".hasna-skills.json";
-var SKILLS_CACHE_DIRNAME2 = "skills";
-var LAYOUT_MIGRATION_RECORD2 = ".layout-migration.json";
 
 class PullSkillError extends Error {
   detail;
@@ -9650,6 +9919,15 @@ async function pullOne(client, rawName, corpusOptions, verify) {
     return { name: slug, success: false, error: `Failed to fetch '${slug}': ${error.message}` };
   }
   if (bundleResponse && !bundleResponse.ok) {
+    if (bundleResponse.status === 410) {
+      return reconcileTombstone(slug, corpusOptions);
+    }
+    if (bundleResponse.status === 404) {
+      const marker = readPullMarker(join15(getPortableSkillsRoot(corpusOptions), slug));
+      if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
+        return { name: slug, success: true, purged: true, removed: false };
+      }
+    }
     return {
       name: slug,
       success: false,
@@ -9675,17 +9953,78 @@ async function pullOne(client, rawName, corpusOptions, verify) {
   if (skillMd === null) {
     return { name: slug, success: false, error: `Skill '${slug}' was not found on the configured Skills instance.` };
   }
-  const written = writeCorpusSkill({ name: slug, skillMd, meta }, corpusOptions);
-  writePullMarker(written.path, { skill: slug, version: written.manifest.version });
+  if (!meta?.revisionId) {
+    const marker = readPullMarker(join15(getPortableSkillsRoot(corpusOptions), slug));
+    if (marker && typeof marker.revisionId === "string" && marker.revisionId) {
+      return { name: slug, success: true, purged: true, removed: false };
+    }
+  }
+  let provenRevisionId;
+  try {
+    provenRevisionId = meta?.revisionId ? provenRevision({ ...meta, skillMd }, slug, {}) : undefined;
+  } catch (error) {
+    if (error instanceof PullSkillError) {
+      return { name: slug, success: false, error: error.message };
+    }
+    throw error;
+  }
+  const written = installCorpusSkillAtomically({ name: slug, skillMd, meta }, corpusOptions);
+  writePullMarker(written.path, {
+    skill: slug,
+    version: written.manifest.version,
+    ...provenRevisionId ? { revisionId: provenRevisionId } : {}
+  });
   return {
     name: slug,
     success: true,
     path: written.path,
     kind: written.manifest.kind,
     version: written.manifest.version,
-    created: written.created
+    created: written.created,
+    ...provenRevisionId ? { revisionId: provenRevisionId } : {}
   };
 }
+function provenRevision(meta, slug, bundle) {
+  const declared = meta.revisionId;
+  if (!declared)
+    return "";
+  const source = meta.publishedSource;
+  if (typeof source !== "string" || source.length === 0) {
+    throw new PullSkillError(`Revision proof failed for '${slug}': the instance declared revision '${declared.slice(0, 12)}\u2026' but did not serve the content fields needed to recompute it (publishedSource). Nothing was installed.`);
+  }
+  const recomputed = revisionIdOf({
+    slug,
+    displayName: meta.displayName ?? "",
+    description: meta.description ?? "",
+    category: meta.category ?? "",
+    tags: meta.tags ?? [],
+    source,
+    kind: meta.kind ?? "instruction",
+    ...meta.version ? { version: meta.version } : {},
+    ...typeof meta.skillMd === "string" && meta.skillMd.length > 0 ? { skillMd: meta.skillMd } : {},
+    ...bundle.sha256 ? { bundleSha256: bundle.sha256 } : {},
+    ...bundle.byteSize !== undefined && bundle.byteSize !== null ? { bundleByteSize: bundle.byteSize } : {}
+  });
+  if (recomputed !== declared) {
+    throw new PullSkillError(`Revision proof failed for '${slug}': the instance declared revision '${declared.slice(0, 12)}\u2026' but the served content recomputes to '${recomputed.slice(0, 12)}\u2026'. The declared revision does not identify the content that was received. Nothing was installed.`);
+  }
+  return declared;
+}
+function reconcileTombstone(slug, corpusOptions) {
+  const target = join15(getPortableSkillsRoot(corpusOptions), slug);
+  if (!existsSync15(join15(target, PULL_MARKER_FILE))) {
+    return { name: slug, success: true, tombstoned: true, removed: false, leftInPlace: true };
+  }
+  rmSync4(target, { recursive: true, force: true });
+  return { name: slug, success: true, tombstoned: true, removed: true };
+}
+function readPullMarker(dir) {
+  try {
+    return JSON.parse(readFileSync14(join15(dir, PULL_MARKER_FILE), "utf-8"));
+  } catch {
+    return null;
+  }
+}
 function installVerifiedBundle(slug, response, meta, corpusOptions, verify) {
   return response.arrayBuffer().then((buffer) => {
     const verified = verifyBundleResponseBytes(buffer, response, verify);
@@ -9697,11 +10036,17 @@ function installVerifiedBundle(slug, response, meta, corpusOptions, verify) {
     }
     const version = str(meta?.version) ?? versionFromEntries(entries) ?? "unknown";
     const sourceCommit = sourceCommitFromEntries(entries);
+    const declaredRevision = verified.revisionId ?? meta?.revisionId;
+    if (declaredRevision && meta?.revisionId && verified.revisionId && declaredRevision !== meta.revisionId) {
+      throw new PullSkillError(`Revision proof failed for '${slug}': the bundle header declares '${verified.revisionId.slice(0, 12)}\u2026' but the metadata declares '${meta.revisionId.slice(0, 12)}\u2026'. The instance is inconsistent. Nothing was installed.`);
+    }
+    const provenRevisionId = declaredRevision ? provenRevision(meta ?? {}, slug, { sha256: verified.contentHash, byteSize: verified.bytes.byteLength }) : undefined;
     const installed = installBundleAtomically(slug, entries, corpusOptions, {
       version,
       contentHash: verified.contentHash,
       ...sourceCommit ? { sourceCommit } : {},
-      ...verified.signature ? { signature: verified.signature } : {}
+      ...verified.signature ? { signature: verified.signature } : {},
+      ...provenRevisionId ? { revisionId: provenRevisionId } : {}
     });
     return {
       name: slug,
@@ -9711,6 +10056,7 @@ function installVerifiedBundle(slug, response, meta, corpusOptions, verify) {
       version,
       contentHash: verified.contentHash,
       ...sourceCommit ? { sourceCommit } : {},
+      ...provenRevisionId ? { revisionId: provenRevisionId } : {},
       created: installed.created
     };
   });
@@ -9761,11 +10107,20 @@ function sourceCommitFromEntries(entries) {
 function verifyBundleResponseBytes(buffer, response, verify = {}) {
   const serverHash = response.headers.get(BUNDLE_DIGEST_HEADER);
   const signature = response.headers.get(BUNDLE_SIGNATURE_HEADER);
+  const revisionId = response.headers.get(BUNDLE_REVISION_ID_HEADER);
+  const revisionNumberRaw = response.headers.get(BUNDLE_REVISION_NUMBER_HEADER);
   const bytes = new Uint8Array(buffer.slice(0));
   const contentHash = sha256Hex(bytes);
   if (serverHash && serverHash.toLowerCase() !== contentHash) {
     throw new PullSkillError(`Bundle digest mismatch: the instance declared ${serverHash} but the received bundle hashes to ${contentHash}.`, ["The bundle was tampered with or truncated in transit. Nothing was installed."]);
   }
+  if (revisionId && !REVISION_ID_PATTERN.test(revisionId)) {
+    throw new PullSkillError(`Malformed revision id: the instance declared '${revisionId}', which is not a 64-character lowercase hex sha-256.`, ["The revision headers were tampered with or the instance is broken. Nothing was installed."]);
+  }
+  const revisionNumber = revisionNumberRaw === null ? undefined : Number(revisionNumberRaw);
+  if (revisionNumberRaw !== null && (!Number.isInteger(revisionNumber) || revisionNumber < 0)) {
+    throw new PullSkillError(`Malformed revision number: the instance declared '${revisionNumberRaw}', which is not a non-negative integer.`, ["The revision headers were tampered with or the instance is broken. Nothing was installed."]);
+  }
   if (signature) {
     const key = verify.signingKey;
     if (!key) {
@@ -9778,43 +10133,46 @@ function verifyBundleResponseBytes(buffer, response, verify = {}) {
     bytes,
     contentHash,
     ...serverHash ? { serverHash } : {},
-    ...signature ? { signature } : {}
+    ...signature ? { signature } : {},
+    ...revisionId ? { revisionId } : {},
+    ...revisionNumberRaw === null || revisionNumber === undefined ? {} : { revisionNumber }
   };
 }
 function installBundleAtomically(name, entries, options = {}, marker = {}) {
   const root = getPortableSkillsRoot(options);
-  mkdirSync10(root, { recursive: true });
+  mkdirSync9(root, { recursive: true });
   const target = join15(root, name);
   const created = !existsSync15(target);
-  const staging = mkdtempSync2(join15(root, `.pull-${name}-`));
+  const staging = mkdtempSync3(join15(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
     for (const entry of entries) {
       const destination = join15(staging, entry.path);
-      mkdirSync10(dirname6(destination), { recursive: true });
-      writeFileSync10(destination, entry.bytes, { mode: entry.mode });
+      mkdirSync9(dirname7(destination), { recursive: true });
+      writeFileSync9(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
       skill: name,
       ...marker.version ? { version: marker.version } : {},
       ...marker.contentHash ? { contentHash: marker.contentHash } : {},
       ...marker.sourceCommit ? { sourceCommit: marker.sourceCommit } : {},
-      ...marker.signature ? { signature: marker.signature } : {}
+      ...marker.signature ? { signature: marker.signature } : {},
+      ...marker.revisionId ? { revisionId: marker.revisionId } : {}
     });
     if (existsSync15(target)) {
-      backup = mkdtempSync2(join15(root, `.pull-backup-${name}-`));
-      renameSync4(target, join15(backup, name));
+      backup = mkdtempSync3(join15(root, `.pull-backup-${name}-`));
+      renameSync3(target, join15(backup, name));
       moved = true;
     }
-    renameSync4(staging, target);
+    renameSync3(staging, target);
     if (moved && backup)
-      rmSync5(backup, { recursive: true, force: true });
+      rmSync4(backup, { recursive: true, force: true });
   } catch (error) {
-    rmSync5(staging, { recursive: true, force: true });
+    rmSync4(staging, { recursive: true, force: true });
     if (moved && backup && existsSync15(join15(backup, name))) {
       try {
-        renameSync4(join15(backup, name), target);
+        renameSync3(join15(backup, name), target);
       } catch {}
     }
     throw error;
@@ -9825,14 +10183,15 @@ function writePullMarker(dir, record) {
   const marker = {
     managedBy: "@hasna/skills",
     skill: record.skill,
-    source: "pull",
+    source: record.source ?? "pull",
     ...record.version ? { version: record.version } : {},
     ...record.contentHash ? { contentHash: record.contentHash } : {},
     ...record.sourceCommit ? { sourceCommit: record.sourceCommit } : {},
     ...record.signature ? { signature: record.signature } : {},
+    ...record.revisionId ? { revisionId: record.revisionId } : {},
     syncedAt: new Date().toISOString()
   };
-  writeFileSync10(join15(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+  writeFileSync9(join15(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function safeMeta(client, slug) {
@@ -9853,20 +10212,14 @@ async function safeMeta(client, slug) {
     ...str(record.category) ? { category: str(record.category) } : {},
     ...tags && tags.length ? { tags } : {},
     ...str(record.version) ? { version: str(record.version) } : {},
-    ...kind ? { kind } : {}
+    ...kind ? { kind } : {},
+    ...REVISION_ID_PATTERN.test(str(record.revisionId) ?? "") ? { revisionId: str(record.revisionId) } : {},
+    ...typeof record.skillMd === "string" && record.skillMd.length > 0 ? { skillMd: record.skillMd } : {},
+    ...str(record.publishedSource) ? { publishedSource: str(record.publishedSource) } : {}
   };
 }
 function pickCorpusOptions(options) {
-  return { rootDir: resolvePullCorpusRoot(options) };
-}
-function resolvePullCorpusRoot(options) {
-  if (options.rootDir)
-    return options.rootDir;
-  const appDir = options.homeDir ? join15(options.homeDir, ".hasna", "skills") : getDataDir();
-  const cache = join15(appDir, SKILLS_CACHE_DIRNAME2);
-  if (existsSync15(join15(cache, LAYOUT_MIGRATION_RECORD2)) && existsSync15(cache))
-    return cache;
-  return getPortableSkillsRoot(options);
+  return { rootDir: resolveCorpusRoot(options) };
 }
 function extractSlug(entry) {
   if (!entry || typeof entry !== "object")
@@ -9984,12 +10337,12 @@ function findSkillsParityForMcpTool(tool) {
   return SKILLS_CLI_MCP_PARITY.find((entry) => entry.mcpTools.includes(tool));
 }
 // src/lib/registry-sync.ts
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname7, relative as relative3 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, relative as relative3 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.1.63",
+  version: "0.1.66",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -10063,6 +10416,7 @@ var package_default = {
   license: "Apache-2.0",
   devDependencies: {
     "@types/bun": "latest",
+    "@types/node": "25.2.3",
     "@types/react": "^18.2.0",
     "bun-types": "1.3.14",
     "react-devtools-core": "^7.0.1",
@@ -10071,7 +10425,7 @@ var package_default = {
   dependencies: {
     "@aws-sdk/client-ecs": "^3.1079.0",
     "@aws-sdk/client-s3": "^3.1079.0",
-    "@hasna/events": "0.1.7",
+    "@hasna/events": "0.1.16",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -10156,8 +10510,8 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync11(dirname7(path), { recursive: true });
-  writeFileSync11(path, `${JSON.stringify(artifact, null, 2)}
+  mkdirSync10(dirname8(path), { recursive: true });
+  writeFileSync10(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
 function buildDocs(name) {
@@ -10996,17 +11350,17 @@ function clone2(value) {
   return JSON.parse(JSON.stringify(value));
 }
 // src/lib/feedback.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync12 } from "fs";
-import { dirname as dirname8, join as join16 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname9, join as join16 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
   return join16(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname8(dbPath);
+  const dir = dirname9(dbPath);
   if (!existsSync16(dir))
-    mkdirSync12(dir, { recursive: true });
+    mkdirSync11(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec([
@@ -11040,16 +11394,16 @@ function saveFeedback(input) {
   return { saved: true, category, path: getFeedbackDbPath() };
 }
 // src/lib/native-storage.ts
-import { createHash as createHash4, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash5, createHmac as createHmac2 } from "crypto";
 import {
   existsSync as existsSync17,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync13,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync15,
   readdirSync as readdirSync9,
   statSync as statSync9,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync11
 } from "fs";
-import { dirname as dirname9, join as join17, normalize as normalize3, relative as relative4, sep as sep2 } from "path";
+import { dirname as dirname10, join as join17, normalize as normalize3, relative as relative4, sep as sep2 } from "path";
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
   "skills_sync_cursors"
@@ -11087,6 +11441,55 @@ var SKILLS_NATIVE_STORAGE_FALLBACK_ENV = {
 };
 var SKILLS_STORAGE_ENV = SKILLS_NATIVE_STORAGE_ENV;
 var SKILLS_STORAGE_FALLBACK_ENV = SKILLS_NATIVE_STORAGE_FALLBACK_ENV;
+var storageCapabilities = {
+  version: 1,
+  values: [
+    "SKILLS_NATIVE_STORAGE_ENV",
+    "SKILLS_NATIVE_STORAGE_FALLBACK_ENV",
+    "SKILLS_STORAGE_ENV",
+    "SKILLS_STORAGE_FALLBACK_ENV",
+    "SKILLS_STORAGE_TABLES",
+    "STORAGE_TABLES",
+    "SkillsPostgresSyncStore",
+    "SkillsS3ObjectStore",
+    "buildSkillsS3ObjectUrl",
+    "createSkillsPostgresSyncStore",
+    "createSkillsS3ObjectStore",
+    "createSkillsSnapshotSyncRecord",
+    "exportSkillsLocalSnapshot",
+    "getSkillsNativeStorageStatus",
+    "getSkillsStorageDatabaseEnv",
+    "getSkillsStorageDatabaseUrl",
+    "getSkillsStorageStatus",
+    "getStorageDatabaseEnv",
+    "getStorageDatabaseUrl",
+    "getStorageStatus",
+    "importSkillsLocalSnapshot",
+    "planSkillsS3SnapshotUpload",
+    "resolveSkillsNativeStorageConfig",
+    "resolveStorageConfig",
+    "signSkillsAwsV4Request",
+    "skillsPostgresSyncSchemaSql",
+    "storageCapabilities",
+    "uploadSkillsSnapshotFilesToS3"
+  ],
+  types: [
+    "AwsCredentials",
+    "SignSkillsAwsV4RequestOptions",
+    "SkillsFetch",
+    "SkillsLocalSnapshot",
+    "SkillsNativeStorageConfig",
+    "SkillsNativeStorageStatus",
+    "SkillsPostgresQueryClient",
+    "SkillsS3ObjectStoreOptions",
+    "SkillsS3PutObjectOptions",
+    "SkillsS3SnapshotPlanEntry",
+    "SkillsS3StoredObject",
+    "SkillsSnapshotFile",
+    "SkillsStorageTable",
+    "SkillsSyncRecord"
+  ]
+};
 var SKILLS_ENV_NAMESPACE = "SKILLS";
 function resolveSkillsNativeStorageConfig(env = process.env) {
   assertNoRetiredModeEnvVars(env, {
@@ -11128,7 +11531,7 @@ function getSkillsNativeStorageStatus(options = {}) {
   const s3BucketEnv = readStorageEnv(env, "s3Bucket");
   const targetDir = options.targetDir ?? process.cwd();
   return {
-    package: "open-skills",
+    package: "skills",
     tables: [...SKILLS_STORAGE_TABLES],
     env: {
       databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
@@ -11162,12 +11565,12 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const files = [];
   if (existsSync17(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync13(filePath);
+      const bytes = readFileSync15(filePath);
       const relativePath = toPosix(relative4(targetDir, filePath));
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash4("sha256").update(bytes).digest("hex"),
+        sha256: createHash5("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -11192,12 +11595,12 @@ function importSkillsLocalSnapshot(snapshot, targetDir = process.cwd(), options
       continue;
     }
     const bytes = Buffer.from(file.contentBase64, "base64");
-    const hash = createHash4("sha256").update(bytes).digest("hex");
+    const hash = createHash5("sha256").update(bytes).digest("hex");
     if (hash !== file.sha256) {
       throw new Error(`Snapshot file checksum mismatch: ${file.path}`);
     }
-    mkdirSync13(dirname9(absolutePath), { recursive: true });
-    writeFileSync12(absolutePath, bytes);
+    mkdirSync12(dirname10(absolutePath), { recursive: true });
+    writeFileSync11(absolutePath, bytes);
     written += 1;
   }
   return { written, skipped };
@@ -11300,7 +11703,7 @@ function createSkillsSnapshotSyncRecord(snapshot, options = {}) {
     kind: "local-snapshot",
     id: options.id ?? "project-state",
     updatedAt: snapshot.exportedAt,
-    source: options.source ?? "open-skills",
+    source: options.source ?? "skills",
     payload: snapshot
   };
 }
@@ -11524,7 +11927,7 @@ function toIsoString(value) {
   return Number.isNaN(date.getTime()) ? value : date.toISOString();
 }
 function sha256Hex2(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function normalizeHeaders(headers) {
   const result = {};
@@ -11593,6 +11996,7 @@ export {
   unpinProjectSkill,
   syncSkillsToAgents,
   summarizeMcpToolContract,
+  storageCapabilities,
   skillsPostgresSyncSchemaSql,
   skillExists,
   signSkillsAwsV4Request,
@@ -11747,6 +12151,8 @@ export {
   SKILLS_CLI_MCP_PARITY,
   SKILLS,
   RemoteSkillsClient,
+  RemoteRouteUnsupportedError,
+  RemoteRequestError,
   REMOTE_SKILL_RUN_CONTRACT_VERSION,
   PullSkillError,
   PROJECT_CONFIG_FILE,