@hasna/skills 0.5.10 → 0.6.0

package/dist/index.js

@@ -256,6 +256,9 @@ function getDataDir() {
   }
   return root;
 }
+function getDataDirReadOnly() {
+  return getDataRoot();
+}
 function getConfigPath(scope) {
   if (scope === "global") {
     return join2(getDataDir(), "config.json");
@@ -350,12 +353,13 @@ import {
   mkdirSync as mkdirSync3,
   mkdtempSync,
   readdirSync as readdirSync5,
+  realpathSync as realpathSync2,
   renameSync,
   rmSync,
   statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join7, normalize as normalize2 } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join7, normalize as normalize2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
 
 // src/lib/registry-data/development-tools.ts
 var DEVELOPMENT_TOOLS_SKILLS = [
@@ -2650,14 +2654,18 @@ function escapeJsString(value) {
 // src/lib/portable-skills.ts
 var LEGACY_CUSTOM_DIRNAME = "custom";
 function getPortableSkillsRoot(options = {}) {
+  return resolvePortableSkillsRoot(options, true);
+}
+function resolvePortableSkillsRoot(options, migrate) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join7(options.homeDir, ".hasna", "skills") : getDataDir();
+  const appDir = options.homeDir ? join7(options.homeDir, ".hasna", "skills") : migrate ? getDataDir() : getDataDirReadOnly();
   const cache = join7(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
     return cache;
   const installed = join7(appDir, INSTALLED_SKILLS_DIRNAME);
-  migrateLegacySkillLayout(appDir, installed);
+  if (migrate)
+    migrateLegacySkillLayout(appDir, installed);
   return installed;
 }
 function looksLikeSkillDirectory(path) {
@@ -2834,6 +2842,26 @@ function portPortableSkillDirectory(sourceDir, options = {}) {
 function isSkillCandidate(dir) {
   return existsSync7(join7(dir, "SKILL.md")) || existsSync7(join7(dir, "skill.json")) || existsSync7(join7(dir, "package.json"));
 }
+function physicalImportPath(path) {
+  let ancestor = resolve2(path);
+  const suffix = [];
+  while (!existsSync7(ancestor)) {
+    suffix.unshift(basename2(ancestor));
+    ancestor = dirname3(ancestor);
+  }
+  return join7(realpathSync2(ancestor), ...suffix);
+}
+function assertDisjointImportPaths(source, destination) {
+  const sourcePath = realpathSync2(source);
+  const destinationPath = physicalImportPath(destination);
+  const contains = (parent, child) => {
+    const path = relative2(parent, child);
+    return path === "" || !isAbsolute2(path) && path !== ".." && !path.startsWith(`..${sep2}`);
+  };
+  if (contains(sourcePath, destinationPath) || contains(destinationPath, sourcePath)) {
+    throw new Error("Source and destination skill directories must not overlap");
+  }
+}
 function portPortableSkill(sourcePath, options = {}) {
   const absoluteSource = normalize2(sourcePath);
   if (!existsSync7(absoluteSource) || !statSync6(absoluteSource).isDirectory()) {
@@ -2847,8 +2875,10 @@ function portPortableSkill(sourcePath, options = {}) {
     const via = explicitName ? `Name '${skillName}' matches a bundled official skill.` : `Inferred name '${skillName}'${sourceSlug && sourceSlug !== skillName ? ` (from source folder '${basename2(absoluteSource)}')` : ""} matches a bundled official skill.`;
     throw new Error(`${via} Importing it would shadow the official '${skillName}'. ` + `Pass --name to choose a different name, or --allow-shadow to override deliberately.`);
   }
+  assertDisjointImportPaths(absoluteSource, join7(resolvePortableSkillsRoot(options, false), skillName));
   const root = getPortableSkillsRoot(options);
   const destination = join7(root, skillName);
+  assertDisjointImportPaths(absoluteSource, destination);
   if (existsSync7(destination)) {
     if (!options.overwrite)
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
@@ -3447,27 +3477,369 @@ function getAllTags() {
   return Array.from(tagSet).sort();
 }
 // src/lib/installer.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, rmSync as rmSync3 } from "fs";
-import { dirname as dirname5, join as join11 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync12, readFileSync as readFileSync10, rmSync as rmSync3 } from "fs";
+import { dirname as dirname6, join as join12 } from "path";
+import { homedir as homedir4 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/agent-sync.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync9,
-  lstatSync as lstatSync3,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync10,
+  lstatSync as lstatSync4,
+  mkdirSync as mkdirSync5,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync7,
-  readdirSync as readdirSync7,
-  renameSync as renameSync2,
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync8,
+  renameSync as renameSync3,
   rmSync as rmSync2,
   statSync as statSync7,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename3, dirname as dirname5, join as join10 } from "path";
+
+// src/lib/agent-integration.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { existsSync as existsSync9, lstatSync as lstatSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync as readdirSync7, readlinkSync, realpathSync as realpathSync3, renameSync as renameSync2, writeFileSync as writeFileSync4, unlinkSync, chmodSync } from "fs";
+import { dirname as dirname4, join as join9, resolve as resolve3, relative as relative3, isAbsolute as isAbsolute3, sep as sep3 } from "path";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, dirname as dirname4, join as join9 } from "path";
+var sha = (data) => createHash2("sha256").update(data).digest("hex");
+var HOOK_EVENTS = ["UserPromptSubmit", "SessionStart", "SubagentStart"];
+var ROOTS = [
+  ["claude", ".claude/skills"],
+  ["codex", ".codex/skills"],
+  ["codex", ".agents/skills"],
+  ["gemini", ".gemini/skills"],
+  ["codewith", ".codewith/skills"],
+  ["opencode", ".config/opencode/skills"],
+  ["cursor", ".cursor/skills"]
+];
+function assertSafePath(path) {
+  let cursor = resolve3(path);
+  while (true) {
+    if (lstatSync3(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+      throw new Error(`Refusing symlink path: ${cursor}`);
+    const parent = dirname4(cursor);
+    if (parent === cursor)
+      return;
+    cursor = parent;
+  }
+}
+function readRootAlias(home, agent) {
+  assertSafePath(home);
+  const realHome = realpathSync3(home), alias = join9(realHome, `.${agent}`);
+  const stat = lstatSync3(alias, { throwIfNoEntry: false, bigint: true });
+  if (!stat?.isSymbolicLink())
+    throw new Error(`Agent root alias changed after planning: ${alias}`);
+  const link = readlinkSync(alias), targetPath = resolve3(dirname4(alias), link);
+  assertSafePath(targetPath);
+  const targetStat = lstatSync3(targetPath, { throwIfNoEntry: false });
+  if (!targetStat?.isDirectory())
+    throw new Error(`Agent root alias must target an existing directory: ${alias}`);
+  const target = realpathSync3(targetPath), inside = relative3(realHome, target);
+  if (!inside || inside === ".." || inside.startsWith(`..${sep3}`) || isAbsolute3(inside))
+    throw new Error(`Agent root alias target must be inside the real home: ${alias}`);
+  return { agent, home: realHome, alias, target, link, aliasIdentity: `${stat.dev}:${stat.ino}:${stat.ctimeNs}`, targetIdentity: `${targetStat.dev}:${targetStat.ino}` };
+}
+function rootAliases(home, allowed = false) {
+  if (!allowed)
+    return [];
+  const result = [];
+  for (const agent of ["claude", "codex"])
+    if (lstatSync3(join9(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
+      result.push(readRootAlias(home, agent));
+  if (result.some((item, index) => result.slice(index + 1).some((other) => item.target === other.target || item.target.startsWith(other.target + sep3) || other.target.startsWith(item.target + sep3))))
+    throw new Error("Agent root alias targets must not overlap");
+  return result;
+}
+function canonicalAgentPath(path, aliases) {
+  const absolute = resolve3(path), binding = aliases.find((item) => absolute === item.alias || absolute.startsWith(item.alias + sep3));
+  return binding ? join9(binding.target, relative3(binding.alias, absolute)) : absolute;
+}
+function recheckRootAliases(aliases) {
+  for (const binding of aliases) {
+    if (!["claude", "codex"].includes(binding.agent) || binding.alias !== join9(binding.home, `.${binding.agent}`))
+      throw new Error("Invalid agent root alias binding");
+    const current = readRootAlias(binding.home, binding.agent);
+    if (JSON.stringify(current) !== JSON.stringify(binding))
+      throw new Error(`Agent root alias changed after planning: ${binding.alias}`);
+  }
+}
+function treeHash(root) {
+  const hash = createHash2("sha256");
+  let bytes = 0, files = 0;
+  function visit(path) {
+    const stat = lstatSync3(path);
+    if (stat.isSymbolicLink())
+      throw new Error(`Refusing symlink in skill: ${path}`);
+    const rel = relative3(root, path);
+    if (stat.isDirectory()) {
+      hash.update(`d\x00${rel}\x00`);
+      for (const name of readdirSync7(path).sort())
+        visit(join9(path, name));
+      return;
+    }
+    if (!stat.isFile())
+      throw new Error(`Unsupported skill file: ${path}`);
+    bytes += stat.size;
+    files++;
+    if (bytes > 64 * 1024 * 1024 || files > 1e4)
+      throw new Error("Native skill exceeds migration size limits");
+    hash.update(`f\x00${rel}\x00${stat.size}\x00`);
+    hash.update(readFileSync7(path));
+  }
+  assertSafePath(root);
+  visit(root);
+  return hash.digest("hex");
+}
+function inventoryNativeSkills(home = homedir2(), options = {}) {
+  const aliases = rootAliases(home, options.allowRootAliases);
+  const roots = ROOTS.map(([agent, path]) => [agent, canonicalAgentPath(join9(home, path), aliases)]);
+  if (options.projectDir)
+    for (const [agent, path] of ROOTS)
+      roots.push([agent, join9(resolve3(options.projectDir), path)]);
+  const entries = [], seen = new Set;
+  function visit(agent, path, vendor = false, depth = 0) {
+    assertSafePath(path);
+    if (!existsSync9(path))
+      return;
+    if (!lstatSync3(path).isDirectory())
+      return;
+    if (existsSync9(join9(path, "SKILL.md"))) {
+      if (seen.has(path))
+        return;
+      seen.add(path);
+      let managed = false;
+      const marker = join9(path, ".hasna-skills.json");
+      if (existsSync9(marker)) {
+        try {
+          managed = JSON.parse(readFileSync7(marker, "utf8")).managedBy === "@hasna/skills";
+        } catch {}
+      }
+      const rootAlias = aliases.find((item) => path === item.target || path.startsWith(item.target + sep3));
+      entries.push({ agent, path, hash: treeHash(path), managed, vendor, ...rootAlias ? { rootAlias } : {} });
+      return;
+    }
+    if (depth > (vendor ? 8 : 3))
+      return;
+    for (const name of readdirSync7(path).sort()) {
+      if (name === "node_modules")
+        continue;
+      if (name.startsWith(".") && name !== ".system")
+        continue;
+      const isVendor = vendor || name === ".system";
+      if (isVendor && !options.includeVendor)
+        continue;
+      visit(agent, join9(path, name), isVendor, depth + 1);
+    }
+  }
+  for (const [agent, path] of roots)
+    visit(agent, path);
+  if (options.includeVendor) {
+    for (const agent of ["codex", "claude"])
+      visit(agent, canonicalAgentPath(join9(home, `.${agent}`, "plugins", "cache"), aliases), true);
+  }
+  recheckRootAliases(aliases);
+  return entries;
+}
+function readOptional(path) {
+  assertSafePath(path);
+  return existsSync9(path) ? readFileSync7(path, "utf8") : null;
+}
+function jsonObject(text, path) {
+  if (text === null)
+    return {};
+  const value = JSON.parse(text);
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`Expected configuration object: ${path}`);
+  return value;
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function configureHooks(config, agent, command, profileId) {
+  config.hooks ??= {};
+  if (typeof config.hooks !== "object" || Array.isArray(config.hooks))
+    throw new Error("Expected hooks configuration object");
+  for (const event of HOOK_EVENTS) {
+    const existing = config.hooks[event] ?? [];
+    if (!Array.isArray(existing))
+      throw new Error(`Expected ${event} hooks array`);
+    const hookCommand = `${shellQuote(command)} hook user-prompt --agent ${agent} --selection-profile ${profileId}`;
+    const retained = existing.flatMap((entry) => {
+      if (!entry || !Array.isArray(entry.hooks))
+        throw new Error(`Malformed ${event} hook entry`);
+      const hooks = entry.hooks.filter((hook) => !(hook?.type === "command" && typeof hook.command === "string" && /(?:^|\s)hook user-prompt --agent (?:claude|codex)(?: --selection-profile [A-Za-z0-9._-]+)?$/.test(hook.command)));
+      return hooks.length ? [{ ...entry, hooks }] : [];
+    });
+    retained.push({ hooks: [{ type: "command", command: hookCommand, timeout: 15 }] });
+    config.hooks[event] = retained;
+  }
+  if (agent === "claude") {
+    config.permissions ??= {};
+    if (typeof config.permissions !== "object" || Array.isArray(config.permissions))
+      throw new Error("Expected permissions configuration object");
+    const denied = config.permissions.deny ?? [];
+    if (!Array.isArray(denied))
+      throw new Error("Expected permission deny array");
+    config.permissions.deny = [...new Set([...denied, "Skill"])];
+  }
+}
+function disableCodexSkills(text, skills, aliases) {
+  Bun.TOML.parse(text);
+  let result = text;
+  for (const skill of skills.filter((entry) => entry.agent === "codex")) {
+    const path = join9(skill.path, "SKILL.md");
+    let found = false;
+    result = result.replace(/^\[\[skills\.config\]\][^\n]*(?:\n(?!\s*\[)[^\n]*)*/gm, (section) => {
+      const parsed = Bun.TOML.parse(section);
+      const declared = parsed.skills?.config?.[0]?.path;
+      if (!declared || ![resolve3(path), resolve3(skill.path)].includes(canonicalAgentPath(declared, aliases)))
+        return section;
+      found = true;
+      return /^\s*enabled\s*=/m.test(section) ? section.replace(/^\s*enabled\s*=.*$/m, "enabled = false") : `${section.trimEnd()}
+enabled = false
+`;
+    });
+    if (!found)
+      result = `${result.trimEnd()}
+
+[[skills.config]]
+path = ${JSON.stringify(path)}
+enabled = false
+`;
+  }
+  Bun.TOML.parse(result);
+  return result;
+}
+function planAgentIntegration(options) {
+  const home = options.home ?? homedir2(), dataDir2 = options.dataDir ?? getDataDir();
+  const profileId = options.profileId ?? "default";
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(profileId) || profileId.includes(".."))
+    throw new Error("Invalid selection profile id");
+  const aliases = rootAliases(home, options.allowRootAliases);
+  const nativeSkills = inventoryNativeSkills(home, { includeVendor: options.includeVendor, projectDir: options.projectDir, allowRootAliases: options.allowRootAliases });
+  const changes = [];
+  for (const agent of [...new Set(options.agents)]) {
+    if (agent !== "claude" && agent !== "codex")
+      throw new Error(`Unsupported agent: ${agent}`);
+    const path = canonicalAgentPath(join9(home, `.${agent}`, agent === "claude" ? "settings.json" : "hooks.json"), aliases);
+    const before = readOptional(path), config = jsonObject(before, path);
+    configureHooks(config, agent, options.command ?? "skills", profileId);
+    const after = `${JSON.stringify(config, null, 2)}
+`;
+    if (before !== after)
+      changes.push({ path, before, after });
+    if (agent === "codex") {
+      const configPath = canonicalAgentPath(join9(home, ".codex", "config.toml"), aliases), previous = readOptional(configPath);
+      const next = disableCodexSkills(previous ?? "", nativeSkills, aliases);
+      if (next !== (previous ?? ""))
+        changes.push({ path: configPath, before: previous, after: next });
+    }
+  }
+  recheckRootAliases(aliases);
+  return { dataDir: dataDir2, profileId, changes, nativeSkills, ...aliases.length ? { rootAliases: aliases } : {} };
+}
+function atomicWrite(path, content) {
+  assertSafePath(path);
+  mkdirSync4(dirname4(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.skills-${randomUUID()}`;
+  try {
+    writeFileSync4(temporary, content, { mode: 384, flag: "wx" });
+    renameSync2(temporary, path);
+  } finally {
+    if (existsSync9(temporary))
+      unlinkSync(temporary);
+  }
+}
+function applyAgentIntegration(plan) {
+  const aliases = plan.rootAliases ?? [];
+  recheckRootAliases(aliases);
+  for (const change of plan.changes)
+    if (readOptional(change.path) !== change.before)
+      throw new Error(`Configuration changed after planning: ${change.path}`);
+  const backupRoot = join9(plan.dataDir, "migration", randomUUID()), backups = [], written = [];
+  if (!plan.changes.length) {
+    const policyPath = join9(plan.dataDir, "agent-policy.json");
+    const policy = jsonObject(readOptional(policyPath), policyPath);
+    recheckRootAliases(aliases);
+    if (policy.loading !== "cli" || policy.profileId !== plan.profileId)
+      atomicWrite(policyPath, JSON.stringify({ version: 1, loading: "cli", profileId: plan.profileId, installedAt: new Date().toISOString() }) + `
+`);
+    return { changed: [], backups, ...aliases.length ? { rootAliases: aliases } : {} };
+  }
+  assertSafePath(backupRoot);
+  mkdirSync4(backupRoot, { recursive: true, mode: 448 });
+  chmodSync(backupRoot, 448);
+  for (const [index, change] of plan.changes.entries())
+    if (change.before !== null) {
+      const backup = join9(backupRoot, `${index}-${sha(change.path).slice(0, 12)}.backup`);
+      writeFileSync4(backup, change.before, { mode: 384, flag: "wx" });
+      backups.push(backup);
+    }
+  try {
+    for (const change of plan.changes) {
+      recheckRootAliases(aliases);
+      atomicWrite(change.path, change.after);
+      written.push(change);
+    }
+    recheckRootAliases(aliases);
+    atomicWrite(join9(plan.dataDir, "agent-policy.json"), JSON.stringify({ version: 1, loading: "cli", profileId: plan.profileId, installedAt: new Date().toISOString() }) + `
+`);
+  } catch (error) {
+    for (const change of written.reverse()) {
+      if (change.before === null)
+        unlinkSync(change.path);
+      else
+        atomicWrite(change.path, change.before);
+    }
+    throw error;
+  }
+  atomicWrite(join9(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: plan.changes.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha(change.before), afterHash: sha(change.after) })), backups, ...aliases.length ? { rootAliases: aliases } : {} }) + `
+`);
+  return { changed: plan.changes.map((change) => change.path), backups, ...aliases.length ? { rootAliases: aliases } : {} };
+}
+function archiveNativeSkills(inventory, options) {
+  const aliases = [...new Map(inventory.filter((entry) => entry.rootAlias).map((entry) => [entry.rootAlias.alias, entry.rootAlias])).values()];
+  if (aliases.length && !options.allowRootAliases)
+    throw new Error("Native migration requires explicit allowRootAliases for agent root aliases");
+  recheckRootAliases(aliases);
+  const selected = inventory.filter((entry) => !entry.vendor && (entry.managed || options.includeUnmanaged));
+  for (const entry of selected)
+    if (treeHash(entry.path) !== entry.hash)
+      throw new Error(`Native skill changed after planning: ${entry.path}`);
+  if (!selected.length)
+    return { entries: [], ...aliases.length ? { rootAliases: aliases } : {} };
+  const archiveRoot = join9(options.dataDir ?? getDataDir(), "migration", randomUUID(), "native");
+  assertSafePath(archiveRoot);
+  mkdirSync4(archiveRoot, { recursive: true, mode: 448 });
+  const entries = [];
+  try {
+    for (const [index, entry] of selected.entries()) {
+      recheckRootAliases(aliases);
+      const archive = join9(archiveRoot, `${index}-${sha(entry.path).slice(0, 12)}`);
+      renameSync2(entry.path, archive);
+      entries.push({ source: entry.path, archive, hash: entry.hash });
+    }
+    recheckRootAliases(aliases);
+    atomicWrite(join9(archiveRoot, "receipt.json"), JSON.stringify({ version: 1, entries, ...aliases.length ? { rootAliases: aliases } : {} }) + `
+`);
+  } catch (error) {
+    for (const entry of entries.reverse())
+      renameSync2(entry.archive, entry.source);
+    throw error;
+  }
+  return { entries, ...aliases.length ? { rootAliases: aliases } : {} };
+}
+function assertNativeExportAllowed(dataDir2 = getDataDir()) {
+  const path = join9(dataDir2, "agent-policy.json");
+  if (!existsSync9(path))
+    return;
+  const policy = jsonObject(readOptional(path), path);
+  if (policy.loading === "cli")
+    throw new Error("NATIVE_SKILL_EXPORT_DISABLED: this station loads skills through the Skills CLI; use skills sync --selection-profile <id>");
+}
 // src/lib/home-migration.ts
 function resolveCorpusRoot(options = {}) {
   return getPortableSkillsRoot(options);
@@ -3482,11 +3854,11 @@ function isSkillsOwnershipMarker(marker) {
   return typeof marker === "object" && marker !== null && Object.hasOwn(marker, "managedBy") && marker.managedBy === SYNC_MARKER_MANAGED_BY;
 }
 function hasSkillsOwnershipMarker(dir) {
-  const path = join9(dir, SYNC_MARKER_FILE);
+  const path = join10(dir, SYNC_MARKER_FILE);
   try {
-    if (!lstatSync3(path).isFile())
+    if (!lstatSync4(path).isFile())
       return false;
-    const marker = JSON.parse(readFileSync7(path, "utf8"));
+    const marker = JSON.parse(readFileSync8(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
   } catch {
     return false;
@@ -3503,12 +3875,12 @@ function resolveSyncAgents(arg) {
   }
   return [arg];
 }
-function agentGlobalSkillsDir(agent, homeDir = homedir2()) {
+function agentGlobalSkillsDir(agent, homeDir = homedir3()) {
   switch (agent) {
     case "opencode":
-      return join9(homeDir, ".config", "opencode", "skills");
+      return join10(homeDir, ".config", "opencode", "skills");
     default:
-      return join9(homeDir, `.${agent}`, "skills");
+      return join10(homeDir, `.${agent}`, "skills");
   }
 }
 function adaptSkillMdForAgent(skillMd, agent) {
@@ -3567,8 +3939,8 @@ function resolveSyncCorpus(options = {}) {
 function packageSourceRoots(source) {
   const roots = [];
   for (const sub of ["skills"]) {
-    const candidate = join9(source, sub);
-    if (existsSync9(candidate) && isDirectory(candidate))
+    const candidate = join10(source, sub);
+    if (existsSync10(candidate) && isDirectory(candidate))
       roots.push(candidate);
   }
   if (roots.length > 0)
@@ -3578,15 +3950,15 @@ function packageSourceRoots(source) {
 function containsSkillDirectories(path) {
   let entries;
   try {
-    entries = readdirSync7(path);
+    entries = readdirSync8(path);
   } catch {
     return false;
   }
   return entries.some((entry) => {
-    const candidate = join9(path, entry);
+    const candidate = join10(path, entry);
     if (!isDirectory(candidate))
       return false;
-    return existsSync9(join9(candidate, "SKILL.md")) || existsSync9(join9(candidate, "skill.json")) || existsSync9(join9(candidate, "package.json"));
+    return existsSync10(join10(candidate, "SKILL.md")) || existsSync10(join10(candidate, "skill.json")) || existsSync10(join10(candidate, "package.json"));
   });
 }
 function isDirectory(path) {
@@ -3597,9 +3969,10 @@ function isDirectory(path) {
   }
 }
 function syncSkillsToAgents(options = {}) {
+  assertNativeExportAllowed();
   const requested = normalizeRequested(options.names);
   const agents = options.agents?.length ? options.agents : [...SYNC_AGENTS];
-  const homeDir = options.homeDir ?? homedir2();
+  const homeDir = options.homeDir ?? homedir3();
   const { roots, source } = resolveSyncCorpus(options);
   const corpus = listPortableSkillsAcrossRoots(roots);
   const byName = new Map(corpus.map((skill) => [skill.name, skill]));
@@ -3625,7 +3998,7 @@ function syncSkillsToAgents(options = {}) {
         actions.push({
           skill: name,
           agent,
-          path: join9(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
+          path: join10(agentGlobalSkillsDir(agent, homeDir), name, "SKILL.md"),
           action: "skip",
           reason: "not found in this machine's corpus"
         });
@@ -3654,8 +4027,8 @@ function syncSkillsToAgents(options = {}) {
   return { actions };
 }
 function writeManagedAgentSkill(params) {
-  const homeDir = params.homeDir ?? homedir2();
-  const dir = join9(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
+  const homeDir = params.homeDir ?? homedir3();
+  const dir = join10(agentGlobalSkillsDir(params.agent, homeDir), params.skill);
   const result = writeManagedSkillDir(dir, params.skillMd, {
     skill: params.skill,
     source: params.source,
@@ -3672,11 +4045,11 @@ function writeManagedAgentSkill(params) {
   };
 }
 function writeManagedSkillDir(dir, skillMd, options) {
-  const skillMdPath = join9(dir, "SKILL.md");
-  const markerPath = join9(dir, SYNC_MARKER_FILE);
-  const dirExists = existsSync9(dir);
+  const skillMdPath = join10(dir, "SKILL.md");
+  const markerPath = join10(dir, SYNC_MARKER_FILE);
+  const dirExists = existsSync10(dir);
   const managed = hasSkillsOwnershipMarker(dir);
-  const hasSkillMd = existsSync9(skillMdPath);
+  const hasSkillMd = existsSync10(skillMdPath);
   if (dirExists && !managed && !hasSkillMd) {
     return {
       action: "skip",
@@ -3688,13 +4061,13 @@ function writeManagedSkillDir(dir, skillMd, options) {
     return {
       action: "skip",
       path: skillMdPath,
-      reason: existsSync9(markerPath) ? "an unmanaged SKILL.md already exists here (invalid or foreign ownership marker); pass --force to overwrite" : "an unmanaged SKILL.md already exists here (hand-authored); pass --force to overwrite"
+      reason: existsSync10(markerPath) ? "an unmanaged SKILL.md already exists here (invalid or foreign ownership marker); pass --force to overwrite" : "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"));
+      existingIsStub = isPointerSkillMd(readFileSync8(skillMdPath, "utf-8"));
     } catch {
       existingIsStub = false;
     }
@@ -3709,32 +4082,32 @@ function writeManagedSkillDir(dir, skillMd, options) {
   const action = dirExists ? "update" : "create";
   if (options.dryRun)
     return { action, path: skillMdPath };
-  const parentDir = dirname4(dir);
-  mkdirSync4(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync2(join9(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
-  const candidateDir = join9(transactionDir, "candidate");
-  const backupDir = join9(transactionDir, "backup");
-  const candidateSkillMdPath = join9(candidateDir, "SKILL.md");
-  const candidateMarkerPath = join9(candidateDir, SYNC_MARKER_FILE);
+  const parentDir = dirname5(dir);
+  mkdirSync5(parentDir, { recursive: true });
+  const transactionDir = mkdtempSync2(join10(parentDir, `.hasna-skills-write-${basename3(dir)}-`));
+  const candidateDir = join10(transactionDir, "candidate");
+  const backupDir = join10(transactionDir, "backup");
+  const candidateSkillMdPath = join10(candidateDir, "SKILL.md");
+  const candidateMarkerPath = join10(candidateDir, SYNC_MARKER_FILE);
   const marker = {
     managedBy: SYNC_MARKER_MANAGED_BY,
     skill: options.skill,
     source: options.source ?? "corpus",
     syncedAt: new Date().toISOString()
   };
-  const renameDirectory = options.renameDirectory ?? renameSync2;
+  const renameDirectory = options.renameDirectory ?? renameSync3;
   let originalMoved = false;
   let preserveTransaction = false;
   try {
     if (options.resourceDir) {
       cpSync3(options.resourceDir, candidateDir, { recursive: true, force: true });
     } else {
-      mkdirSync4(candidateDir, { recursive: true });
+      mkdirSync5(candidateDir, { recursive: true });
     }
-    writeFileSync4(candidateSkillMdPath, skillMd.endsWith(`
+    writeFileSync5(candidateSkillMdPath, skillMd.endsWith(`
 `) ? skillMd : `${skillMd}
 `);
-    writeFileSync4(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
+    writeFileSync5(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
 `);
     if (dirExists) {
       originalMoved = true;
@@ -3742,9 +4115,9 @@ function writeManagedSkillDir(dir, skillMd, options) {
     }
     renameDirectory(candidateDir, dir);
   } catch (error) {
-    if (originalMoved && existsSync9(backupDir)) {
+    if (originalMoved && existsSync10(backupDir)) {
       try {
-        if (existsSync9(dir))
+        if (existsSync10(dir))
           rmSync2(dir, { recursive: true, force: true });
         renameDirectory(backupDir, dir);
         originalMoved = false;
@@ -3763,8 +4136,8 @@ function writeManagedSkillDir(dir, skillMd, options) {
   }
   return { action, path: skillMdPath };
 }
-function removeManagedAgentSkill(skill, agent, homeDir = homedir2()) {
-  const dir = join9(agentGlobalSkillsDir(agent, homeDir), skill);
+function removeManagedAgentSkill(skill, agent, homeDir = homedir3()) {
+  const dir = join10(agentGlobalSkillsDir(agent, homeDir), skill);
   if (!hasSkillsOwnershipMarker(dir))
     return false;
   rmSync2(dir, { recursive: true, force: true });
@@ -3772,9 +4145,9 @@ function removeManagedAgentSkill(skill, agent, homeDir = homedir2()) {
 }
 function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = false) {
   if (kind === undefined || kind === "instruction" || preferBundledDocs) {
-    const skillMdPath = join9(skillPath, "SKILL.md");
-    if (existsSync9(skillMdPath))
-      return readFileSync7(skillMdPath, "utf-8");
+    const skillMdPath = join10(skillPath, "SKILL.md");
+    if (existsSync10(skillMdPath))
+      return readFileSync8(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -3804,8 +4177,8 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
   "custom",
@@ -3820,17 +4193,17 @@ var SKILLS_PROJECT_DIR = ".skills";
 var PROJECT_CONFIG_FILE = "project.json";
 var DEFAULT_EXPORT_DIR = ".skills/exports";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join10(targetDir, SKILLS_PROJECT_DIR);
+  return join11(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join10(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join11(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync8(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync9(path, "utf-8")));
   } catch {
     return null;
   }
@@ -3851,9 +4224,9 @@ function ensureProjectConfig(targetDir = process.cwd()) {
 }
 function saveProjectConfig(config, targetDir = process.cwd()) {
   const dir = getProjectStateDir(targetDir);
-  mkdirSync5(dir, { recursive: true });
+  mkdirSync6(dir, { recursive: true });
   const normalized = normalizeProjectConfig({ ...config, updatedAt: new Date().toISOString() });
-  writeFileSync5(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
+  writeFileSync6(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
 `);
 }
 function pinProjectSkill(name, details = {}, targetDir = process.cwd()) {
@@ -3944,16 +4317,16 @@ function isPinSource(value) {
 }
 
 // src/lib/installer.ts
-var __dirname2 = dirname5(fileURLToPath(import.meta.url));
+var __dirname2 = dirname6(fileURLToPath(import.meta.url));
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join11(dir, "skills");
-    if (existsSync11(candidate) && !dir.includes(".skills"))
+    const candidate = join12(dir, "skills");
+    if (existsSync12(candidate) && !dir.includes(".skills"))
       return candidate;
-    dir = dirname5(dir);
+    dir = dirname6(dir);
   }
-  return join11(__dirname2, "..", "skills");
+  return join12(__dirname2, "..", "skills");
 }
 var SKILLS_DIR = findSkillsDir();
 function getSkillPath(name) {
@@ -3961,25 +4334,25 @@ function getSkillPath(name) {
   const portable = findPortableSkill(skillName);
   if (portable)
     return portable.path;
-  const legacyCustomPath = join11(getDataDir(), "custom", skillName);
-  if (existsSync11(legacyCustomPath))
+  const legacyCustomPath = join12(getDataDir(), "custom", skillName);
+  if (existsSync12(legacyCustomPath))
     return legacyCustomPath;
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join11(SKILLS_DIR, skillName);
+  return join12(SKILLS_DIR, skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
 }
 function skillExists(name) {
-  return existsSync11(getSkillPath(name));
+  return existsSync12(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const canonicalName = getCanonicalSkillName(name);
   const skillName = normalizeSkillName(canonicalName);
-  if (!existsSync11(getSkillPath(name))) {
+  if (!existsSync12(getSkillPath(name))) {
     const knownOfficial = Boolean(getSkill(name));
     return {
       skill: canonicalName,
@@ -4006,7 +4379,7 @@ function installSkill(name, options = {}) {
 }
 function installSkillSource(name, _options = {}) {
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync11(getSkillPath(name))) {
+  if (!existsSync12(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found`, mode: "source" };
   }
   return {
@@ -4027,12 +4400,12 @@ function installSkillManifest(manifest, _options = {}) {
 }
 function createLocalSkillManifest(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync11(sourcePath))
+  if (!existsSync12(sourcePath))
     return null;
   let skillMd = "";
-  const skillMdPath = join11(sourcePath, "SKILL.md");
-  if (existsSync11(skillMdPath)) {
-    skillMd = readFileSync9(skillMdPath, "utf-8");
+  const skillMdPath = join12(sourcePath, "SKILL.md");
+  if (existsSync12(skillMdPath)) {
+    skillMd = readFileSync10(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -4104,20 +4477,21 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join11(base, ".pi", "skills") : join11(homedir3(), ".pi", "agent", "skills");
+      return scope === "project" ? join12(base, ".pi", "skills") : join12(homedir4(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join11(base, ".opencode", "skills") : join11(homedir3(), ".config", "opencode", "skills");
+      return scope === "project" ? join12(base, ".opencode", "skills") : join12(homedir4(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join11(base, `.${agent}`, "skills") : join11(homedir3(), `.${agent}`, "skills");
+      return scope === "project" ? join12(base, `.${agent}`, "skills") : join12(homedir4(), `.${agent}`, "skills");
   }
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
-  return join11(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join12(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
+  assertNativeExportAllowed();
   const canonicalName = getCanonicalSkillName(name);
-  if (!existsSync11(getSkillPath(name))) {
+  if (!existsSync12(getSkillPath(name))) {
     return { skill: canonicalName, success: false, error: `Skill '${name}' not found` };
   }
   const scope = options.scope ?? "global";
@@ -4148,9 +4522,9 @@ function removeSkillForAgent(name, options) {
 }
 function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
-  const skillMdPath = join11(sourcePath, "SKILL.md");
-  if (existsSync11(skillMdPath))
-    return readFileSync9(skillMdPath, "utf-8");
+  const skillMdPath = join12(sourcePath, "SKILL.md");
+  if (existsSync12(skillMdPath))
+    return readFileSync10(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -4168,7 +4542,7 @@ function warnMissingDependencies(name, targetDir) {
 }
 function generateMinimalSkillMd(name) {
   const sourcePath = getSkillPath(name);
-  if (!existsSync11(sourcePath))
+  if (!existsSync12(sourcePath))
     return null;
   const canonicalName = getCanonicalSkillName(name);
   const meta = getSkill(canonicalName);
@@ -4183,7 +4557,7 @@ function generateMinimalSkillMd(name) {
     "---",
     ""
   ].filter(Boolean);
-  const fallbackDoc = readFileIfExists(join11(sourcePath, "README.md")) || readFileIfExists(join11(sourcePath, "CLAUDE.md"));
+  const fallbackDoc = readFileIfExists(join12(sourcePath, "README.md")) || readFileIfExists(join12(sourcePath, "CLAUDE.md"));
   if (fallbackDoc)
     return `${frontmatter.join(`
 `)}${fallbackDoc.trim()}
@@ -4202,38 +4576,38 @@ skills run ${canonicalName}
 `;
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join11(getSkillPath(name), "package.json");
-  if (!existsSync11(pkgPath))
+  const pkgPath = join12(getSkillPath(name), "package.json");
+  if (!existsSync12(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync11(path) ? readFileSync9(path, "utf-8") : null;
+  return existsSync12(path) ? readFileSync10(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 existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync as readdirSync8, statSync as statSync8, writeFileSync as writeFileSync6 } from "fs";
-import { extname, join as join12, relative as relative2 } from "path";
+import { createHash as createHash3, randomBytes } from "crypto";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync11, readdirSync as readdirSync9, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
+import { extname, join as join13, relative as relative4 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now = new Date;
   const id = createRunId(now);
   const day = now.toISOString().slice(0, 10);
   const skillName = normalizeSkillName(params.skill);
   const root = getProjectStateDir(targetDir);
-  const runDir = join12(root, "runs", day, id);
-  const logsDir = join12(runDir, "logs");
-  const exportDir = join12(root, "exports", skillName, id);
-  mkdirSync6(logsDir, { recursive: true });
-  mkdirSync6(exportDir, { recursive: true });
-  mkdirSync6(join12(root, "tmp"), { recursive: true });
+  const runDir = join13(root, "runs", day, id);
+  const logsDir = join13(runDir, "logs");
+  const exportDir = join13(root, "exports", skillName, id);
+  mkdirSync7(logsDir, { recursive: true });
+  mkdirSync7(exportDir, { recursive: true });
+  mkdirSync7(join13(root, "tmp"), { recursive: true });
   const record = {
     id,
     skill: skillName,
@@ -4285,27 +4659,27 @@ function updateSkillRun(context, patch) {
   return context.record;
 }
 function writeRunLogs(context, stdout = "", stderr = "") {
-  writeFileSync6(join12(context.logsDir, "stdout.log"), stdout);
-  writeFileSync6(join12(context.logsDir, "stderr.log"), stderr);
+  writeFileSync7(join13(context.logsDir, "stdout.log"), stdout);
+  writeFileSync7(join13(context.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join12(context.runDir, "events.ndjson");
-  const previous = existsSync12(path) ? readFileSync10(path, "utf-8") : "";
-  writeFileSync6(path, previous + line);
+  const path = join13(context.runDir, "events.ndjson");
+  const previous = existsSync13(path) ? readFileSync11(path, "utf-8") : "";
+  writeFileSync7(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
-  const runsRoot = join12(getProjectStateDir(targetDir), "runs");
-  if (!existsSync12(runsRoot))
+  const runsRoot = join13(getProjectStateDir(targetDir), "runs");
+  if (!existsSync13(runsRoot))
     return [];
   const records = [];
-  for (const day of readdirSync8(runsRoot).sort().reverse()) {
-    const dayDir = join12(runsRoot, day);
+  for (const day of readdirSync9(runsRoot).sort().reverse()) {
+    const dayDir = join13(runsRoot, day);
     if (!statSync8(dayDir).isDirectory())
       continue;
-    for (const runId of readdirSync8(dayDir).sort().reverse()) {
-      const record = readRunRecord(join12(dayDir, runId));
+    for (const runId of readdirSync9(dayDir).sort().reverse()) {
+      const record = readRunRecord(join13(dayDir, runId));
       if (record)
         records.push(record);
       if (records.length >= limit)
@@ -4315,57 +4689,57 @@ function listSkillRuns(targetDir = process.cwd(), limit = 50) {
   return records;
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join12(getProjectStateDir(targetDir), "runs");
-  if (!existsSync12(runsRoot))
+  const runsRoot = join13(getProjectStateDir(targetDir), "runs");
+  if (!existsSync13(runsRoot))
     return null;
-  for (const day of readdirSync8(runsRoot)) {
-    const record = readRunRecord(join12(runsRoot, day, runId));
+  for (const day of readdirSync9(runsRoot)) {
+    const record = readRunRecord(join13(runsRoot, day, runId));
     if (record)
       return record;
   }
   return null;
 }
 function getRunExportDir(runId, skill, targetDir = process.cwd()) {
-  return join12(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
+  return join13(getProjectStateDir(targetDir), "exports", normalizeSkillName(skill), runId);
 }
 function writeRunRecord(context) {
-  writeFileSync6(join12(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
+  writeFileSync7(join13(context.runDir, "run.json"), JSON.stringify(context.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context, artifacts) {
-  writeFileSync6(join12(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
+  writeFileSync7(join13(context.runDir, "artifacts.json"), JSON.stringify({ runId: context.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context) {
-  if (!existsSync12(context.exportDir))
+  if (!existsSync13(context.exportDir))
     return [];
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
     const stat = statSync8(path);
-    const bytes = readFileSync10(path);
+    const bytes = readFileSync11(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash2("sha256").update(bytes).digest("hex"),
+      sha256: createHash3("sha256").update(bytes).digest("hex"),
       sizeBytes: stat.size
     });
   }
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join12(runDir, "run.json");
-  if (!existsSync12(path))
+  const path = join13(runDir, "run.json");
+  if (!existsSync13(path))
     return null;
   try {
-    return JSON.parse(readFileSync10(path, "utf-8"));
+    return JSON.parse(readFileSync11(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync8(dir)) {
-    const full = join12(dir, entry);
+  for (const entry of readdirSync9(dir)) {
+    const full = join13(dir, entry);
     if (statSync8(full).isDirectory())
       files.push(...walkFiles(full));
     else
@@ -4377,7 +4751,7 @@ function createRunId(now) {
   return `run_${now.getTime().toString(36)}_${randomBytes(4).toString("hex")}`;
 }
 function toProjectRelative(targetDir, path) {
-  const rel = relative2(targetDir, path).split(/[\\/]/).join("/");
+  const rel = relative4(targetDir, path).split(/[\\/]/).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 function mimeForPath(path) {
@@ -4411,16 +4785,16 @@ function mimeForPath(path) {
   }
 }
 // src/lib/skillinfo.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import { join as join14 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
     return true;
-  const skillMdPath = join13(skillPath, "SKILL.md");
-  if (!existsSync13(skillMdPath))
+  const skillMdPath = join14(skillPath, "SKILL.md");
+  if (!existsSync14(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync11(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync12(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -4443,12 +4817,12 @@ var HOSTED_PROVIDER_ENV_PREFIXES = [
 ];
 function getSkillDocs(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync13(skillPath))
+  if (!existsSync14(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join13(skillPath, "SKILL.md")),
-    readme: readIfExists(join13(skillPath, "README.md")),
-    claudeMd: readIfExists(join13(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join14(skillPath, "SKILL.md")),
+    readme: readIfExists(join14(skillPath, "README.md")),
+    claudeMd: readIfExists(join14(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name) {
@@ -4459,17 +4833,24 @@ function getSkillBestDoc(name) {
 }
 function getSkillRequirements(name) {
   const skillPath = getSkillPath(name);
-  if (!existsSync13(skillPath))
+  if (!existsSync14(skillPath))
     return null;
   const texts = [];
   for (const file of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join13(skillPath, file));
+    const content = readIfExists(join14(skillPath, file));
     if (content)
       texts.push(content);
   }
+  const meta = getSkill(name);
+  let dependencies = {};
+  try {
+    dependencies = JSON.parse(readFileSync12(join14(skillPath, "package.json"), "utf8")).dependencies || {};
+  } catch {}
+  return getSkillRequirementsFromContent(name, texts, dependencies, meta);
+}
+function getSkillRequirementsFromContent(name, texts, dependencies = {}, meta) {
   const allText = texts.join(`
 `);
-  const meta = getSkill(name);
   const canonicalName = meta?.name ?? normalizeSkillName(name);
   const envVars = extractEnvVars(allText);
   if (isHostedPremiumSkill(canonicalName, meta)) {
@@ -4502,14 +4883,6 @@ function getSkillRequirements(name) {
   }
   const skillName = normalizeSkillName(name);
   let cliCommand = `skills run ${skillName}`;
-  let dependencies = {};
-  const pkgPath = join13(skillPath, "package.json");
-  if (existsSync13(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
-      dependencies = pkg.dependencies || {};
-    } catch {}
-  }
   return {
     envVars: Array.from(envVars).sort(),
     systemDeps: Array.from(systemDeps).sort(),
@@ -4524,7 +4897,7 @@ async function runSkill(name, args, options = {}) {
   const meta = getSkill(name);
   const canonicalName = meta?.name ?? name;
   const skillPath = getSkillPath(canonicalName);
-  if (!existsSync13(skillPath)) {
+  if (!existsSync14(skillPath)) {
     return { exitCode: 1, error: `Skill '${name}' not found` };
   }
   if (isInstructionSkillDir(skillPath, meta)) {
@@ -4533,13 +4906,13 @@ 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 = join13(skillPath, "package.json");
-  if (!existsSync13(pkgPath)) {
+  const pkgPath = join14(skillPath, "package.json");
+  if (!existsSync14(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
   let entryPoint;
   try {
-    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint = binValues[0];
@@ -4553,12 +4926,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join13(skillPath, entryPoint);
-  if (!existsSync13(entryPath)) {
+  const entryPath = join14(skillPath, entryPoint);
+  if (!existsSync14(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint}' not found in skill '${name}'` };
   }
-  const nodeModules = join13(skillPath, "node_modules");
-  if (!existsSync13(nodeModules)) {
+  const nodeModules = join14(skillPath, "node_modules");
+  if (!existsSync14(nodeModules)) {
     const install = Bun.spawn(["bun", "install", "--no-save"], {
       cwd: skillPath,
       stdout: "pipe",
@@ -4630,7 +5003,7 @@ function generateSkillMd(name) {
   if (!meta)
     return null;
   const skillPath = getSkillPath(name);
-  if (!existsSync13(skillPath))
+  if (!existsSync14(skillPath))
     return null;
   const frontmatter = [
     "---",
@@ -4639,13 +5012,13 @@ function generateSkillMd(name) {
     "---"
   ].join(`
 `);
-  const readme = readIfExists(join13(skillPath, "README.md"));
-  const claudeMd = readIfExists(join13(skillPath, "CLAUDE.md"));
+  const readme = readIfExists(join14(skillPath, "README.md"));
+  const claudeMd = readIfExists(join14(skillPath, "CLAUDE.md"));
   let cliCommand = null;
-  const pkgPath = join13(skillPath, "package.json");
-  if (existsSync13(pkgPath)) {
+  const pkgPath = join14(skillPath, "package.json");
+  if (existsSync14(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -4720,8 +5093,8 @@ function extractEnvVars(text) {
 }
 function readIfExists(path) {
   try {
-    if (existsSync13(path)) {
-      return readFileSync11(path, "utf-8");
+    if (existsSync14(path)) {
+      return readFileSync12(path, "utf-8");
     }
   } catch {}
   return null;
@@ -8702,11 +9075,11 @@ var NEVER = INVALID;
 // ../contracts/dist/client/transport.js
 import { isIP } from "net";
 import { spawnSync } from "child_process";
-import { closeSync, fstatSync, openSync, readFileSync as readFileSync12 } from "fs";
+import { closeSync, fstatSync, openSync, readFileSync as readFileSync13 } from "fs";
 import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
 import { createRequire } from "module";
 import { hostname as osHostname } from "os";
-import { isAbsolute as isAbsolute3, join as join14 } from "path";
+import { isAbsolute as isAbsolute4, join as join15 } from "path";
 function envToken(name) {
   return name.toUpperCase().replace(/-/g, "_");
 }
@@ -8765,21 +9138,21 @@ function homeDir(env) {
 }
 function absoluteOverride(env, key) {
   const value = env[key]?.trim();
-  return value && isAbsolute3(value) ? value : null;
+  return value && isAbsolute4(value) ? value : null;
 }
 function hasnaHomeDir(env) {
   const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
   if (override)
     return override;
   const home = homeDir(env);
-  return home ? join14(home, HASNA_HOME_DIR) : null;
+  return home ? join15(home, HASNA_HOME_DIR) : null;
 }
 function appConfigDir(name, env) {
   const configRoot = absoluteOverride(env, HASNA_CONFIG_HOME_ENV_KEY);
   if (configRoot)
-    return join14(configRoot, name);
+    return join15(configRoot, name);
   const root = hasnaHomeDir(env);
-  return root ? join14(root, name, CONFIG_SUBDIR) : null;
+  return root ? join15(root, name, CONFIG_SUBDIR) : null;
 }
 function credentialDiskSourceList(name, env, profile = null) {
   if (!SAFE_APP_SLUG.test(name))
@@ -8788,7 +9161,7 @@ function credentialDiskSourceList(name, env, profile = null) {
   if (!directory)
     return [];
   const file = profile ? `${CREDENTIALS_FILE}-${profile}` : CREDENTIALS_FILE;
-  return [{ path: join14(directory, file), tier: "disk" }];
+  return [{ path: join15(directory, file), tier: "disk" }];
 }
 function credentialDiskSources(name, env) {
   return credentialDiskSourceList(name, env, null).map((s) => s.path);
@@ -8863,7 +9236,7 @@ function readAppConfigFile(path) {
       unsafe("the file is not owned by the current user");
     if (before.size > MAX_CREDENTIAL_FILE_BYTES)
       unsafe("the file exceeds the size limit");
-    const bytes = readFileSync12(fd);
+    const bytes = readFileSync13(fd);
     const after = fstatSync(fd);
     if (!configFileReadsCoherent(before, after)) {
       unsafe("the file changed while being read");
@@ -9386,7 +9759,7 @@ var AUTHORITY_OVERRIDE_HEADERS = new Set([
 ]);
 
 // src/lib/instance-credentials.ts
-import { closeSync as closeSync2, constants, fstatSync as fstatSync2, lstatSync as lstatSync4, openSync as openSync2, readSync } from "fs";
+import { closeSync as closeSync2, constants, fstatSync as fstatSync2, lstatSync as lstatSync5, openSync as openSync2, readSync } from "fs";
 var SKILLS_BOUND_API_URL = "HASNA_SKILLS_BOUND_API_URL";
 function selectedSkillsProfile(env, explicit) {
   const selected = explicit ?? env.HASNA_PROFILE;
@@ -9402,7 +9775,7 @@ function skillsProfileCredentialFiles(env, explicit) {
 }
 function fileIdentity(file) {
   try {
-    return lstatSync4(file);
+    return lstatSync5(file);
   } catch (error) {
     if (["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
       return null;
@@ -11082,7 +11455,7 @@ function object(value) {
 }
 
 // src/lib/remote-files.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var MAX_REMOTE_FILE_BYTES = 64 * 1024 * 1024;
 function describeRemoteFiles(files) {
   if (files.length > 10)
@@ -11100,7 +11473,7 @@ function describeRemoteFiles(files) {
   });
 }
 function sha256(bytes) {
-  return createHash3("sha256").update(bytes).digest("hex");
+  return createHash4("sha256").update(bytes).digest("hex");
 }
 async function readBoundedResponse(response, maximum) {
   if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > MAX_REMOTE_FILE_BYTES)
@@ -11193,10 +11566,10 @@ async function readQuoteUnavailableCode(response) {
   let timer;
   let deadlineExceeded = false;
   const expired = Symbol("quote body deadline");
-  const deadline = new Promise((resolve2) => {
+  const deadline = new Promise((resolve4) => {
     timer = setTimeout(() => {
       deadlineExceeded = true;
-      resolve2(expired);
+      resolve4(expired);
       reader.cancel().catch(() => {});
     }, 1500);
   });
@@ -11315,6 +11688,7 @@ class RemoteSkillsClient {
       credentials: "omit",
       signal: options?.signal ?? AbortSignal.timeout(15000),
       headers: {
+        "User-Agent": "hasna-skills",
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json",
         ...options?.headers
@@ -12009,26 +12383,26 @@ async function createRemoteSkillsClient(env = process.env) {
   return connection ? new RemoteSkillsClient(connection.apiKey, connection.apiOrigin) : null;
 }
 // src/lib/scheduler.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join16 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join15(targetDir, ".skills", "schedules.json");
+  return join16(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  if (existsSync14(path)) {
+  if (existsSync15(path)) {
     try {
-      return JSON.parse(readFileSync13(path, "utf-8"));
+      return JSON.parse(readFileSync14(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join15(targetDir, ".skills");
-  if (!existsSync14(dir))
-    mkdirSync7(dir, { recursive: true });
-  writeFileSync7(path, JSON.stringify(data, null, 2));
+  const dir = join16(targetDir, ".skills");
+  if (!existsSync15(dir))
+    mkdirSync8(dir, { recursive: true });
+  writeFileSync8(path, JSON.stringify(data, null, 2));
 }
 function validateCronField(expr, min, max, label) {
   for (const part of expr.split(",")) {
@@ -12213,7 +12587,7 @@ function recordScheduleRun(id, status, targetDir) {
   saveSchedules(data, targetDir);
 }
 // src/lib/revision.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var REVISION_ID_PATTERN = /^[0-9a-f]{64}$/;
 function revisionIdOf(content) {
   const canonical = JSON.stringify({
@@ -12229,19 +12603,19 @@ function revisionIdOf(content) {
     bundleSha256: content.bundleSha256 ?? null,
     bundleByteSize: content.bundleByteSize ?? null
   });
-  return createHash4("sha256").update(canonical).digest("hex");
+  return createHash5("sha256").update(canonical).digest("hex");
 }
 function revisionIdOfRecord(record4) {
   return revisionIdOf(record4);
 }
 // src/lib/pull.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, readFileSync as readFileSync15, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname6, join as join17 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname7, join as join18 } from "path";
 
 // src/lib/skill-bundle.ts
-import { createHash as createHash5 } from "crypto";
-import { readFileSync as readFileSync14, readdirSync as readdirSync9, statSync as statSync9 } from "fs";
-import { join as join16, relative as relative3 } from "path";
+import { createHash as createHash6 } from "crypto";
+import { readFileSync as readFileSync15, readdirSync as readdirSync10, statSync as statSync9 } from "fs";
+import { join as join17, relative as relative5 } from "path";
 import { createGunzip } from "zlib";
 var BLOCK = 512;
 var ANY_SEGMENT_EXCLUDES = new Set([
@@ -12394,7 +12768,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash5("sha256").update(bytes).digest("hex");
+  return createHash6("sha256").update(bytes).digest("hex");
 }
 function collectSkillBundleEntries(dir) {
   const entries = [];
@@ -12402,9 +12776,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 readdirSync9(current, { withFileTypes: true })) {
-    const absolute = join16(current, entry.name);
-    const rel = relative3(root, absolute).split("\\").join("/");
+  for (const entry of readdirSync10(current, { withFileTypes: true })) {
+    const absolute = join17(current, entry.name);
+    const rel = relative5(root, absolute).split("\\").join("/");
     const isRootLevel = !rel.includes("/");
     if (ANY_SEGMENT_EXCLUDES.has(entry.name.toLowerCase()))
       continue;
@@ -12427,7 +12801,7 @@ function walk(root, current, out) {
     const stats = statSync9(absolute);
     out.push({
       path: rel,
-      bytes: ownBytes(readFileSync14(absolute)),
+      bytes: ownBytes(readFileSync15(absolute)),
       mode: stats.mode & 64 ? 493 : 420
     });
   }
@@ -12640,7 +13014,7 @@ async function inspectSkillBundle(bundle, options = {}) {
       parser.push(chunk);
       bytesSinceYield += chunk.byteLength;
       if (bytesSinceYield >= 256 * 1024) {
-        await new Promise((resolve2) => setTimeout(resolve2, 0));
+        await new Promise((resolve4) => setTimeout(resolve4, 0));
         bytesSinceYield = 0;
         check();
       }
@@ -12886,7 +13260,7 @@ async function pullOne(client, rawName, corpusOptions, verify) {
       return reconcileTombstone(slug, corpusOptions);
     }
     if (bundleResponse.status === 404) {
-      const marker = readPullMarker(join17(getPortableSkillsRoot(corpusOptions), slug));
+      const marker = readPullMarker(join18(getPortableSkillsRoot(corpusOptions), slug));
       if (isPublishedInstallMarker(marker)) {
         return { name: slug, success: true, purged: true, removed: false };
       }
@@ -12925,7 +13299,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(join17(getPortableSkillsRoot(corpusOptions), slug));
+    const marker = readPullMarker(join18(getPortableSkillsRoot(corpusOptions), slug));
     if (isPublishedInstallMarker(marker)) {
       return { name: slug, success: true, purged: true, removed: false };
     }
@@ -12982,7 +13356,7 @@ function provenRevision(meta, slug, bundle) {
   return declared;
 }
 function reconcileTombstone(slug, corpusOptions) {
-  const target = join17(getPortableSkillsRoot(corpusOptions), slug);
+  const target = join18(getPortableSkillsRoot(corpusOptions), slug);
   if (!hasSkillsOwnershipMarker(target)) {
     return { name: slug, success: true, tombstoned: true, removed: false, leftInPlace: true };
   }
@@ -12991,7 +13365,7 @@ function reconcileTombstone(slug, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync15(join17(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync16(join18(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -13125,17 +13499,17 @@ function verifyBundleResponseBytes(buffer, response, verify = {}) {
 }
 function installBundleAtomically(name, entries, options = {}, marker = {}) {
   const root = getPortableSkillsRoot(options);
-  mkdirSync8(root, { recursive: true });
-  const target = join17(root, name);
-  const created = !existsSync15(target);
-  const staging = mkdtempSync3(join17(root, `.pull-${name}-`));
+  mkdirSync9(root, { recursive: true });
+  const target = join18(root, name);
+  const created = !existsSync16(target);
+  const staging = mkdtempSync3(join18(root, `.pull-${name}-`));
   let moved = false;
   let backup = null;
   try {
     for (const entry of entries) {
-      const destination = join17(staging, entry.path);
-      mkdirSync8(dirname6(destination), { recursive: true });
-      writeFileSync8(destination, entry.bytes, { mode: entry.mode });
+      const destination = join18(staging, entry.path);
+      mkdirSync9(dirname7(destination), { recursive: true });
+      writeFileSync9(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
       skill: name,
@@ -13145,19 +13519,19 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
       ...marker.signature ? { signature: marker.signature } : {},
       ...marker.revisionId ? { revisionId: marker.revisionId } : {}
     });
-    if (existsSync15(target)) {
-      backup = mkdtempSync3(join17(root, `.pull-backup-${name}-`));
-      renameSync3(target, join17(backup, name));
+    if (existsSync16(target)) {
+      backup = mkdtempSync3(join18(root, `.pull-backup-${name}-`));
+      renameSync4(target, join18(backup, name));
       moved = true;
     }
-    renameSync3(staging, target);
+    renameSync4(staging, target);
     if (moved && backup)
       rmSync4(backup, { recursive: true, force: true });
   } catch (error) {
     rmSync4(staging, { recursive: true, force: true });
-    if (moved && backup && existsSync15(join17(backup, name))) {
+    if (moved && backup && existsSync16(join18(backup, name))) {
       try {
-        renameSync3(join17(backup, name), target);
+        renameSync4(join18(backup, name), target);
       } catch {}
     }
     throw error;
@@ -13176,7 +13550,7 @@ function writePullMarker(dir, record4) {
     ...record4.revisionId ? { revisionId: record4.revisionId } : {},
     syncedAt: new Date().toISOString()
   };
-  writeFileSync8(join17(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+  writeFileSync9(join18(dir, PULL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function safeMeta(client, slug) {
@@ -13331,12 +13705,12 @@ function findSkillsParityForMcpTool(tool) {
   return SKILLS_CLI_MCP_PARITY.find((entry) => entry.mcpTools.includes(tool));
 }
 // src/lib/registry-sync.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname7, relative as relative4 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, relative as relative6 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.5.10",
+  version: "0.6.0",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -13452,7 +13826,8 @@ var package_default = {
   },
   repository: {
     type: "git",
-    url: "git+https://github.com/hasna/apps.git"
+    url: "https://github.com/hasna/apps.git",
+    directory: "apps/skills"
   },
   homepage: "https://github.com/hasna/skills",
   bugs: {
@@ -13472,7 +13847,7 @@ function createRegistrySyncArtifact(options = {}) {
   const registry = [...loadRegistryProfile(profile)].sort((a, b) => a.name.localeCompare(b.name));
   const skills = registry.map((skill) => {
     const skillPath = getSkillPath(skill.name);
-    const directory = relative4(process.cwd(), skillPath) || skillPath;
+    const directory = relative6(process.cwd(), skillPath) || skillPath;
     const validation = includeValidation ? validateSkillDirectory(skill.name, skillPath, skill) : undefined;
     const docs = includeDocs ? buildDocs(skill.name) : undefined;
     return {
@@ -13517,8 +13892,8 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync9(dirname7(path), { recursive: true });
-  writeFileSync9(path, `${JSON.stringify(artifact, null, 2)}
+  mkdirSync10(dirname8(path), { recursive: true });
+  writeFileSync10(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
 function buildDocs(name) {
@@ -14590,17 +14965,17 @@ function clone2(value) {
   return JSON.parse(JSON.stringify(value));
 }
 // src/lib/feedback.ts
-import { appendFileSync, existsSync as existsSync16, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname8, join as join18 } from "path";
+import { appendFileSync, existsSync as existsSync17, mkdirSync as mkdirSync11 } from "fs";
+import { dirname as dirname9, join as join19 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join18(getDataDir(), "skills.db");
+  return join19(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname8(dbPath);
-  if (!existsSync16(dir))
-    mkdirSync10(dir, { recursive: true });
+  const dir = dirname9(dbPath);
+  if (!existsSync17(dir))
+    mkdirSync11(dir, { recursive: true });
   const db = new Database(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec([
@@ -14626,10 +15001,10 @@ function saveFeedback(input) {
     throw new Error("Feedback message is required");
   const category = input.category ?? "general";
   if (isApiMode()) {
-    const path = join18(getDataDir(), "feedback.jsonl");
-    const dir = dirname8(path);
-    if (!existsSync16(dir))
-      mkdirSync10(dir, { recursive: true });
+    const path = join19(getDataDir(), "feedback.jsonl");
+    const dir = dirname9(path);
+    if (!existsSync17(dir))
+      mkdirSync11(dir, { recursive: true });
     appendFileSync(path, JSON.stringify({ message, category, email: input.email ?? null, agent: input.agent ?? null, version: input.version ?? null, createdAt: new Date().toISOString() }) + `
 `);
     return { saved: true, category, path };
@@ -14650,16 +15025,16 @@ function isApiMode(env = process.env) {
   }
 }
 // src/lib/native-storage.ts
-import { createHash as createHash6, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash7, createHmac as createHmac2 } from "crypto";
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync11,
-  readFileSync as readFileSync16,
-  readdirSync as readdirSync10,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync17,
+  readdirSync as readdirSync11,
   statSync as statSync10,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
-import { dirname as dirname9, join as join19, normalize as normalize3, relative as relative5, sep as sep2 } from "path";
+import { dirname as dirname10, join as join20, normalize as normalize3, relative as relative7, sep as sep4 } from "path";
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
   "skills_sync_cursors"
@@ -14796,7 +15171,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join19(getDataDir(), "skills.db")
+      feedbackDbPath: join20(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config.databaseUrl),
@@ -14819,14 +15194,14 @@ function getStorageStatus(options = {}) {
 function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const projectStateDir = getProjectStateDir(targetDir);
   const files = [];
-  if (existsSync17(projectStateDir)) {
+  if (existsSync18(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync16(filePath);
-      const relativePath = toPosix(relative5(targetDir, filePath));
+      const bytes = readFileSync17(filePath);
+      const relativePath = toPosix(relative7(targetDir, filePath));
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash6("sha256").update(bytes).digest("hex"),
+        sha256: createHash7("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -14846,17 +15221,17 @@ function importSkillsLocalSnapshot(snapshot, targetDir = process.cwd(), options
       continue;
     }
     const absolutePath = resolveSnapshotPath(targetDir, file.path);
-    if (existsSync17(absolutePath) && !options.overwrite) {
+    if (existsSync18(absolutePath) && !options.overwrite) {
       skipped += 1;
       continue;
     }
     const bytes = Buffer.from(file.contentBase64, "base64");
-    const hash = createHash6("sha256").update(bytes).digest("hex");
+    const hash = createHash7("sha256").update(bytes).digest("hex");
     if (hash !== file.sha256) {
       throw new Error(`Snapshot file checksum mismatch: ${file.path}`);
     }
-    mkdirSync11(dirname9(absolutePath), { recursive: true });
-    writeFileSync10(absolutePath, bytes);
+    mkdirSync12(dirname10(absolutePath), { recursive: true });
+    writeFileSync11(absolutePath, bytes);
     written += 1;
   }
   return { written, skipped };
@@ -15152,8 +15527,8 @@ function parsePositiveInteger(value) {
 }
 function walkFiles2(dir) {
   const files = [];
-  for (const entry of readdirSync10(dir)) {
-    const full = join19(dir, entry);
+  for (const entry of readdirSync11(dir)) {
+    const full = join20(dir, entry);
     const stats = statSync10(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
@@ -15164,13 +15539,13 @@ function walkFiles2(dir) {
 }
 function resolveSnapshotPath(targetDir, snapshotPath) {
   const normalizedPath = normalize3(snapshotPath);
-  if (normalizedPath.startsWith("..") || normalizedPath.includes(`${sep2}..${sep2}`) || normalizedPath.startsWith(sep2)) {
+  if (normalizedPath.startsWith("..") || normalizedPath.includes(`${sep4}..${sep4}`) || normalizedPath.startsWith(sep4)) {
     throw new Error(`Unsafe snapshot path: ${snapshotPath}`);
   }
   if (!toPosix(normalizedPath).startsWith(".skills/")) {
     throw new Error(`Snapshot path must stay inside .skills: ${snapshotPath}`);
   }
-  return join19(targetDir, normalizedPath);
+  return join20(targetDir, normalizedPath);
 }
 function normalizeS3Prefix(prefix) {
   return (prefix ?? "").trim().replace(/^\/+|\/+$/g, "");
@@ -15183,7 +15558,7 @@ function toIsoString(value) {
   return Number.isNaN(date.getTime()) ? value : date.toISOString();
 }
 function sha256Hex2(value) {
-  return createHash6("sha256").update(value).digest("hex");
+  return createHash7("sha256").update(value).digest("hex");
 }
 function normalizeHeaders(headers) {
   const result = {};
@@ -15235,20 +15610,20 @@ function toArrayBuffer(bytes) {
   return buffer;
 }
 // src/lib/station-snapshot.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync17,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync18,
   statSync as statSync12,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "fs";
-import { dirname as dirname10, isAbsolute as isAbsolute4, relative as relative6, resolve as resolve2, sep as sep4 } from "path";
+import { dirname as dirname11, isAbsolute as isAbsolute5, relative as relative8, resolve as resolve4, sep as sep6 } from "path";
 
 // src/lib/portable-snapshot-filter.ts
-import { readdirSync as readdirSync11, statSync as statSync11 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join20, sep as sep3 } from "path";
+import { readdirSync as readdirSync12, statSync as statSync11 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join21, sep as sep5 } from "path";
 var SYNC_HOMES = [
   { name: "skills", subClass: "skills", agent: null },
   { name: "custom", subClass: "custom", agent: null },
@@ -15339,29 +15714,29 @@ function isPortableWithinSkill(relativeParts) {
   return PORTABLE_SUBDIRS.has(second);
 }
 function homePathFor(definition, homesRoot) {
-  const home = homesRoot ?? homedir4();
+  const home = homesRoot ?? homedir5();
   if (definition.subClass === "skills" || definition.subClass === "custom") {
-    return join20(skillsDataRootForHome(home), definition.name);
+    return join21(skillsDataRootForHome(home), definition.name);
   }
   if (definition.agent === "opencode") {
-    return join20(home, ".config", "opencode", "skills");
+    return join21(home, ".config", "opencode", "skills");
   }
-  return join20(home, `.${definition.agent}`, "skills");
+  return join21(home, `.${definition.agent}`, "skills");
 }
 function destinationFor(definition, stationId, relativePath) {
-  const category = definition.subClass === "agent-homes" ? join20("agent-homes", definition.agent ?? "") : definition.name;
-  return join20("resources", stationId, "skills", category, ...relativePath.split(sep3));
+  const category = definition.subClass === "agent-homes" ? join21("agent-homes", definition.agent ?? "") : definition.name;
+  return join21("resources", stationId, "skills", category, ...relativePath.split(sep5));
 }
 function walkEntries(absoluteRoot) {
   let entries;
   try {
-    entries = readdirSync11(absoluteRoot, { withFileTypes: true });
+    entries = readdirSync12(absoluteRoot, { withFileTypes: true });
   } catch {
     return [];
   }
   const output = [];
   for (const entry of entries) {
-    const childFull = join20(absoluteRoot, entry.name);
+    const childFull = join21(absoluteRoot, entry.name);
     if (entry.isSymbolicLink()) {
       output.push({ kind: "symlink", relativePath: entry.name, fullPath: childFull });
       continue;
@@ -15372,7 +15747,7 @@ function walkEntries(absoluteRoot) {
       }
       const nested = walkEntries(childFull);
       for (const item of nested) {
-        output.push({ ...item, relativePath: join20(entry.name, item.relativePath) });
+        output.push({ ...item, relativePath: join21(entry.name, item.relativePath) });
       }
       continue;
     }
@@ -15410,7 +15785,7 @@ function validateStationId(stationId) {
   }
 }
 function sha256File(filePath) {
-  return createHash7("sha256").update(readFileSync17(filePath)).digest("hex");
+  return createHash8("sha256").update(readFileSync18(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -15418,7 +15793,7 @@ function scanHome(definition, homesRoot) {
   const portable = [];
   const skipped = [];
   for (const entry of entries) {
-    const relativeParts = entry.relativePath.split(sep4);
+    const relativeParts = entry.relativePath.split(sep6);
     const fileName = relativeParts[relativeParts.length - 1];
     if (entry.kind === "symlink") {
       skipped.push({ relativePath: entry.relativePath, reason: "symlink" });
@@ -15481,7 +15856,7 @@ function humanHomes(scanned) {
   }));
 }
 function writeStationSnapshot(options) {
-  const repoRoot = resolve2(options.repoRoot ?? process.cwd());
+  const repoRoot = resolve4(options.repoRoot ?? process.cwd());
   const { scanned, plans, totalBytes } = planStationSnapshot(options);
   const manifestFiles = plans.map((plan) => ({
     relativePath: plan.source.relativePath,
@@ -15507,9 +15882,9 @@ function writeStationSnapshot(options) {
   const conflicts = [];
   const untouched = [];
   for (const plan of plans) {
-    const destination = resolve2(repoRoot, plan.destination);
-    const destinationRelative = relative6(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep4) || isAbsolute4(destinationRelative)) {
+    const destination = resolve4(repoRoot, plan.destination);
+    const destinationRelative = relative8(repoRoot, destination);
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep6) || isAbsolute5(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -15530,8 +15905,8 @@ function writeStationSnapshot(options) {
   }
   let written = 0;
   for (const plan of untouched) {
-    const destination = resolve2(repoRoot, plan.destination);
-    mkdirSync12(dirname10(destination), { recursive: true });
+    const destination = resolve4(repoRoot, plan.destination);
+    mkdirSync13(dirname11(destination), { recursive: true });
     copyFileSync2(plan.source.fullPath, destination);
     written += 1;
   }
@@ -15549,9 +15924,9 @@ function writeStationSnapshot(options) {
     },
     files: manifestFiles
   };
-  const manifestPath = resolve2(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync12(dirname10(manifestPath), { recursive: true });
-  writeFileSync11(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = resolve4(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
+  mkdirSync13(dirname11(manifestPath), { recursive: true });
+  writeFileSync12(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
     ...base,
@@ -15561,16 +15936,16 @@ function writeStationSnapshot(options) {
   };
 }
 // src/lib/station-hydrate.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
   copyFileSync as copyFileSync3,
-  mkdirSync as mkdirSync13,
-  readdirSync as readdirSync12,
-  readFileSync as readFileSync18,
+  mkdirSync as mkdirSync14,
+  readdirSync as readdirSync13,
+  readFileSync as readFileSync19,
   statSync as statSync13,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname11, join as join21, resolve as resolve3, sep as sep5 } from "path";
+import { dirname as dirname12, join as join22, resolve as resolve5, sep as sep7 } from "path";
 var STATION_HYDRATION_MANIFEST_SCHEMA = "hasna.fleet-resources.skills-hydration-manifest/v1";
 var STATION_HYDRATION_PRODUCER = { name: "@hasna/skills", version: package_default.version };
 var MANIFEST_HASH_KEY_SEP = String.fromCharCode(0);
@@ -15578,14 +15953,14 @@ function fail(code, message, detail = []) {
   throw new StationSnapshotError(code, message, detail);
 }
 function snapshotRootFor(repoRoot, stationId) {
-  return join21(repoRoot, "resources", stationId, "skills");
+  return join22(repoRoot, "resources", stationId, "skills");
 }
 function readSnapshotManifest(repoRoot, stationId) {
   const snapshotRoot = snapshotRootFor(repoRoot, stationId);
-  const manifestPath = join21(snapshotRoot, "sync-manifest.json");
+  const manifestPath = join22(snapshotRoot, "sync-manifest.json");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync18(manifestPath, "utf8"));
+    manifest = JSON.parse(readFileSync19(manifestPath, "utf8"));
   } catch (error) {
     fail("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error.message}`);
   }
@@ -15609,10 +15984,10 @@ function planStationHydration(stationId, repoRoot) {
   const hashMismatches = [];
   const skippedByRule = [];
   for (const agent of SYNC_AGENTS) {
-    const agentRoot = join21(snapshotRoot, "agent-homes", agent);
+    const agentRoot = join22(snapshotRoot, "agent-homes", agent);
     let identEntries;
     try {
-      identEntries = readdirSync12(agentRoot, { withFileTypes: true });
+      identEntries = readdirSync13(agentRoot, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -15620,10 +15995,10 @@ function planStationHydration(stationId, repoRoot) {
       if (!identEntry.isDirectory() || identEntry.name.startsWith(".")) {
         continue;
       }
-      const identRoot = join21(agentRoot, identEntry.name);
+      const identRoot = join22(agentRoot, identEntry.name);
       const entries = walkEntries(identRoot);
       for (const entry of entries) {
-        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep5)];
+        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep7)];
         if (entry.kind === "symlink") {
           symlinks.push({ ident: identEntry.name, agent, relativePath: entry.relativePath });
           continue;
@@ -15647,8 +16022,8 @@ function planStationHydration(stationId, repoRoot) {
           });
           continue;
         }
-        const withinIdent = relativeParts.slice(1).join(sep5);
-        const homeRelative = relativeParts.join(sep5);
+        const withinIdent = relativeParts.slice(1).join(sep7);
+        const homeRelative = relativeParts.join(sep7);
         if (REFUSED_SCANNER_FLAGGED.has(homeRelative)) {
           skippedByRule.push({
             ident: identEntry.name,
@@ -15721,7 +16096,7 @@ function planStationHydration(stationId, repoRoot) {
         for (const copy of copies) {
           let isStub = false;
           try {
-            isStub = isPointerSkillMd(readFileSync18(copy.fullPath, "utf8"));
+            isStub = isPointerSkillMd(readFileSync19(copy.fullPath, "utf8"));
           } catch {
             isStub = false;
           }
@@ -15767,12 +16142,12 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file) => sha256File(file.winner.fullPath));
-  return createHash8("sha256").update(joined.sort().join(`
+  return createHash9("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
-  const repoRoot = resolve3(options.repoRoot ?? process.cwd());
-  const cacheRoot = resolve3(options.cacheRoot ?? resolveCorpusRoot());
+  const repoRoot = resolve5(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve5(options.cacheRoot ?? resolveCorpusRoot());
   const plan = planStationHydration(options.stationId, repoRoot);
   const resultSkills = plan.winners.map((skill) => ({
     ident: skill.ident,
@@ -15805,7 +16180,7 @@ function writeStationHydration(options) {
   const toWrite = [];
   for (const skill of plan.winners) {
     for (const file of skill.files) {
-      const destination = join21(cacheRoot, skill.ident, file.withinIdent);
+      const destination = join22(cacheRoot, skill.ident, file.withinIdent);
       const digest = sha256File(file.winner.fullPath);
       let existingDigest = null;
       try {
@@ -15826,7 +16201,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync13(dirname11(entry.destination), { recursive: true });
+    mkdirSync14(dirname12(entry.destination), { recursive: true });
     copyFileSync3(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -15847,9 +16222,9 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join21(dirname11(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync13(dirname11(hydrationManifestPath), { recursive: true });
-  writeFileSync12(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
+  const hydrationManifestPath = join22(dirname12(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync14(dirname12(hydrationManifestPath), { recursive: true });
+  writeFileSync13(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
     ...base,
@@ -15954,7 +16329,7 @@ async function requestInvitationEmail(origin, action, input) {
 }
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 var PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
 var failures = {
   INVALID_REQUEST: [400, "The publication request is invalid."],
@@ -16001,7 +16376,7 @@ var hash = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
 var record5 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var exact = (v, keys) => record5(v) && Object.keys(v).sort().join(",") === keys.sort().join(",");
 var date = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v));
-var publicationSha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex");
+var publicationSha256 = (bytes) => createHash10("sha256").update(bytes).digest("hex");
 function checkedPublicationDeclaration(value) {
   if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
@@ -16246,12 +16621,12 @@ class RemotePrivatePublicationsClient {
       previous = view;
       if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
         return view;
-      await new Promise((resolve4) => {
+      await new Promise((resolve6) => {
         const timer = setTimeout(done, Math.min(1000, until - Date.now()));
         function done() {
           clearTimeout(timer);
           options.signal?.removeEventListener("abort", done);
-          resolve4();
+          resolve6();
         }
         options.signal?.addEventListener("abort", done, { once: true });
       });
@@ -16483,23 +16858,23 @@ class RemoteSkillsAuthClient {
   }
 }
 // src/lib/private-publication-recovery.ts
-import { constants as constants2, closeSync as closeSync3, fsyncSync, fstatSync as fstatSync3, lstatSync as lstatSync5, mkdirSync as mkdirSync14, openSync as openSync3, readSync as readSync2, realpathSync as realpathSync2, renameSync as renameSync4, unlinkSync, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute5, join as join22, resolve as resolve4 } from "path";
-import { randomUUID } from "crypto";
+import { constants as constants2, closeSync as closeSync3, fsyncSync, fstatSync as fstatSync3, lstatSync as lstatSync6, mkdirSync as mkdirSync15, openSync as openSync3, readSync as readSync2, realpathSync as realpathSync4, renameSync as renameSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname13, isAbsolute as isAbsolute6, join as join23, resolve as resolve6 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 var fail2 = () => {
   throw new PrivatePublicationError("PUBLICATION_RECOVERY_INVALID", "The recovery directory is invalid or changed. Preserve it and inspect the existing intent; do not start a replacement automatically.");
 };
 function safeDirectory(directory) {
-  if (!isAbsolute5(directory) || directory !== resolve4(directory) || realpathSync2(directory) !== directory)
+  if (!isAbsolute6(directory) || directory !== resolve6(directory) || realpathSync4(directory) !== directory)
     return fail2();
-  for (let path = directory;; path = dirname12(path)) {
-    const stat = lstatSync5(path);
+  for (let path = directory;; path = dirname13(path)) {
+    const stat = lstatSync6(path);
     if (!stat.isDirectory() || stat.isSymbolicLink())
       return fail2();
-    if (path === dirname12(path))
+    if (path === dirname13(path))
       break;
   }
-  const own = lstatSync5(directory);
+  const own = lstatSync6(directory);
   if ((own.mode & 63) !== 0 || process.getuid && own.uid !== process.getuid())
     return fail2();
   return { dev: own.dev, ino: own.ino };
@@ -16510,7 +16885,7 @@ function unchangedDirectory(directory, identity) {
     return fail2();
 }
 function readOwned(directory, name, max) {
-  const identity = safeDirectory(directory), file = join22(directory, name);
+  const identity = safeDirectory(directory), file = join23(directory, name);
   const fd = openSync3(file, constants2.O_RDONLY | constants2.O_NOFOLLOW);
   try {
     const stat = fstatSync3(fd);
@@ -16534,20 +16909,20 @@ function readOwned(directory, name, max) {
   }
 }
 function writeOwned(directory, name, bytes) {
-  const fd = openSync3(join22(directory, name), constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  const fd = openSync3(join23(directory, name), constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
   try {
-    writeFileSync13(fd, bytes);
+    writeFileSync14(fd, bytes);
     fsyncSync(fd);
   } finally {
     closeSync3(fd);
   }
 }
 function save(directory, value) {
-  const identity = safeDirectory(directory), temporary = `.receipt-${randomUUID()}.json`;
+  const identity = safeDirectory(directory), temporary = `.receipt-${randomUUID2()}.json`;
   writeOwned(directory, temporary, JSON.stringify(value) + `
 `);
   unchangedDirectory(directory, identity);
-  renameSync4(join22(directory, temporary), join22(directory, "receipt.json"));
+  renameSync5(join23(directory, temporary), join23(directory, "receipt.json"));
   const fd = openSync3(directory, constants2.O_RDONLY | constants2.O_NOFOLLOW);
   try {
     fsyncSync(fd);
@@ -16560,7 +16935,7 @@ function bind(client, receipt) {
     throw new PrivatePublicationError("PUBLICATION_IDENTITY_CHANGED", "The fresh session does not match the recovery directory's server, account and membership.");
 }
 async function locked(directory, action) {
-  const identity = safeDirectory(directory), file = join22(directory, "operation.lock");
+  const identity = safeDirectory(directory), file = join23(directory, "operation.lock");
   let fd;
   try {
     fd = openSync3(file, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
@@ -16569,17 +16944,17 @@ async function locked(directory, action) {
   }
   const lock = fstatSync3(fd);
   try {
-    writeFileSync13(fd, JSON.stringify({ pid: process.pid }) + `
+    writeFileSync14(fd, JSON.stringify({ pid: process.pid }) + `
 `);
     fsyncSync(fd);
     return await action();
   } finally {
     closeSync3(fd);
     unchangedDirectory(directory, identity);
-    const now = lstatSync5(file);
+    const now = lstatSync6(file);
     if (now.dev !== lock.dev || now.ino !== lock.ino || !now.isFile() || now.isSymbolicLink())
       fail2();
-    unlinkSync(file);
+    unlinkSync2(file);
   }
 }
 function readPrivatePublicationRecovery(directory) {
@@ -16610,7 +16985,7 @@ async function preparePrivatePublication(client, sourceDirectory, recoveryDirect
     throw new PrivatePublicationError("PUBLICATION_BUNDLE_INVALID", "The skill must have a valid skill.json with its current content hash. Validate the skill before publishing.");
   const manifestText = new TextDecoder("utf-8", { fatal: true }).decode(manifest.bytes);
   const declaration = checkedPublicationDeclaration({
-    idempotencyKey: input.idempotencyKey ?? randomUUID(),
+    idempotencyKey: input.idempotencyKey ?? randomUUID2(),
     version: JSON.parse(manifestText).version,
     expectedCurrentVersionId: input.expectedCurrentVersionId,
     manifestText,
@@ -16628,11 +17003,11 @@ async function preparePrivatePublication(client, sourceDirectory, recoveryDirect
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute5(recoveryDirectory) || resolve4(recoveryDirectory) !== recoveryDirectory || realpathSync2(dirname12(recoveryDirectory)) !== dirname12(recoveryDirectory))
+  if (!isAbsolute6(recoveryDirectory) || resolve6(recoveryDirectory) !== recoveryDirectory || realpathSync4(dirname13(recoveryDirectory)) !== dirname13(recoveryDirectory))
     return fail2();
-  mkdirSync14(recoveryDirectory, { mode: 448 });
+  mkdirSync15(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync3(dirname12(recoveryDirectory), constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  const parent = openSync3(dirname13(recoveryDirectory), constants2.O_RDONLY | constants2.O_NOFOLLOW);
   try {
     fsyncSync(parent);
   } finally {
@@ -16718,6 +17093,565 @@ async function inspectLocked(client, directory, cancel) {
     throw new PrivatePublicationError("PUBLICATION_INTENT_UNKNOWN", "Reconcile the saved begin request with publication resume before cancelling its intent.");
   return privatePublicationResult(directory, receipt);
 }
+// src/lib/profile-client.ts
+function object2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function identifier(value) {
+  return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value) && !value.includes("..");
+}
+function invalid4() {
+  throw new Error("The Skills API returned an invalid profile response");
+}
+function validateSelection(value) {
+  if (!object2(value) || !identifier(value.slug) || typeof value.version !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(value.version) || value.version.includes("..") || typeof value.bundleDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.bundleDigest))
+    invalid4();
+  if (value.triggers !== undefined) {
+    if (!object2(value.triggers) || Object.keys(value.triggers).some((key) => !["keywords", "paths", "always"].includes(key)))
+      invalid4();
+    if (value.triggers.always !== undefined && typeof value.triggers.always !== "boolean")
+      invalid4();
+    for (const key of ["keywords", "paths"]) {
+      const values = value.triggers[key];
+      if (values !== undefined && (!Array.isArray(values) || values.length > 32 || values.some((term) => typeof term !== "string" || !term.trim() || term.length > 256)))
+        invalid4();
+    }
+  }
+}
+
+class HttpProfileClient {
+  key;
+  authority;
+  origin;
+  constructor(key, origin) {
+    this.key = key;
+    if (!key.trim())
+      throw new Error("A Skills credential is required");
+    this.origin = normalizeSkillsApiOrigin(origin);
+    this.authority = skillsApiRequestUrl(this.origin, "/api/v1/").replace(/\/+$/, "");
+  }
+  async request(path, init = {}) {
+    let response;
+    try {
+      response = await fetch(skillsApiRequestUrl(this.origin, `/api/v1${path}`), {
+        ...init,
+        redirect: "error",
+        credentials: "omit",
+        signal: AbortSignal.timeout(15000),
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": `hasna-skills/${package_default.version}`,
+          Authorization: `Bearer ${this.key}`,
+          ...init.headers
+        }
+      });
+    } catch {
+      throw new Error("Unable to reach the configured Skills API");
+    }
+    if (!response.ok) {
+      response.body?.cancel().catch(() => {});
+      throw new Error(`Skills API request failed (HTTP ${response.status})`);
+    }
+    return response;
+  }
+  async read(response) {
+    try {
+      return JSON.parse(new TextDecoder().decode(await readBoundedResponse(response, 1e6)));
+    } catch {
+      invalid4();
+    }
+  }
+  async resolveProfile(id) {
+    if (!identifier(id))
+      throw new Error("Invalid selection profile id");
+    const result = await this.read(await this.request(`/profiles/${encodeURIComponent(id)}/resolve`));
+    if (!object2(result) || result.profileId !== id || result.authority !== this.authority || !identifier(result.workspaceId) || !identifier(result.profileRevision) || !Array.isArray(result.selections) || result.selections.length > 256)
+      invalid4();
+    const seen = new Set;
+    for (const entry of result.selections) {
+      validateSelection(entry);
+      const item = entry;
+      if (seen.has(item.slug) || item.authority !== this.authority || item.workspaceId !== result.workspaceId || item.profileRevision !== result.profileRevision)
+        invalid4();
+      seen.add(item.slug);
+    }
+    return result;
+  }
+  async recordStation(id, input) {
+    if (!identifier(id) || !identifier(input.profileId) || !identifier(input.profileRevision) || !Array.isArray(input.selections) || input.selections.length > 256)
+      throw new Error("Invalid station state");
+    input.selections.forEach(validateSelection);
+    const result = await this.read(await this.request(`/stations/${encodeURIComponent(id)}/state`, {
+      method: "PUT",
+      body: JSON.stringify(input)
+    }));
+    if (!object2(result) || result.stationId !== id || result.profileId !== input.profileId || result.profileRevision !== input.profileRevision || !identifier(result.workspaceId) || !identifier(result.actorId) || typeof result.appliedAt !== "string" || !Array.isArray(result.selections))
+      invalid4();
+    result.selections.forEach(validateSelection);
+    return result;
+  }
+  async getBundle(slug, version) {
+    if (!identifier(slug) || !/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(version) || version.includes(".."))
+      throw new Error("Invalid immutable skill reference");
+    return this.request(`/skills/${encodeURIComponent(slug)}/versions/${encodeURIComponent(version)}/bundle`);
+  }
+}
+async function createProfileClient() {
+  const connection = await resolveSkillsConnection();
+  if (!connection)
+    throw new Error("Selection profiles require a configured Skills API");
+  return new HttpProfileClient(connection.apiKey, connection.apiOrigin);
+}
+// src/lib/skill-context.ts
+import { createHash as createHash12 } from "crypto";
+import { resolve as resolve8 } from "path";
+
+// src/lib/selection-cache.ts
+import { createHash as createHash11, randomUUID as randomUUID3 } from "crypto";
+import { closeSync as closeSync4, constants as constants3, fstatSync as fstatSync4, lstatSync as lstatSync7, mkdirSync as mkdirSync16, openSync as openSync4, readFileSync as readFileSync20, renameSync as renameSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname14, join as join24, parse, resolve as resolve7 } from "path";
+class SkillSelectionError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SkillSelectionError";
+  }
+}
+var MAX_CACHED_PROFILE_AGE_MS = 24 * 60 * 60 * 1000;
+var SELECTION_LOCK_FILE = "selection.lock.json";
+var MAX_RECEIPT_BYTES = 1024 * 1024;
+function selectionCacheRoot(options = {}) {
+  return resolve7(options.cacheDir ?? join24(getDataDirReadOnly(), "selection-cache"));
+}
+function selectionKey(selection) {
+  validateSelection2(selection);
+  return hash2([selection.authority, selection.workspaceId, selection.slug, selection.version, selection.bundleDigest]);
+}
+function hash2(value) {
+  return createHash11("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function validateSelection2(selection) {
+  if (!selection || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(selection.slug) || !isValidSkillVersion(selection.version) || !/^sha256:[a-f0-9]{64}$/.test(selection.bundleDigest) || typeof selection.workspaceId !== "string" || !selection.workspaceId.trim() || typeof selection.profileRevision !== "string" || !selection.profileRevision.trim()) {
+    throw new SkillSelectionError("INVALID_SELECTION", "A skill selection must carry an exact version, digest, workspace and profile revision.");
+  }
+  try {
+    const url = new URL(selection.authority);
+    if (url.username || url.password || url.search || url.hash || !["https:", "http:"].includes(url.protocol) || url.protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))
+      throw new Error;
+  } catch {
+    throw new SkillSelectionError("INVALID_SELECTION", "The skill selection authority is invalid.");
+  }
+}
+function validateResolvedProfile(profile, authority) {
+  if (!profile || typeof profile.profileId !== "string" || !profile.profileId.trim() || !Array.isArray(profile.selections) || profile.selections.length > 1000 || typeof profile.workspaceId !== "string" || !profile.workspaceId.trim() || typeof profile.profileRevision !== "string" || !profile.profileRevision.trim() || typeof profile.authority !== "string" || authority !== undefined && profile.authority !== authority) {
+    throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The resolved profile does not match the configured Skills authority.");
+  }
+  const slugs = new Set;
+  for (const selection of profile.selections) {
+    validateSelection2(selection);
+    if (selection.authority !== profile.authority || selection.workspaceId !== profile.workspaceId || selection.profileRevision !== profile.profileRevision || slugs.has(selection.slug)) {
+      throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The resolved profile contains conflicting selection identities.");
+    }
+    slugs.add(selection.slug);
+  }
+}
+function selectionBundlePath(selection, options = {}) {
+  validateSelection2(selection);
+  return join24(selectionCacheRoot(options), "objects", hash2(selection.authority), hash2(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
+}
+function assertRegularPath(path, createParents = false) {
+  const absolute = resolve7(path);
+  const root = parse(absolute).root;
+  let cursor2 = root;
+  const segments = absolute.slice(root.length).split("/");
+  for (let index = 0;index < segments.length; index++) {
+    cursor2 = join24(cursor2, segments[index]);
+    try {
+      const stat = lstatSync7(cursor2);
+      if (stat.isSymbolicLink() || index < segments.length - 1 && !stat.isDirectory()) {
+        throw new SkillSelectionError("UNSAFE_CACHE_PATH", "Skills cache paths must not traverse symlinks or non-directories.");
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+      if (createParents && index < segments.length - 1)
+        mkdirSync16(cursor2, { mode: 448 });
+    }
+  }
+}
+function readRegularFile(path, limit) {
+  assertRegularPath(path);
+  let fd;
+  try {
+    fd = openSync4(path, constants3.O_RDONLY | constants3.O_NOFOLLOW);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  try {
+    const stat = fstatSync4(fd);
+    if (!stat.isFile() || stat.size > limit)
+      throw new SkillSelectionError("INVALID_CACHE_FILE", "The Skills cache contains an invalid or oversized file.");
+    return readFileSync20(fd);
+  } finally {
+    closeSync4(fd);
+  }
+}
+function writeSelectionJson(path, value) {
+  const bytes = Buffer.from(`${JSON.stringify(value, null, 2)}
+`);
+  if (bytes.length > MAX_RECEIPT_BYTES)
+    throw new SkillSelectionError("RECEIPT_TOO_LARGE", "The Skills selection receipt exceeds its size limit.");
+  atomicWrite2(path, bytes, 384);
+}
+function atomicWrite2(path, bytes, mode) {
+  assertRegularPath(path, true);
+  const temporary = join24(dirname14(path), `.selection-${randomUUID3()}.tmp`);
+  try {
+    writeFileSync15(temporary, bytes, { flag: "wx", mode });
+    renameSync6(temporary, path);
+  } finally {
+    try {
+      unlinkSync3(temporary);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+}
+function readSelectionJson(path) {
+  const bytes = readRegularFile(path, MAX_RECEIPT_BYTES);
+  if (!bytes)
+    return null;
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills selection receipt is unreadable; sync the profile again.");
+  }
+}
+async function verifiedEntries(selection, bytes) {
+  if (`sha256:${sha256Hex(bytes)}` !== selection.bundleDigest)
+    throw new SkillSelectionError("BUNDLE_DIGEST_MISMATCH", "The skill bundle does not match its selected digest.");
+  const bundle = await inspectSkillBundle(bytes);
+  return bundle.entries;
+}
+async function readCachedSelection(selection, options = {}) {
+  const bytes = readRegularFile(selectionBundlePath(selection, options), SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes);
+  return bytes ? verifiedEntries(selection, bytes) : null;
+}
+async function cacheSelectionBundle(selection, response, options = {}) {
+  validateSelection2(selection);
+  if (!response?.ok)
+    throw new SkillSelectionError("BUNDLE_UNAVAILABLE", `The selected skill bundle is unavailable${response ? ` (HTTP ${response.status})` : ""}.`);
+  const declared = response.headers.get("X-Skill-Bundle-Sha256");
+  const version = response.headers.get("X-Skill-Version");
+  if (declared && `sha256:${declared}` !== selection.bundleDigest || version && version !== selection.version) {
+    await response.body?.cancel();
+    throw new SkillSelectionError("BUNDLE_IDENTITY_MISMATCH", "The returned bundle does not match the selected version and digest.");
+  }
+  const maximum = SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes;
+  const reader = response.body?.getReader();
+  if (!reader)
+    throw new SkillSelectionError("BUNDLE_UNAVAILABLE", "The selected bundle response has no body.");
+  const chunks = [];
+  let length = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done)
+        break;
+      length += next.value.byteLength;
+      if (length > maximum)
+        throw new SkillSelectionError("BUNDLE_TOO_LARGE", "The selected bundle exceeds the cache size limit.");
+      chunks.push(next.value);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {});
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const entries = await verifiedEntries(selection, bytes);
+  const path = selectionBundlePath(selection, options);
+  const existing = readRegularFile(path, maximum);
+  if (existing)
+    await verifiedEntries(selection, existing);
+  else
+    atomicWrite2(path, bytes, 256);
+  return entries;
+}
+function profilePath(profileId, options) {
+  return join24(selectionCacheRoot(options), "profiles", `${hash2(profileId)}.json`);
+}
+function activateSelectionProfile(profile, options = {}) {
+  validateResolvedProfile(profile);
+  const receipt = { schemaVersion: 1, verifiedAt: new Date((options.now ?? Date.now)()).toISOString(), profile };
+  writeSelectionJson(profilePath(profile.profileId, options), receipt);
+  return receipt;
+}
+function readSelectionProfile(profileId, options = {}) {
+  const receipt = readSelectionJson(profilePath(profileId, options));
+  if (receipt)
+    validateSelectionReceipt(receipt);
+  return receipt;
+}
+function validateSelectionReceipt(receipt) {
+  if (!receipt || receipt.schemaVersion !== 1 || !Number.isFinite(Date.parse(receipt.verifiedAt)))
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills selection receipt is invalid.");
+  validateResolvedProfile(receipt.profile);
+}
+function assertFreshCachedProfile(receipt, options = {}) {
+  validateSelectionReceipt(receipt);
+  const age = (options.now ?? Date.now)() - Date.parse(receipt.verifiedAt);
+  const maximum = options.maxAgeMs ?? MAX_CACHED_PROFILE_AGE_MS;
+  if (!Number.isFinite(maximum) || maximum <= 0 || maximum > MAX_CACHED_PROFILE_AGE_MS || age < 0 || age > maximum) {
+    throw new SkillSelectionError("CACHED_PROFILE_EXPIRED", "The cached Skills profile has expired; authenticate and sync it again.");
+  }
+}
+function projectSelectionLockPath(projectDir) {
+  return join24(resolve7(projectDir), ".skills", SELECTION_LOCK_FILE);
+}
+function readProjectSelection(projectDir) {
+  const receipt = readSelectionJson(projectSelectionLockPath(projectDir));
+  if (receipt)
+    validateSelectionReceipt(receipt);
+  return receipt;
+}
+function sessionReceiptPath(sessionId, options = {}) {
+  if (!sessionId.trim() || sessionId.length > 256)
+    throw new SkillSelectionError("INVALID_SESSION", "A Skills session id must contain 1\u2013256 characters.");
+  return join24(selectionCacheRoot(options), "sessions", `${hash2(sessionId)}.json`);
+}
+function readSkillSession(sessionId, options = {}) {
+  const receipt = readSelectionJson(sessionReceiptPath(sessionId, options));
+  if (receipt) {
+    validateSelectionReceipt(receipt);
+    if (receipt.sessionId !== sessionId || !Array.isArray(receipt.loaded) || !receipt.loaded.every((key) => /^[a-f0-9]{64}$/.test(key))) {
+      throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt is invalid.");
+    }
+  }
+  return receipt;
+}
+
+// src/lib/selected-document.ts
+var DOCUMENT_PATHS = ["SKILL.md", "README.md", "CLAUDE.md"];
+function readSelectedDocument(entries, file) {
+  const entry = file !== undefined ? entries.find((candidate) => candidate.path === file) : DOCUMENT_PATHS.map((path) => entries.find((candidate) => candidate.path === path && candidate.bytes.length > 0)).find(Boolean);
+  if (!entry) {
+    if (file !== undefined)
+      throw new SkillSelectionError("SKILL_FILE_MISSING", "The selected skill bundle does not contain that file.");
+    throw new SkillSelectionError("SKILL_DOCS_MISSING", "The selected bundle has no nonempty SKILL.md, README.md, or CLAUDE.md. Use skills load <slug>@<version> --file <path> to read an exact bundle file; loading context never runs the skill.");
+  }
+  try {
+    return { file: entry.path, content: new TextDecoder("utf-8", { fatal: true }).decode(entry.bytes) };
+  } catch {
+    throw new SkillSelectionError("SKILL_FILE_NOT_TEXT", "The selected bundle file is not valid UTF-8 text; choose a documentation file with --file.");
+  }
+}
+
+// src/lib/selection-resolver.ts
+async function syncSelectionProfile(profileId, options = {}) {
+  const client = options.client ?? await createProfileClient();
+  const profile = await client.resolveProfile(profileId);
+  validateResolvedProfile(profile, client.authority);
+  if (profile.profileId !== profileId)
+    throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The API returned a different selection profile.");
+  const previous = readSelectionProfile(profileId, options);
+  const changed = !previous || JSON.stringify(previous.profile) !== JSON.stringify(profile);
+  let downloaded = 0;
+  for (const selection of profile.selections) {
+    const entries = await readCachedSelection(selection, options);
+    if (entries)
+      continue;
+    if (options.check) {
+      downloaded++;
+      continue;
+    }
+    await cacheSelectionBundle(selection, await client.getBundle(selection.slug, selection.version), options);
+    downloaded++;
+  }
+  if (options.check)
+    return { profile, receipt: previous, changed: changed || downloaded > 0, downloaded, stationReported: false };
+  const receipt = activateSelectionProfile(profile, options);
+  if (options.projectDir)
+    writeSelectionJson(projectSelectionLockPath(options.projectDir), receipt);
+  let stationReported = false;
+  if (options.stationId) {
+    try {
+      await client.recordStation(options.stationId, {
+        profileId: profile.profileId,
+        profileRevision: profile.profileRevision,
+        selections: profile.selections
+      });
+    } catch {
+      throw new SkillSelectionError("PROFILE_APPLIED_REPORT_FAILED", "The verified Skills profile is active, but the station receipt could not be reported. Retry sync to confirm the station state.");
+    }
+    stationReported = true;
+  }
+  return { profile, receipt, changed, downloaded, stationReported };
+}
+async function resolveSelectionContext(profileId, options = {}) {
+  const session = options.sessionId ? readSkillSession(options.sessionId, options) : null;
+  const parentSession = !session && options.parentSessionId ? readSkillSession(options.parentSessionId, options) : null;
+  const project = options.projectDir ? readProjectSelection(options.projectDir) : null;
+  if (session && session.profile.profileId !== profileId || parentSession && parentSession.profile.profileId !== profileId || project && project.profile.profileId !== profileId) {
+    throw new SkillSelectionError("PROFILE_LOCK_MISMATCH", "The session or project is pinned to a different Skills profile. Select that profile or explicitly sync the new selection.");
+  }
+  if (options.cached) {
+    const receipt2 = session ?? parentSession ?? project ?? readSelectionProfile(profileId, options);
+    if (!receipt2)
+      throw new SkillSelectionError("CACHED_PROFILE_MISSING", "No verified Skills profile is cached; authenticate and sync it first.");
+    assertFreshCachedProfile(receipt2, options);
+    assertBinding(receipt2.profile, options);
+    return { receipt: receipt2, session, inheritedLoaded: parentSession?.loaded };
+  }
+  const client = options.client ?? await createProfileClient();
+  const current = await client.resolveProfile(profileId);
+  validateResolvedProfile(current, client.authority);
+  if (current.profileId !== profileId)
+    throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The API returned a different selection profile.");
+  assertBinding(current, options);
+  const locked2 = session ?? parentSession ?? project;
+  if (locked2 && (locked2.profile.authority !== current.authority || locked2.profile.workspaceId !== current.workspaceId)) {
+    throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The pinned selection belongs to another Skills authority or workspace.");
+  }
+  const receipt = locked2 ?? { schemaVersion: 1, verifiedAt: new Date((options.now ?? Date.now)()).toISOString(), profile: current };
+  return { receipt, session, client, inheritedLoaded: parentSession?.loaded };
+}
+function assertBinding(profile, options) {
+  if (options.authority !== undefined && profile.authority !== options.authority || options.workspaceId !== undefined && profile.workspaceId !== options.workspaceId) {
+    throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The cached selection belongs to another Skills authority or workspace.");
+  }
+}
+async function readSelectedEntries(selection, context, options = {}) {
+  if (options.cached) {
+    const entries = await readCachedSelection(selection, options);
+    if (!entries)
+      throw new SkillSelectionError("CACHED_BUNDLE_MISSING", "The exact selected bundle is not cached. Cached mode cannot fetch or use an authoring draft.");
+    return entries;
+  }
+  const client = context.client ?? options.client ?? await createProfileClient();
+  return cacheSelectionBundle(selection, await client.getBundle(selection.slug, selection.version), options);
+}
+function exactProfileSelection(spec, profile) {
+  const at = spec.lastIndexOf("@");
+  const slug = at > 0 ? spec.slice(0, at) : spec;
+  const version = at > 0 ? spec.slice(at + 1) : undefined;
+  const selection = profile.selections.find((entry) => entry.slug === slug && (version === undefined || version === entry.version));
+  if (!selection || version === "")
+    throw new SkillSelectionError("SKILL_NOT_SELECTED", "The requested exact skill version is not selected by this profile or project lock.");
+  return selection;
+}
+
+// src/lib/skill-context.ts
+function words(value) {
+  return new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
+}
+function pathMatch(pattern, path) {
+  if (!pattern || pattern.length > 512)
+    return false;
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\x00").replace(/\*/g, "[^/]*").replace(/\u0000/g, ".*");
+  return new RegExp(`^(?:${escaped})$`).test(path.replace(/\\/g, "/"));
+}
+async function buildSkillContext(input, options = {}) {
+  const prompt = input.prompt ?? "";
+  if (prompt.length > 128 * 1024 || (input.paths?.length ?? 0) > 100 || (input.skills?.length ?? 0) > 100) {
+    throw new SkillSelectionError("CONTEXT_INPUT_TOO_LARGE", "The Skills context input exceeds its size limit.");
+  }
+  const maxChars = options.maxChars ?? 8000;
+  const maxSkills = options.maxSkills ?? 3;
+  if (!Number.isInteger(maxChars) || maxChars < 512 || maxChars > 64000 || !Number.isInteger(maxSkills) || maxSkills < 1 || maxSkills > 20) {
+    throw new SkillSelectionError("INVALID_CONTEXT_BUDGET", "Context limits must be 512\u201364000 characters and 1\u201320 skills.");
+  }
+  const profileId = input.profileId ?? "default";
+  const sessionId = input.sessionId ? input.agentId ? `${input.sessionId}:${input.agentId}` : input.sessionId : undefined;
+  const resolverOptions = { ...options, projectDir: input.cwd ?? options.projectDir, sessionId, parentSessionId: input.agentId ? input.sessionId : undefined };
+  const resolved = await resolveSelectionContext(profileId, resolverOptions);
+  const profile = resolved.receipt.profile;
+  const explicit = new Set((input.skills ?? []).map((spec) => selectionKey(exactProfileSelection(spec, profile))));
+  for (const match of prompt.matchAll(/\$([a-z0-9]+(?:-[a-z0-9]+)*(?:@[a-zA-Z0-9._-]+)?)/g)) {
+    const spec = match[1];
+    const slug = spec.split("@")[0];
+    if (profile.selections.some((entry) => entry.slug === slug))
+      explicit.add(selectionKey(exactProfileSelection(spec, profile)));
+  }
+  const promptWords = words(prompt);
+  const loaded = new Set(resolved.session?.loaded ?? []);
+  const paths = [...input.paths ?? [], ...input.cwd ? [input.cwd, resolve8(input.cwd)] : []];
+  const candidates = profile.selections.map((selection) => {
+    const key = selectionKey(selection);
+    if (input.restore && loaded.has(key))
+      return { selection, reason: "session-restore", score: 2000 };
+    if (resolved.inheritedLoaded?.includes(key))
+      return { selection, reason: "subagent-inherit", score: 2000 };
+    if (explicit.has(key))
+      return { selection, reason: "explicit", score: 1000 };
+    if (selection.triggers?.always)
+      return { selection, reason: "profile-required", score: 900 };
+    const matchedPath = selection.triggers?.paths?.some((pattern) => paths.some((path) => pathMatch(pattern, path)));
+    if (matchedPath)
+      return { selection, reason: "path", score: 500 };
+    const keywords = selection.triggers?.keywords ?? selection.slug.split("-").filter((word) => word.length >= 4);
+    const matches = keywords.filter((keyword) => {
+      const tokens = [...words(keyword)];
+      return tokens.length > 0 && tokens.every((token) => promptWords.has(token));
+    }).length;
+    return { selection, reason: "prompt", score: matches * 100 };
+  }).filter((candidate) => candidate.score > 0).sort((a, b) => b.score - a.score || a.selection.slug.localeCompare(b.selection.slug));
+  const sections = [];
+  const selections = [];
+  const omitted = [];
+  let chars = 0;
+  for (const candidate of candidates) {
+    const { selection, reason } = candidate;
+    if (!input.restore && !explicit.has(selectionKey(selection)) && loaded.has(selectionKey(selection)))
+      continue;
+    const loadCommand = `skills load ${selection.slug}@${selection.version} --selection-profile ${profile.profileId}`;
+    if (selections.length >= maxSkills) {
+      omitted.push({ slug: selection.slug, version: selection.version, reason: "skill-limit", loadCommand });
+      continue;
+    }
+    const entries = await readSelectedEntries(selection, resolved, resolverOptions);
+    const { content } = readSelectedDocument(entries);
+    const section = `Skill ${selection.slug}@${selection.version} (${selection.bundleDigest}; ${reason})
+${content}`;
+    if (chars + section.length + (sections.length ? 2 : 0) > maxChars) {
+      omitted.push({ slug: selection.slug, version: selection.version, reason: "context-budget", loadCommand });
+      continue;
+    }
+    chars += section.length + (sections.length ? 2 : 0);
+    sections.push(section);
+    selections.push({ ...selection, reason });
+    loaded.add(selectionKey(selection));
+  }
+  const context = sections.join(`
+
+`);
+  const receipt = {
+    schemaVersion: 1,
+    id: createHash12("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
+    profileId: profile.profileId,
+    profileRevision: profile.profileRevision,
+    authority: profile.authority,
+    workspaceId: profile.workspaceId,
+    source: options.cached ? "verified-cache" : "api",
+    ...sessionId ? { sessionId } : {},
+    restored: Boolean(input.restore),
+    chars: context.length,
+    selections
+  };
+  if (sessionId)
+    writeSelectionJson(sessionReceiptPath(sessionId, options), { ...resolved.receipt, sessionId, loaded: [...loaded] });
+  return { context, selections, omitted, receipt };
+}
 export {
   writeStationSnapshot,
   writeStationHydration,
@@ -16744,6 +17678,7 @@ export {
   unpinSkill,
   unpinProjectSkill,
   syncSkillsToAgents,
+  syncSelectionProfile,
   summarizeMcpToolContract,
   storageCapabilities,
   skillsPostgresSyncSchemaSql,
@@ -16793,6 +17728,7 @@ export {
   planStationSnapshot,
   planStationHydration,
   planSkillsS3SnapshotUpload,
+  planAgentIntegration,
   pinSkill,
   pinProjectSkill,
   parseSkillFrontmatter,
@@ -16825,6 +17761,7 @@ export {
   isGatewayBackedSkill,
   isExcludedSkillFileName,
   isBasicSkillName,
+  inventoryNativeSkills,
   installSkills,
   installSkillSource,
   installSkillManifest,
@@ -16892,6 +17829,7 @@ export {
   createSkillMcpMetadata,
   createRemoteSkillsClient,
   createRegistrySyncArtifact,
+  createProfileClient,
   createMcpContractManifest,
   createLocalSkillManifest,
   continuePrivatePublication,
@@ -16903,6 +17841,9 @@ export {
   canonicalizeManifest,
   buildSkillsS3ObjectUrl,
   buildSkillsApiUrl,
+  buildSkillContext,
+  archiveNativeSkills,
+  applyAgentIntegration,
   appendRunEvent,
   agentGlobalSkillsDir,
   addSchedule,
@@ -16971,6 +17912,7 @@ export {
   MissingSkillsFleetError,
   MCP_CONTRACT_SCHEMA_VERSION,
   InvitationEmailInputError,
+  HttpProfileClient,
   HostedApiError,
   DEFAULT_EXPORT_DIR,
   ContentHashInputError,