@hasna/skills 0.10.47 → 0.10.49

package/dist/index.js

@@ -6988,7 +6988,7 @@ var require_public_api = __commonJS((exports) => {
 });
 
 // src/lib/registry.ts
-import { existsSync as existsSync15, readFileSync as readFileSync20, readdirSync as readdirSync12 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync21, readdirSync as readdirSync12 } from "fs";
 import { join as join35 } from "path";
 
 // src/lib/config.ts
@@ -7256,13 +7256,13 @@ import {
   mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync2,
   readdirSync as readdirSync11,
-  realpathSync as realpathSync12,
+  realpathSync as realpathSync13,
   renameSync as renameSync6,
   rmSync as rmSync4,
   statSync as statSync11,
   writeFileSync as writeFileSync9
 } from "fs";
-import { basename as basename12, dirname as dirname21, isAbsolute as isAbsolute19, join as join34, normalize as normalize4, relative as relative7, resolve as resolve20, sep as sep10 } from "path";
+import { basename as basename12, dirname as dirname21, isAbsolute as isAbsolute20, join as join34, normalize as normalize4, relative as relative7, resolve as resolve20, sep as sep10 } from "path";
 
 // src/lib/registry-data/index.ts
 var SKILLS = [];
@@ -8920,7 +8920,7 @@ var NATIVE_SKILL_ROOTS = [
 ];
 
 // src/lib/authoring-path.ts
-import { lstatSync as lstatSync25, realpathSync as realpathSync11 } from "fs";
+import { lstatSync as lstatSync26, realpathSync as realpathSync12 } from "fs";
 import { homedir as homedir6 } from "os";
 import { basename as basename11, dirname as dirname20, join as join33, resolve as resolve19, sep as sep9 } from "path";
 
@@ -9538,9 +9538,9 @@ function assertAgentPolicyCollections(policy) {
 }
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash23 } from "crypto";
-import { lstatSync as lstatSync24, readFileSync as readFileSync19, readdirSync as readdirSync10, realpathSync as realpathSync10 } from "fs";
-import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute18, join as join32, resolve as resolve18, sep as sep8 } from "path";
+import { createHash as createHash24 } from "crypto";
+import { lstatSync as lstatSync25, readFileSync as readFileSync20, readdirSync as readdirSync10, realpathSync as realpathSync11 } from "fs";
+import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute19, join as join32, resolve as resolve18, sep as sep8 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
 
 // node_modules/yaml/dist/index.js
@@ -10230,12 +10230,12 @@ function projectReviewedClaudePluginManifest(text2, reviewedSha256) {
 }
 
 // src/lib/plugin-discovery.ts
-import { closeSync as closeSync12, constants as constants12, fstatSync as fstatSync12, lstatSync as lstatSync22, openSync as openSync12, opendirSync as opendirSync5, readSync as readSync10 } from "fs";
-import { basename as basename8, dirname as dirname17, isAbsolute as isAbsolute16, join as join31, resolve as resolve16 } from "path";
+import { closeSync as closeSync13, constants as constants13, fstatSync as fstatSync13, lstatSync as lstatSync23, openSync as openSync13, opendirSync as opendirSync5, readSync as readSync10 } from "fs";
+import { basename as basename8, dirname as dirname17, isAbsolute as isAbsolute17, join as join31, resolve as resolve16 } from "path";
 
 // src/lib/plugin-admission.ts
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute15, join as join30, resolve as resolve15 } from "path";
+import { isAbsolute as isAbsolute16, join as join30, resolve as resolve15 } from "path";
 
 // src/lib/selection-cache.ts
 import { createHash as createHash9, randomUUID } from "crypto";
@@ -11572,7 +11572,7 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.47",
+  version: "0.10.49",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -13401,7 +13401,7 @@ async function prepareSkillDependencies(skillPath, env, timeoutMs = DEFAULT_PREP
 }
 
 // src/lib/skillinfo.ts
-import { existsSync as existsSync13, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync19 } from "fs";
 import { join as join28 } from "path";
 
 // src/lib/codex-corpus-write.ts
@@ -13566,7 +13566,7 @@ function withCodexCorpusWrite(roots, run, options = {}) {
 }
 
 // src/lib/installer.ts
-import { existsSync as existsSync12, readFileSync as readFileSync17, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync18, rmSync as rmSync2 } from "fs";
 import { join as join27 } from "path";
 import { homedir as homedir4 } from "os";
 
@@ -13574,10 +13574,10 @@ import { homedir as homedir4 } from "os";
 import {
   cpSync as cpSync2,
   existsSync as existsSync10,
-  lstatSync as lstatSync20,
+  lstatSync as lstatSync21,
   mkdirSync as mkdirSync7,
   mkdtempSync,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync9,
   renameSync as renameSync4,
   rmSync,
@@ -15501,10 +15501,10 @@ function upgradeCodexSettingsWitnessV4(previous, reviewedSettingsPath) {
 }
 
 // src/lib/agent-integration.ts
-import { createHash as createHash18, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash19, randomUUID as randomUUID3 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual6 } from "util";
-import { existsSync as existsSync9, lstatSync as lstatSync19, statSync as statSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync14, readdirSync as readdirSync8, opendirSync as opendirSync3, readlinkSync as readlinkSync5, realpathSync as realpathSync9, renameSync as renameSync3, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, chmodSync, openSync as openSync10, closeSync as closeSync10, fsyncSync as fsyncSync4, fstatSync as fstatSync10, readSync as readSync8, constants as constants10, linkSync as linkSync2 } from "fs";
-import { dirname as dirname14, join as join23, resolve as resolve13, relative as relative6, isAbsolute as isAbsolute13, sep as sep7 } from "path";
+import { existsSync as existsSync9, lstatSync as lstatSync20, statSync as statSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync15, readdirSync as readdirSync8, opendirSync as opendirSync3, readlinkSync as readlinkSync6, realpathSync as realpathSync10, renameSync as renameSync3, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, chmodSync, openSync as openSync11, closeSync as closeSync11, fsyncSync as fsyncSync5, fstatSync as fstatSync11, readSync as readSync8, constants as constants11, linkSync as linkSync2 } from "fs";
+import { dirname as dirname14, join as join23, resolve as resolve13, relative as relative6, isAbsolute as isAbsolute14, sep as sep7 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/lib/managed-policy.ts
@@ -16068,8 +16068,144 @@ function unchanged2(before) {
   need5(sameStat(before.stat, after.stat) && after.sha256 === before.sha256, "INPUT_CHANGED");
 }
 
+// src/cli/commands/runtime-launcher.ts
+import { createHash as createHash18 } from "crypto";
+import { closeSync as closeSync10, constants as constants10, fchmodSync, fstatSync as fstatSync10, fsyncSync as fsyncSync4, lstatSync as lstatSync19, openSync as openSync10, readFileSync as readFileSync14, readlinkSync as readlinkSync5, realpathSync as realpathSync9, symlinkSync, writeSync as writeSync2 } from "fs";
+import { isAbsolute as isAbsolute13 } from "path";
+var PINNED_LAUNCHER_SCHEMA = "hasna-skills-pinned-launcher-v1";
+var LAUNCH_CWD_VARIABLE = "HASNA_SKILLS_LAUNCH_CWD";
+var PINNED_LAUNCHER_BUN_FLAGS = ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install"];
+var PINNED_LAUNCHER_ENV_NAMES = [
+  "HOME",
+  "PATH",
+  "TMPDIR",
+  "TERM",
+  "TERM_PROGRAM",
+  "TERM_PROGRAM_VERSION",
+  "COLORTERM",
+  "LANG",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "TZ",
+  "NO_COLOR",
+  "FORCE_COLOR",
+  "CI",
+  "COLUMNS",
+  "LINES",
+  "EDITOR",
+  "VISUAL",
+  "PAGER",
+  "SSH_AUTH_SOCK",
+  "DATABASE_URL",
+  "TERMINAL_CWD",
+  "CODEX_HOME",
+  "HERMES_HOME",
+  "HERMES_ENABLE_PROJECT_PLUGINS",
+  "HOST",
+  "PORT",
+  "NODE_ENV",
+  "AGENT_ID",
+  "ECS_CONTAINER_METADATA_URI_V4"
+];
+var PINNED_LAUNCHER_ENV_PREFIXES = ["HASNA", "SKILLS", "SKILL", "MCP", "XDG", "LC", "AWS"];
+var ENV_PREFIX = new RegExp(`^(${PINNED_LAUNCHER_ENV_PREFIXES.join("|")})_`);
+var ENV_EXACT = new Set(PINNED_LAUNCHER_ENV_NAMES);
+function sha2562(bytes) {
+  return createHash18("sha256").update(bytes).digest("hex");
+}
+function assertLauncherPath(value, code) {
+  if (typeof value !== "string" || !isAbsolute13(value) || /['\x00-\x1f\x7f]/.test(value))
+    throw new Error(code);
+}
+function renderPinnedLauncher(binding) {
+  assertLauncherPath(binding.runtime, "LAUNCHER_RUNTIME_PATH_INVALID");
+  assertLauncherPath(binding.cwd, "LAUNCHER_CWD_PATH_INVALID");
+  assertLauncherPath(binding.entry, "LAUNCHER_ENTRY_PATH_INVALID");
+  const names = PINNED_LAUNCHER_ENV_NAMES.join(" ");
+  const prefixes = PINNED_LAUNCHER_ENV_PREFIXES.join("|");
+  return [
+    "#!/bin/sh -p",
+    `# ${PINNED_LAUNCHER_SCHEMA}`,
+    "# Written by `skills self-update`; rewrite it with `skills self-update`, do not edit by hand.",
+    "# Runs the exact Skills entry below under one exact Bun from one trusted directory with",
+    "# no working-directory configuration (no bunfig.toml, no .env, no macros, no auto-install)",
+    "# and only the environment names allowed here. Everything else, BUN_* and NODE_OPTIONS",
+    "# included, never reaches the runtime. The CLI returns to the caller's directory itself.",
+    "# `-p` keeps the caller's exported functions and shell options out of this shell.",
+    "set -eu",
+    `${LAUNCH_CWD_VARIABLE}=$(pwd -P 2>/dev/null || :)`,
+    `export ${LAUNCH_CWD_VARIABLE}`,
+    `set -- '${binding.runtime}' ${PINNED_LAUNCHER_BUN_FLAGS.join(" ")} '--cwd=${binding.cwd}' '${binding.entry}' "$@"`,
+    "hasna_skills_env=$(LC_ALL=C /usr/bin/awk 'BEGIN {",
+    `  n = split("${names}", exact, " ")`,
+    "  for (i = 1; i <= n; i++) allow[exact[i]] = 1",
+    "  for (name in ENVIRON) {",
+    "    if (name !~ /^[A-Za-z_][A-Za-z0-9_]*$/) continue",
+    `    if (name == "LC_ALL" || (!(name in allow) && name !~ /^(${prefixes})_/)) continue`,
+    '    value = ENVIRON[name]; quoted = ""',
+    '    while ((k = index(value, "\\047")) > 0) { quoted = quoted substr(value, 1, k - 1) "\\047\\\\\\047\\047"; value = substr(value, k + 1) }',
+    '    printf "\\047%s=%s\\047 ", name, quoted value',
+    "  }",
+    "}')",
+    'eval "set -- $hasna_skills_env \\"\\$@\\""',
+    'if [ "${LC_ALL+x}" = x ]; then set -- "LC_ALL=$LC_ALL" "$@"; fi',
+    'exec /usr/bin/env -i "$@"',
+    ""
+  ].join(`
+`);
+}
+var COMMAND_LINE = new RegExp(`^set -- '([^']+)' ${PINNED_LAUNCHER_BUN_FLAGS.join(" ")} '--cwd=([^']+)' '([^']+)' "\\$@"$`, "m");
+function parsePinnedLauncher(text2) {
+  const match = COMMAND_LINE.exec(text2);
+  if (!match)
+    return null;
+  const binding = { runtime: match[1], cwd: match[2], entry: match[3] };
+  try {
+    if (renderPinnedLauncher(binding) !== text2)
+      return null;
+  } catch {
+    return null;
+  }
+  return binding;
+}
+var PINNED_LAUNCHER_MAX_BYTES = 16 * 1024;
+function resolveLauncherCommand(path) {
+  const physical = realpathSync9(path);
+  const stat = lstatSync19(physical);
+  if (stat.isFile() && stat.size <= PINNED_LAUNCHER_MAX_BYTES) {
+    const text2 = readFileSync14(physical, "utf8");
+    const binding = parsePinnedLauncher(text2);
+    if (binding) {
+      let entry;
+      try {
+        entry = realpathSync9(binding.entry);
+      } catch {
+        throw new Error("LAUNCHER_ENTRY_UNREADABLE");
+      }
+      if (entry !== binding.entry)
+        throw new Error("LAUNCHER_ENTRY_NOT_PHYSICAL");
+      return { physical, entry, pinned: { ...binding, sha256: sha2562(text2) } };
+    }
+  }
+  return { physical, entry: physical, pinned: null };
+}
+function assertPinnedLauncherRuntimeSafe(runtime) {
+  assertLauncherPath(runtime, "LAUNCHER_RUNTIME_PATH_INVALID");
+  let stat;
+  try {
+    stat = lstatSync19(runtime);
+  } catch {
+    throw new Error("LAUNCHER_RUNTIME_UNSAFE");
+  }
+  const uid = process.getuid?.() ?? -1;
+  if (!stat.isFile() || stat.isSymbolicLink() || ![0, uid].includes(stat.uid) || (stat.mode & 18) !== 0 || (stat.mode & 64) === 0) {
+    throw new Error("LAUNCHER_RUNTIME_UNSAFE");
+  }
+}
+
 // src/lib/agent-integration.ts
-var sha3 = (data) => createHash18("sha256").update(data).digest("hex");
+var sha3 = (data) => createHash19("sha256").update(data).digest("hex");
 var ROOTS = NATIVE_SKILL_ROOTS;
 function hasTrustedDarwinAcl(fd, allowDenyOnly = false) {
   try {
@@ -16120,11 +16256,11 @@ function isSystemRootAlias(path) {
   const target = `/private${path}`, link = `private${path}`;
   const identity5 = (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}`;
   try {
-    const before = lstatSync19(path, { bigint: true });
-    if (!before.isSymbolicLink() || before.uid !== 0n || readlinkSync5(path) !== link)
+    const before = lstatSync20(path, { bigint: true });
+    if (!before.isSymbolicLink() || before.uid !== 0n || readlinkSync6(path) !== link)
       return false;
     const directories = ["/", "/private", target].map((directory) => {
-      const stat = lstatSync19(directory, { bigint: true });
+      const stat = lstatSync20(directory, { bigint: true });
       if (!stat.isDirectory() || stat.uid !== 0n)
         throw new Error("Untrusted system alias directory");
       if (directory !== "/private/tmp") {
@@ -16132,23 +16268,23 @@ function isSystemRootAlias(path) {
           throw new Error("Writable system alias directory");
       } else if ((stat.mode & 0o1000n) === 0n)
         throw new Error("Unprotected system temporary directory");
-      const fd = openSync10(directory, constants10.O_RDONLY | constants10.O_DIRECTORY | constants10.O_NOFOLLOW);
+      const fd = openSync11(directory, constants11.O_RDONLY | constants11.O_DIRECTORY | constants11.O_NOFOLLOW);
       try {
-        if (identity5(fstatSync10(fd, { bigint: true })) !== identity5(stat) || !hasTrustedDarwinAcl(fd) || identity5(fstatSync10(fd, { bigint: true })) !== identity5(stat))
+        if (identity5(fstatSync11(fd, { bigint: true })) !== identity5(stat) || !hasTrustedDarwinAcl(fd) || identity5(fstatSync11(fd, { bigint: true })) !== identity5(stat))
           throw new Error("Unverified system alias directory ACL");
       } finally {
-        closeSync10(fd);
+        closeSync11(fd);
       }
       return { directory, identity: identity5(stat) };
     });
-    return realpathSync9(path) === target && readlinkSync5(path) === link && identity5(lstatSync19(path, { bigint: true })) === identity5(before) && directories.every((item) => identity5(lstatSync19(item.directory, { bigint: true })) === item.identity);
+    return realpathSync10(path) === target && readlinkSync6(path) === link && identity5(lstatSync20(path, { bigint: true })) === identity5(before) && directories.every((item) => identity5(lstatSync20(item.directory, { bigint: true })) === item.identity);
   } catch {
     return false;
   }
 }
 function canonicalSystemPath(path) {
   const absolute = resolve13(path), root = `/${absolute.split(sep7)[1]}`;
-  if (process.platform !== "darwin" || !["/var", "/tmp", "/etc"].includes(root) || !lstatSync19(root, { throwIfNoEntry: false })?.isSymbolicLink())
+  if (process.platform !== "darwin" || !["/var", "/tmp", "/etc"].includes(root) || !lstatSync20(root, { throwIfNoEntry: false })?.isSymbolicLink())
     return absolute;
   if (!isSystemRootAlias(root))
     throw new Error(`Refusing symlink path: ${root}`);
@@ -16157,7 +16293,7 @@ function canonicalSystemPath(path) {
 function assertSafePath(path) {
   let cursor = resolve13(path);
   while (true) {
-    if (lstatSync19(cursor, { throwIfNoEntry: false })?.isSymbolicLink() && !isSystemRootAlias(cursor))
+    if (lstatSync20(cursor, { throwIfNoEntry: false })?.isSymbolicLink() && !isSystemRootAlias(cursor))
       throw new Error(`Refusing symlink path: ${cursor}`);
     const parent = dirname14(cursor);
     if (parent === cursor)
@@ -16167,17 +16303,17 @@ function assertSafePath(path) {
 }
 function readRootAlias(home, agent) {
   assertSafePath(home);
-  const realHome = realpathSync9(home), alias = join23(realHome, `.${agent}`);
-  const stat = lstatSync19(alias, { throwIfNoEntry: false, bigint: true });
+  const realHome = realpathSync10(home), alias = join23(realHome, `.${agent}`);
+  const stat = lstatSync20(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link = readlinkSync5(alias), targetPath = resolve13(dirname14(alias), link);
+  const link = readlinkSync6(alias), targetPath = resolve13(dirname14(alias), link);
   assertSafePath(targetPath);
-  const targetStat = lstatSync19(targetPath, { throwIfNoEntry: false });
+  const targetStat = lstatSync20(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
     throw new Error(`Agent root alias must target an existing directory: ${alias}`);
-  const target = realpathSync9(targetPath), inside = relative6(realHome, target);
-  if (!inside || inside === ".." || inside.startsWith(`..${sep7}`) || isAbsolute13(inside))
+  const target = realpathSync10(targetPath), inside = relative6(realHome, target);
+  if (!inside || inside === ".." || inside.startsWith(`..${sep7}`) || isAbsolute14(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}` };
 }
@@ -16186,7 +16322,7 @@ function rootAliases(home, allowed = false) {
     return [];
   const result = [];
   for (const agent of ["claude", "codex"])
-    if (lstatSync19(join23(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync20(join23(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 + sep7) || other.target.startsWith(item.target + sep7))))
     throw new Error("Agent root alias targets must not overlap");
@@ -16203,17 +16339,17 @@ function disabledCodexSkillPaths(config, aliases) {
   const rows = skills.config;
   if (!Array.isArray(rows))
     return [];
-  if (rows.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.enabled !== "boolean" || entry.path !== undefined === (entry.name !== undefined) || entry.path !== undefined && (typeof entry.path !== "string" || !isAbsolute13(entry.path)) || entry.name !== undefined && (typeof entry.name !== "string" || !entry.name.trim())))
+  if (rows.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.enabled !== "boolean" || entry.path !== undefined === (entry.name !== undefined) || entry.path !== undefined && (typeof entry.path !== "string" || !isAbsolute14(entry.path)) || entry.name !== undefined && (typeof entry.name !== "string" || !entry.name.trim())))
     return [];
   if (rows.some((entry) => entry.name !== undefined && entry.enabled !== false))
     return [];
   const settings = new Map;
   for (const entry of rows) {
-    if (typeof entry.path !== "string" || !isAbsolute13(entry.path))
+    if (typeof entry.path !== "string" || !isAbsolute14(entry.path))
       continue;
     let document2;
     try {
-      document2 = realpathSync9(canonicalAgentPath(entry.path, aliases));
+      document2 = realpathSync10(canonicalAgentPath(entry.path, aliases));
     } catch {
       continue;
     }
@@ -16234,16 +16370,16 @@ function recheckRootAliases(aliases) {
 }
 function nativeSourceDigest(path) {
   assertSafePath(path);
-  return lstatSync19(path, { throwIfNoEntry: false }) ? sha3(readNativeBytes(path, 1024 * 1024)) : null;
+  return lstatSync20(path, { throwIfNoEntry: false }) ? sha3(readNativeBytes(path, 1024 * 1024)) : null;
 }
 function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
   assertSafePath(path);
-  const before = lstatSync19(path);
+  const before = lstatSync20(path);
   if (!before.isFile() || before.size > maximum)
     throw new Error("Unsupported or oversized native skill file");
-  const descriptor = openSync10(path, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
+  const descriptor = openSync11(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
   try {
-    const opened = fstatSync10(descriptor);
+    const opened = fstatSync11(descriptor);
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size)
       throw new Error("Native skill file changed while reading");
     const bytes = Buffer.allocUnsafe(before.size + 1);
@@ -16254,19 +16390,19 @@ function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
         break;
       length += count;
     }
-    const after = fstatSync10(descriptor), current = lstatSync19(path);
+    const after = fstatSync11(descriptor), current = lstatSync20(path);
     if (current.dev !== opened.dev || current.ino !== opened.ino || current.size !== after.size || current.mtimeMs !== after.mtimeMs || current.ctimeMs !== after.ctimeMs || length !== before.size || after.size !== before.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs)
       throw new Error("Native skill file changed while reading");
     return bytes.subarray(0, length);
   } finally {
-    closeSync10(descriptor);
+    closeSync11(descriptor);
   }
 }
 function treeHash(root) {
-  const hash2 = createHash18("sha256");
+  const hash2 = createHash19("sha256");
   let bytes = 0, files = 0;
   function visit2(path) {
-    const stat = lstatSync19(path);
+    const stat = lstatSync20(path);
     if (stat.isSymbolicLink())
       throw new Error(`Refusing symlink in skill: ${path}`);
     const rel = relative6(root, path);
@@ -16295,13 +16431,13 @@ function selectNativeMigrationTargets(inventory, manifest) {
   const identities = new Set;
   const selected = [];
   for (const target of manifest.targets) {
-    if (!isAbsolute13(target.projectRoot) || resolve13(target.projectRoot) !== target.projectRoot)
+    if (!isAbsolute14(target.projectRoot) || resolve13(target.projectRoot) !== target.projectRoot)
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
     const projectRoot = canonicalSystemPath(target.projectRoot), normalized = relative6(projectRoot, resolve13(projectRoot, target.path));
-    if (!existsSync9(projectRoot) || !lstatSync19(projectRoot).isDirectory())
+    if (!existsSync9(projectRoot) || !lstatSync20(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
     assertSafePath(projectRoot);
-    if (isAbsolute13(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
+    if (isAbsolute14(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
       throw new Error(`Invalid native migration target: ${target.path}`);
     const identity5 = `${target.agent}\x00${canonicalSystemPath(projectRoot)}\x00${normalized}`;
     if (identities.has(identity5))
@@ -16344,9 +16480,9 @@ function isCodexSkillDiscoveryInput(path) {
 }
 function inventoryNativeSkills(home = homedir2(), options = {}) {
   home = canonicalSystemPath(home);
-  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute13(options.reviewedCacheAlias) || resolve13(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
+  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute14(options.reviewedCacheAlias) || resolve13(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
     throw new Error("A reviewed cache alias requires vendor inventory and an exact absolute path");
-  if (options.disabledVendorPaths?.some((path) => !isAbsolute13(path) || resolve13(path) !== path))
+  if (options.disabledVendorPaths?.some((path) => !isAbsolute14(path) || resolve13(path) !== path))
     throw new Error("Disabled vendor paths must be exact absolute paths");
   const reviewedCacheAlias = options.reviewedCacheAlias === undefined ? undefined : canonicalSystemPath(options.reviewedCacheAlias);
   const disabledVendorPaths = new Set((options.disabledVendorPaths ?? []).map(canonicalSystemPath));
@@ -16365,7 +16501,7 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
           roots.push(["sumi", canonicalAgentPath(join23(project, directory, name), aliases)]);
   }
   const installationInputs = options.codexInstallationInputRoots ?? [];
-  if (installationInputs.some((input) => resolve13(input) !== input || realpathSync9(input) !== input || roots.some(([agent, path]) => agent === "codex" && (path === input || path.startsWith(input + sep7) || input.startsWith(path + sep7)))))
+  if (installationInputs.some((input) => resolve13(input) !== input || realpathSync10(input) !== input || roots.some(([agent, path]) => agent === "codex" && (path === input || path.startsWith(input + sep7) || input.startsWith(path + sep7)))))
     throw new Error("Native installation input overlaps an unconditional skill-loading root");
   const entries = [], seen = new Set;
   const cacheScans = new Map, maxAliasProofEntries = 1e4;
@@ -16379,13 +16515,13 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
   }
   let reviewedCacheAliasFound = false;
   function verifiedSiblingCacheAlias(agent, path, parent) {
-    const link = readlinkSync5(path), lexicalTarget = resolve13(parent, link);
-    if (isAbsolute13(link) ? link !== lexicalTarget : dirname14(link) !== ".")
+    const link = readlinkSync6(path), lexicalTarget = resolve13(parent, link);
+    if (isAbsolute14(link) ? link !== lexicalTarget : dirname14(link) !== ".")
       return false;
     const target = canonicalSystemPath(lexicalTarget);
     if (dirname14(target) !== parent)
       return false;
-    if (!lstatSync19(target, { throwIfNoEntry: false })?.isDirectory())
+    if (!lstatSync20(target, { throwIfNoEntry: false })?.isDirectory())
       return false;
     const scan = cacheScans.get(target);
     if (!scan?.complete || scan.entries > maxAliasProofEntries)
@@ -16410,7 +16546,7 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
       return scan;
     if (!existsSync9(path))
       return scan;
-    const stat = lstatSync19(path);
+    const stat = lstatSync20(path);
     if (stat.isFile()) {
       if (agent === "sumi" && depth === 1 && path.endsWith(".md"))
         throw new Error("NATIVE_SKILL_DRIFT: flat Sumi skill documents require a dedicated migration adapter");
@@ -16427,7 +16563,7 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
       const marker = join23(path, ".hasna-skills.json");
       if (existsSync9(marker)) {
         try {
-          managed = JSON.parse(readFileSync14(marker, "utf8")).managedBy === "@hasna/skills";
+          managed = JSON.parse(readFileSync15(marker, "utf8")).managedBy === "@hasna/skills";
         } catch {}
       }
       const bridge = (!vendor || agent === "sumi") && isOwnedCliBridge(path, bridgePaths);
@@ -16459,7 +16595,7 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
       if (isVendor && !options.includeVendor)
         continue;
       const child = join23(path, name);
-      if (isVendor && lstatSync19(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      if (isVendor && lstatSync20(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
         const target = statSync9(child, { throwIfNoEntry: false });
         if (target?.isFile() || pluginCache && target?.isDirectory() && verifiedSiblingCacheAlias(agent, child, path)) {
           scan.entries++;
@@ -16502,7 +16638,7 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
 }
 function readOptional(path) {
   assertSafePath(path);
-  return existsSync9(path) ? readFileSync14(path, "utf8") : null;
+  return existsSync9(path) ? readFileSync15(path, "utf8") : null;
 }
 function jsonObject(text2, path) {
   if (text2 === null)
@@ -16834,23 +16970,23 @@ function projectedHookAcl(path, observed) {
   if (process.platform !== "darwin")
     return;
   const identity5 = (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}:${stat.nlink}:${stat.size}:${stat.mtimeNs}`;
-  const fd = openSync10(path, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK | (observed.isDirectory() ? constants10.O_DIRECTORY : 0));
+  const fd = openSync11(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK | (observed.isDirectory() ? constants11.O_DIRECTORY : 0));
   try {
-    if (identity5(fstatSync10(fd, { bigint: true })) !== identity5(observed) || !hasTrustedDarwinAcl(fd, true) || identity5(fstatSync10(fd, { bigint: true })) !== identity5(observed) || identity5(lstatSync19(path, { bigint: true })) !== identity5(observed))
+    if (identity5(fstatSync11(fd, { bigint: true })) !== identity5(observed) || !hasTrustedDarwinAcl(fd, true) || identity5(fstatSync11(fd, { bigint: true })) !== identity5(observed) || identity5(lstatSync20(path, { bigint: true })) !== identity5(observed))
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
   } finally {
-    closeSync10(fd);
+    closeSync11(fd);
   }
 }
 function projectedHookExecutable(command, expectedResolved) {
   try {
-    if (!isAbsolute13(command) || /[\0\r\n]/.test(command) || resolve13(command) !== command)
+    if (!isAbsolute14(command) || /[\0\r\n]/.test(command) || resolve13(command) !== command)
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     command = canonicalSystemPath(command);
     const parents2 = (file = command) => {
       const result = [];
       for (let path = dirname14(file);; path = dirname14(path)) {
-        const stat = lstatSync19(path, { bigint: true });
+        const stat = lstatSync20(path, { bigint: true });
         if (!stat.isDirectory() || (stat.mode & 0o022n) !== 0n && !(stat.uid === 0n && (stat.mode & 0o1000n) !== 0n))
           hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
         projectedHookAcl(path, stat);
@@ -16860,13 +16996,22 @@ function projectedHookExecutable(command, expectedResolved) {
       }
       return result;
     };
-    const parentIdentity = parents2(), link = lstatSync19(command, { bigint: true });
+    const parentIdentity = parents2(), link = lstatSync20(command, { bigint: true });
     if (link.uid !== BigInt(process.getuid()) || !link.isFile() && !link.isSymbolicLink())
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     const linkIdentity = (stat) => `${stat.dev}:${stat.ino}:${stat.mode}:${stat.uid}:${stat.ctimeNs}`;
-    const resolved = realpathSync9(command);
+    const target = resolveLauncherCommand(command), resolved = target.entry;
     if (expectedResolved !== undefined && resolved !== expectedResolved)
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+    let launcher, launcherParentIdentity;
+    if (target.pinned) {
+      launcherParentIdentity = parents2(target.physical);
+      launcher = snapshot(target.physical, false);
+      projectedHookAcl(launcher.file, launcher.stat);
+      if (launcher.sha256 !== target.pinned.sha256 || (launcher.stat.mode & 0o100n) === 0n)
+        hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+      assertPinnedLauncherRuntimeSafe(target.pinned.runtime);
+    }
     const resolvedParentIdentity = parents2(resolved);
     const manifest = snapshot(join23(dirname14(dirname14(resolved)), "package.json"), false, { readOnlyPackage: true });
     projectedHookAcl(manifest.file, manifest.stat);
@@ -16879,8 +17024,15 @@ function projectedHookExecutable(command, expectedResolved) {
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     const recheck = () => {
       try {
-        if (realpathSync9(command) !== resolved || linkIdentity(lstatSync19(command, { bigint: true })) !== linkIdentity(link) || !isDeepStrictEqual6(parents2(), parentIdentity) || !isDeepStrictEqual6(parents2(resolved), resolvedParentIdentity))
+        const again = resolveLauncherCommand(command);
+        if (again.entry !== resolved || again.physical !== target.physical || linkIdentity(lstatSync20(command, { bigint: true })) !== linkIdentity(link) || !isDeepStrictEqual6(parents2(), parentIdentity) || !isDeepStrictEqual6(parents2(resolved), resolvedParentIdentity))
           hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+        if (launcher) {
+          if (!isDeepStrictEqual6(parents2(target.physical), launcherParentIdentity))
+            hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+          projectedHookAcl(launcher.file, launcher.stat);
+          unchanged2(launcher);
+        }
         projectedHookAcl(cli.file, cli.stat);
         projectedHookAcl(manifest.file, manifest.stat);
         unchanged2(cli);
@@ -17002,7 +17154,7 @@ function claudeSettingsConsumers(home, path, discoveries, aliases) {
   const canonical6 = (value) => canonicalAgentPath(value, aliases);
   const containsSettings = (root) => {
     const distance = relative6(canonical6(root), path);
-    return distance === "" || distance !== ".." && !distance.startsWith(`..${sep7}`) && !isAbsolute13(distance);
+    return distance === "" || distance !== ".." && !distance.startsWith(`..${sep7}`) && !isAbsolute14(distance);
   };
   return discoveries.filter((binding) => binding.agent === "claude" || binding.agent === "opencode" || canonical6(join23(home, AGENT_ADAPTERS[binding.agent].config)) === path || binding.sources.some((source) => canonical6(source.path) === path) || binding.roots.some(containsSettings) || binding.directories?.some((directory) => containsSettings(directory.path))).map((binding) => binding.agent);
 }
@@ -17035,7 +17187,7 @@ function planClaudeHookEventsUpdate(options) {
   recheckRootAliases(aliases);
   const path = canonicalAgentPath(join23(home, ".claude", "settings.json"), aliases);
   assertSafePath(path);
-  const before = lstatSync19(path, { throwIfNoEntry: false }) ? new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(readNativeBytes(path, 1024 * 1024)) : null;
+  const before = lstatSync20(path, { throwIfNoEntry: false }) ? new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(readNativeBytes(path, 1024 * 1024)) : null;
   if ((before === null ? "absent" : sha3(before)) !== options.expectedSettingsSha256)
     throw new Error("Claude settings preimage changed");
   assertClaudeHookEventsReplacement(before, options.replacement, options.events);
@@ -17226,7 +17378,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
     if (change.before !== null) {
       const backup = join23(backupRoot, `${index}-${sha3(change.path).slice(0, 12)}.backup`);
       writeFileSync6(backup, change.before, { mode: 384, flag: "wx" });
-      if (readFileSync14(backup, "utf8") !== change.before)
+      if (readFileSync15(backup, "utf8") !== change.before)
         throw new Error("Native configuration preservation readback failed");
       backups.push(backup);
     }
@@ -17289,11 +17441,11 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
-  const descriptor = openSync10(path, constants10.O_RDONLY | constants10.O_DIRECTORY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
+  const descriptor = openSync11(path, constants11.O_RDONLY | constants11.O_DIRECTORY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
   try {
-    fsyncSync4(descriptor);
+    fsyncSync5(descriptor);
   } finally {
-    closeSync10(descriptor);
+    closeSync11(descriptor);
   }
 }
 function writeArchiveJournal(path, value) {
@@ -17301,18 +17453,18 @@ function writeArchiveJournal(path, value) {
   const temporary = `${path}.skills-${randomUUID3()}`;
   let descriptor;
   try {
-    descriptor = openSync10(temporary, constants10.O_WRONLY | constants10.O_CREAT | constants10.O_EXCL | constants10.O_NOFOLLOW, 384);
+    descriptor = openSync11(temporary, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
     writeFileSync6(descriptor, `${JSON.stringify(value)}
 `);
-    fsyncSync4(descriptor);
-    closeSync10(descriptor);
+    fsyncSync5(descriptor);
+    closeSync11(descriptor);
     descriptor = undefined;
     renameSync3(temporary, path);
     syncArchiveDirectory(dirname14(path));
   } finally {
     if (descriptor !== undefined)
-      closeSync10(descriptor);
-    if (lstatSync19(temporary, { throwIfNoEntry: false }))
+      closeSync11(descriptor);
+    if (lstatSync20(temporary, { throwIfNoEntry: false }))
       unlinkSync4(temporary);
   }
 }
@@ -17358,7 +17510,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
   const moved = [];
   const verifyArchive = (entry) => {
     assertSafePath(entry.archive);
-    const stat = lstatSync19(entry.archive);
+    const stat = lstatSync20(entry.archive);
     if (entry.discoveryOnly ? !stat.isFile() : !stat.isDirectory())
       throw new Error("Archive type changed");
     if ((entry.discoveryOnly ? sha3(readNativeBytes(entry.archive)) : treeHash(entry.archive)) !== entry.hash)
@@ -17409,7 +17561,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
         recheckRootAliases(aliases);
         assertSafePath(entry.source);
         assertSafePath(entry.archive);
-        if (lstatSync19(entry.source, { throwIfNoEntry: false })) {
+        if (lstatSync20(entry.source, { throwIfNoEntry: false })) {
           entry.status = "recovery-required";
           entry.conflict = "source-occupied";
           continue;
@@ -17426,7 +17578,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
           syncArchiveDirectory(dirname14(entry.source));
           unlinkSync4(entry.archive);
         } else {
-          if (lstatSync19(entry.source, { throwIfNoEntry: false })) {
+          if (lstatSync20(entry.source, { throwIfNoEntry: false })) {
             entry.status = "recovery-required";
             entry.conflict = "source-occupied";
             continue;
@@ -17459,12 +17611,12 @@ function isInertCodexPluginCacheCopy(entry, cache, allowedHostPaths, read2) {
       return false;
     const document2 = join23(entry.path, "SKILL.md");
     const inside = relative6(cache, entry.path);
-    if (!inside || isAbsolute13(inside) || inside.split(sep7).some((segment) => segment === ".."))
+    if (!inside || isAbsolute14(inside) || inside.split(sep7).some((segment) => segment === ".."))
       return false;
     assertSafePath(entry.path);
-    if (!lstatSync19(cache).isDirectory() || !lstatSync19(entry.path).isDirectory() || !lstatSync19(document2).isFile())
+    if (!lstatSync20(cache).isDirectory() || !lstatSync20(entry.path).isDirectory() || !lstatSync20(document2).isFile())
       return false;
-    if (realpathSync9.native(cache) !== cache || realpathSync9.native(entry.path) !== entry.path || realpathSync9.native(document2) !== document2)
+    if (realpathSync10.native(cache) !== cache || realpathSync10.native(entry.path) !== entry.path || realpathSync10.native(document2) !== document2)
       return false;
     if (!classifyCodexPluginCacheDocument(document2, cache, read2))
       return false;
@@ -17641,9 +17793,9 @@ function isSkillsOwnershipMarker(marker) {
 function hasSkillsOwnershipMarker(dir) {
   const path = join25(dir, SYNC_MARKER_FILE);
   try {
-    if (!lstatSync20(path).isFile())
+    if (!lstatSync21(path).isFile())
       return false;
-    const marker = JSON.parse(readFileSync15(path, "utf8"));
+    const marker = JSON.parse(readFileSync16(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
   } catch {
     return false;
@@ -17860,7 +18012,7 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
   if (dirExists && managed && hasSkillMd && !options.force && isPointerSkillMd(skillMd)) {
     let existingIsStub = false;
     try {
-      existingIsStub = isPointerSkillMd(readFileSync15(skillMdPath, "utf-8"));
+      existingIsStub = isPointerSkillMd(readFileSync16(skillMdPath, "utf-8"));
     } catch {
       existingIsStub = false;
     }
@@ -17910,7 +18062,7 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
     assertCurrent();
     renameDirectory(candidateDir, dir);
     assertCurrent();
-    if (readFileSync15(skillMdPath, "utf8") !== (skillMd.endsWith(`
+    if (readFileSync16(skillMdPath, "utf8") !== (skillMd.endsWith(`
 `) ? skillMd : `${skillMd}
 `))
       throw new Error("Managed skill readback failed");
@@ -17954,7 +18106,7 @@ function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = f
   if (kind === undefined || kind === "instruction" || preferBundledDocs) {
     const skillMdPath = join25(skillPath, "SKILL.md");
     if (existsSync10(skillMdPath))
-      return readFileSync15(skillMdPath, "utf-8");
+      return readFileSync16(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -17994,7 +18146,7 @@ function resolveSkillAlias(name) {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
 import { join as join26 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
@@ -18020,7 +18172,7 @@ function loadProjectConfig(targetDir = process.cwd()) {
   if (!existsSync11(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync16(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync17(path, "utf-8")));
   } catch {
     return null;
   }
@@ -18207,7 +18359,7 @@ function createLocalSkillManifest(name, generateSkillMd) {
   let skillMd = "";
   const skillMdPath = join27(sourcePath, "SKILL.md");
   if (existsSync12(skillMdPath)) {
-    skillMd = readFileSync17(skillMdPath, "utf-8");
+    skillMd = readFileSync18(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -18333,7 +18485,7 @@ function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
   const skillMdPath = join27(sourcePath, "SKILL.md");
   if (existsSync12(skillMdPath))
-    return readFileSync17(skillMdPath, "utf-8");
+    return readFileSync18(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -18389,14 +18541,14 @@ function readBundledSkillVersion(name) {
   if (!existsSync12(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync17(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync12(path) ? readFileSync17(path, "utf-8") : null;
+  return existsSync12(path) ? readFileSync18(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
@@ -18444,7 +18596,7 @@ function isInstructionSkillDir(skillPath, meta) {
   if (!existsSync13(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync18(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync19(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -18495,7 +18647,7 @@ function getSkillRequirements(name) {
   const meta = getSkill(name);
   let dependencies = {};
   try {
-    dependencies = JSON.parse(readFileSync18(join28(skillPath, "package.json"), "utf8")).dependencies || {};
+    dependencies = JSON.parse(readFileSync19(join28(skillPath, "package.json"), "utf8")).dependencies || {};
   } catch {}
   return getSkillRequirementsFromContent(name, texts, dependencies, meta);
 }
@@ -18563,7 +18715,7 @@ async function runSkill(name, args, options = {}) {
   }
   let entryPoint2;
   try {
-    const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint2 = binValues[0];
@@ -18666,7 +18818,7 @@ function generateSkillMd(name) {
   const pkgPath = join28(skillPath, "package.json");
   if (existsSync13(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -18742,7 +18894,7 @@ function extractEnvVars(text2) {
 function readIfExists(path) {
   try {
     if (existsSync13(path)) {
-      return readFileSync18(path, "utf-8");
+      return readFileSync19(path, "utf-8");
     }
   } catch {}
   return null;
@@ -18869,7 +19021,7 @@ function exactProfileSelection(spec, profile) {
 }
 
 // src/lib/plugin-projection.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import { posix } from "path";
 var PLUGIN_PROJECTION_MANIFEST = "plugin-projection.json";
 var PLUGIN_PROJECTION_LIMITS = Object.freeze({ files: 1024, bytes: 64 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, metadataBytes: 512 * 1024, registrations: 64, history: 128 });
@@ -18880,7 +19032,7 @@ function pluginNeed(value, message) {
   if (!value)
     pluginRefusal(message);
 }
-var pluginHash = (bytes) => createHash19("sha256").update(bytes).digest("hex");
+var pluginHash = (bytes) => createHash20("sha256").update(bytes).digest("hex");
 function pluginObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -19068,16 +19220,16 @@ function buildPluginProjection(entries) {
 }
 
 // src/lib/plugin-projection-store.ts
-import { createHash as createHash20, randomUUID as randomUUID4 } from "crypto";
-import { constants as constants11, closeSync as closeSync11, fchmodSync, fstatSync as fstatSync11, fsyncSync as fsyncSync5, linkSync as linkSync3, lstatSync as lstatSync21, mkdirSync as mkdirSync9, openSync as openSync11, opendirSync as opendirSync4, readSync as readSync9, renameSync as renameSync5, rmdirSync as rmdirSync3, rmSync as rmSync3, unlinkSync as unlinkSync5, writeSync as writeSync2 } from "fs";
-import { dirname as dirname16, isAbsolute as isAbsolute14, join as join29, parse as parse6, resolve as resolve14 } from "path";
-var READ_FLAGS = constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK;
-var WRITE_FLAGS = constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW | constants11.O_NONBLOCK;
+import { createHash as createHash21, randomUUID as randomUUID4 } from "crypto";
+import { constants as constants12, closeSync as closeSync12, fchmodSync as fchmodSync2, fstatSync as fstatSync12, fsyncSync as fsyncSync6, linkSync as linkSync3, lstatSync as lstatSync22, mkdirSync as mkdirSync9, openSync as openSync12, opendirSync as opendirSync4, readSync as readSync9, renameSync as renameSync5, rmdirSync as rmdirSync3, rmSync as rmSync3, unlinkSync as unlinkSync5, writeSync as writeSync3 } from "fs";
+import { dirname as dirname16, isAbsolute as isAbsolute15, join as join29, parse as parse6, resolve as resolve14 } from "path";
+var READ_FLAGS = constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
+var WRITE_FLAGS = constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
 var uid = () => typeof process.getuid === "function" ? BigInt(process.getuid()) : undefined;
 var missing = (error) => Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 function stat(path) {
   try {
-    return lstatSync21(path, { bigint: true });
+    return lstatSync22(path, { bigint: true });
   } catch (error) {
     if (missing(error))
       return null;
@@ -19085,7 +19237,7 @@ function stat(path) {
   }
 }
 function canonical6(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute14(path) && resolve14(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
+  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute15(path) && resolve14(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -19153,8 +19305,8 @@ function readBytes(path, maximum, kind) {
   fileShape(before, maximum, kind);
   let fd;
   try {
-    fd = openSync11(path, READ_FLAGS);
-    const opened = fstatSync11(fd, { bigint: true });
+    fd = openSync12(path, READ_FLAGS);
+    const opened = fstatSync12(fd, { bigint: true });
     same3(before, opened);
     fileShape(opened, maximum, kind);
     const bytes = new Uint8Array(Number(opened.size));
@@ -19165,7 +19317,7 @@ function readBytes(path, maximum, kind) {
       offset += count;
     }
     pluginNeed(readSync9(fd, new Uint8Array(1), 0, 1, null) === 0, "Plugin file grew while being read");
-    same3(opened, fstatSync11(fd, { bigint: true }));
+    same3(opened, fstatSync12(fd, { bigint: true }));
     same3(opened, stat(path));
     verifyAncestors(chain);
     return bytes;
@@ -19175,7 +19327,7 @@ function readBytes(path, maximum, kind) {
     return pluginRefusal("Cannot safely read plugin file");
   } finally {
     if (fd !== undefined)
-      closeSync11(fd);
+      closeSync12(fd);
   }
 }
 function exactPaths(entries) {
@@ -19285,16 +19437,16 @@ function verifyPluginTree(root, witnesses) {
 function writeExclusive(path, bytes, mode) {
   let fd, created;
   try {
-    fd = openSync11(path, WRITE_FLAGS, mode);
-    fchmodSync(fd, mode);
-    created = fstatSync11(fd, { bigint: true });
+    fd = openSync12(path, WRITE_FLAGS, mode);
+    fchmodSync2(fd, mode);
+    created = fstatSync12(fd, { bigint: true });
     let offset = 0;
     while (offset < bytes.byteLength) {
-      const count = writeSync2(fd, bytes, offset, bytes.byteLength - offset);
+      const count = writeSync3(fd, bytes, offset, bytes.byteLength - offset);
       pluginNeed(count > 0, "Plugin file write did not progress");
       offset += count;
     }
-    fsyncSync5(fd);
+    fsyncSync6(fd);
   } catch (error) {
     if (created) {
       same3(created, stat(path), true);
@@ -19303,7 +19455,7 @@ function writeExclusive(path, bytes, mode) {
     throw error;
   } finally {
     if (fd !== undefined)
-      closeSync11(fd);
+      closeSync12(fd);
   }
 }
 function materializePluginTree(root, entries) {
@@ -19406,11 +19558,11 @@ function pluginExecutableDigest(path) {
   fileShape(before, maximum, "executable");
   let fd;
   try {
-    fd = openSync11(path, READ_FLAGS);
-    const opened = fstatSync11(fd, { bigint: true });
+    fd = openSync12(path, READ_FLAGS);
+    const opened = fstatSync12(fd, { bigint: true });
     same3(before, opened);
     fileShape(opened, maximum, "executable");
-    const hash2 = createHash20("sha256"), buffer = new Uint8Array(64 * 1024);
+    const hash2 = createHash21("sha256"), buffer = new Uint8Array(64 * 1024);
     let remaining = Number(opened.size);
     while (remaining > 0) {
       const count = readSync9(fd, buffer, 0, Math.min(buffer.byteLength, remaining), null);
@@ -19419,7 +19571,7 @@ function pluginExecutableDigest(path) {
       remaining -= count;
     }
     pluginNeed(readSync9(fd, buffer, 0, 1, null) === 0, "Plugin executable grew during hashing");
-    same3(opened, fstatSync11(fd, { bigint: true }));
+    same3(opened, fstatSync12(fd, { bigint: true }));
     same3(opened, stat(path));
     verifyAncestors(chain);
     return `sha256:${hash2.digest("hex")}`;
@@ -19429,7 +19581,7 @@ function pluginExecutableDigest(path) {
     return pluginRefusal("Cannot safely hash plugin executable");
   } finally {
     if (fd !== undefined)
-      closeSync11(fd);
+      closeSync12(fd);
   }
 }
 
@@ -19468,7 +19620,7 @@ function validatePluginTarget(value) {
   for (const registration of value.registrations) {
     pluginKeys(registration, ["scope", "projectPath"]);
     pluginNeed(registration.scope === "user" || registration.scope === "project", "Unsupported plugin registration scope");
-    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute15(registration.projectPath) && resolve15(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
+    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute16(registration.projectPath) && resolve15(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
     const key = JSON.stringify([registration.scope, registration.projectPath]);
     pluginNeed(!scopes.has(key), "Duplicate plugin registration scope");
     scopes.add(key);
@@ -19476,7 +19628,7 @@ function validatePluginTarget(value) {
   for (const key of ["native", "resolver"]) {
     pluginKeys(value[key], key === "native" ? ["version", "executable", "digest"] : ["executable", "digest"]);
     pluginText(value[key].executable);
-    pluginNeed(isAbsolute15(value[key].executable) && resolve15(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute16(value[key].executable) && resolve15(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
     pluginDigest(value[key].digest);
   }
   pluginNeed(["2.1.274", "2.1.276"].includes(value.native.version), "Plugin admission requires a certified Claude command-source runtime (2.1.274 or 2.1.276)");
@@ -19628,7 +19780,7 @@ function pluginResolverCommand(binding) {
 }
 function root(options) {
   const path = options.storeRoot ?? pluginAdmissionRoot();
-  pluginNeed(isAbsolute15(path) && resolve15(path) === path, "Invalid plugin admission store root");
+  pluginNeed(isAbsolute16(path) && resolve15(path) === path, "Invalid plugin admission store root");
   return path;
 }
 function pluginBindingPath(storeRoot, id) {
@@ -19833,25 +19985,25 @@ function validateManagedPluginWitnesses(value) {
     pluginNeed(typeof item.bindingId === "string" && /^[a-f0-9]{64}$/.test(item.bindingId) && !seen.has(item.bindingId), "Invalid or duplicate managed plugin witness");
     seen.add(item.bindingId);
     pluginText(item.storeRoot);
-    pluginNeed(isAbsolute16(item.storeRoot) && resolve16(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute17(item.storeRoot) && resolve16(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe3(path) {
   pluginText(path);
-  pluginNeed(isAbsolute16(path) && resolve16(path) === path, "Invalid plugin registry path");
+  pluginNeed(isAbsolute17(path) && resolve16(path) === path, "Invalid plugin registry path");
   for (let at = path;; at = dirname17(at)) {
-    pluginNeed(!lstatSync22(at, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
+    pluginNeed(!lstatSync23(at, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
     if (at === dirname17(at))
       break;
   }
 }
 function readRegistry(path) {
   safe3(path);
-  const initial = lstatSync22(path);
+  const initial = lstatSync23(path);
   pluginNeed(initial.isFile() && initial.size <= 1024 * 1024, "Plugin registry is not a bounded regular file");
-  const fd = openSync12(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
+  const fd = openSync13(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
   try {
-    const opened = fstatSync12(fd);
+    const opened = fstatSync13(fd);
     pluginNeed(opened.isFile() && opened.ino === initial.ino && opened.dev === initial.dev, "Plugin registry changed during open");
     const bytes = Buffer.alloc(1024 * 1024 + 1);
     let length = 0;
@@ -19861,7 +20013,7 @@ function readRegistry(path) {
         break;
       length += count;
     }
-    const after = fstatSync12(fd), current = lstatSync22(path);
+    const after = fstatSync13(fd), current = lstatSync23(path);
     safe3(path);
     pluginNeed(length <= 1024 * 1024 && length === opened.size && after.size === opened.size && after.mtimeMs === opened.mtimeMs && after.ctimeMs === opened.ctimeMs && current.dev === opened.dev && current.ino === opened.ino && current.mtimeMs === opened.mtimeMs && current.ctimeMs === opened.ctimeMs, "Plugin registry changed during read");
     let value;
@@ -19873,7 +20025,7 @@ function readRegistry(path) {
     pluginNeed(pluginObject(value) && value.version === 2 && pluginObject(value.plugins), "Unsupported native plugin registry schema");
     return { value, rawDigest: pluginHash(bytes.subarray(0, length)) };
   } finally {
-    closeSync12(fd);
+    closeSync13(fd);
   }
 }
 function nativeVersionMatches(version, receipt) {
@@ -19934,7 +20086,7 @@ function hashManagedPluginRegistry(path, managed) {
       return Object.fromEntries(Object.entries(row).filter(([key]) => !["version", "installPath", "sourceProducerPath", "previousProducerPaths", "lastUpdated"].includes(key)));
     });
     safe3(cacheRoot);
-    const before = lstatSync22(cacheRoot);
+    const before = lstatSync23(cacheRoot);
     pluginNeed(before.isDirectory(), "Invalid managed plugin cache root");
     const directory = opendirSync5(cacheRoot), names = [];
     try {
@@ -19957,7 +20109,7 @@ function hashManagedPluginRegistry(path, managed) {
     }
     for (const row of rows)
       pluginNeed(names.includes(row.version), "Managed native plugin installation is missing");
-    const after = lstatSync22(cacheRoot);
+    const after = lstatSync23(cacheRoot);
     safe3(cacheRoot);
     pluginNeed(before.dev === after.dev && before.ino === after.ino && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs, "Managed cache version membership changed during verification");
   }
@@ -19969,22 +20121,22 @@ function captureManagedPluginRegistry(path, managedPlugins) {
 }
 
 // src/lib/claude-marketplace-registry.ts
-import { createHash as createHash21 } from "crypto";
-import { closeSync as closeSync13, constants as constants13, fstatSync as fstatSync13, lstatSync as lstatSync23, openSync as openSync13, readSync as readSync11 } from "fs";
-import { basename as basename9, dirname as dirname18, isAbsolute as isAbsolute17, resolve as resolve17 } from "path";
+import { createHash as createHash22 } from "crypto";
+import { closeSync as closeSync14, constants as constants14, fstatSync as fstatSync14, lstatSync as lstatSync24, openSync as openSync14, readSync as readSync11 } from "fs";
+import { basename as basename9, dirname as dirname18, isAbsolute as isAbsolute18, resolve as resolve17 } from "path";
 var CLAUDE_MARKETPLACE_REGISTRY_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
 function need6(value, reason) {
   if (!value)
     throw new Error(`Claude marketplace registry ${reason}`);
 }
 function absolutePath3(value) {
-  need6(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute17(value) && resolve17(value) === value, "requires a normalized absolute path");
+  need6(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute18(value) && resolve17(value) === value, "requires a normalized absolute path");
 }
 var sameFile2 = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
 function parents2(path) {
   const result = [];
   for (let at = dirname18(path);; at = dirname18(at)) {
-    const stat2 = lstatSync23(at, { bigint: true });
+    const stat2 = lstatSync24(at, { bigint: true });
     need6(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
     result.push([at, stat2]);
     if (at === dirname18(at))
@@ -19995,12 +20147,12 @@ function readRegistry2(path, budget2) {
   absolutePath3(path);
   need6(basename9(path) === "known_marketplaces.json", "requires known_marketplaces.json");
   need6(Number.isSafeInteger(budget2.remaining) && budget2.remaining >= 0, "has an invalid byte budget");
-  const ancestors2 = parents2(path), initial = lstatSync23(path, { bigint: true });
+  const ancestors2 = parents2(path), initial = lstatSync24(path, { bigint: true });
   need6(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
   need6(initial.size <= BigInt(budget2.remaining), "exceeds its aggregate byte limit");
-  const fd = openSync13(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+  const fd = openSync14(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
-    const opened = fstatSync13(fd, { bigint: true });
+    const opened = fstatSync14(fd, { bigint: true });
     need6(opened.isFile() && sameFile2(initial, opened), "changed during open");
     const bytes = Buffer.alloc(Number(opened.size) + 1);
     let length = 0;
@@ -20010,10 +20162,10 @@ function readRegistry2(path, budget2) {
         break;
       length += count;
     }
-    const after = fstatSync13(fd, { bigint: true }), current = lstatSync23(path, { bigint: true });
+    const after = fstatSync14(fd, { bigint: true }), current = lstatSync24(path, { bigint: true });
     need6(current.isFile() && sameFile2(opened, after) && sameFile2(after, current) && BigInt(length) === opened.size, "changed during read");
     for (const [ancestor, before] of ancestors2) {
-      const now = lstatSync23(ancestor, { bigint: true });
+      const now = lstatSync24(ancestor, { bigint: true });
       need6(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
     }
     budget2.remaining -= length;
@@ -20023,7 +20175,7 @@ function readRegistry2(path, budget2) {
       throw new Error("Claude marketplace registry is not strict UTF-8");
     }
   } finally {
-    closeSync13(fd);
+    closeSync14(fd);
   }
 }
 function parse7(text2) {
@@ -20138,19 +20290,19 @@ function captureClaudeMarketplaceRegistry(path, budget2 = { remaining: 256 * 102
   const value = parse7(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row);
-  const sha2562 = createHash21("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
-  return { path, hashMode: "claude-marketplace-registry", sha256: sha2562 };
+  const sha2563 = createHash22("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
+  return { path, hashMode: "claude-marketplace-registry", sha256: sha2563 };
 }
 function captureClaudeMarketplaceRegistryV2(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   const value = parse7(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row, 2);
-  const sha2562 = createHash21("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
-  return { path, hashMode: "claude-marketplace-registry-v2", sha256: sha2562 };
+  const sha2563 = createHash22("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
+  return { path, hashMode: "claude-marketplace-registry-v2", sha256: sha2563 };
 }
 
 // src/lib/codex-hook-discovery-recovery.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 
 // src/lib/codex-hook-additions-review.ts
 var events = { UserPromptSubmit: ["userPromptSubmit", "user_prompt_submit"], SessionStart: ["sessionStart", "session_start"], SubagentStart: ["subagentStart", "subagent_start"] };
@@ -20158,7 +20310,7 @@ var matchedEvents = { ...events, PreToolUse: ["preToolUse", "pre_tool_use"] };
 var proofs = new WeakMap;
 
 // src/lib/codex-hook-discovery-recovery.ts
-var sha4 = (text2) => createHash22("sha256").update(text2).digest("hex");
+var sha4 = (text2) => createHash23("sha256").update(text2).digest("hex");
 var fields = [...CODEX_DISCOVERY_PROJECTION_FIELDS];
 var proofs2 = new WeakMap;
 function assertCodexHookDiscoveryRecovery(binding, witness) {
@@ -20177,7 +20329,7 @@ function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witnes
 }
 
 // src/lib/agent-discovery.ts
-var digest = (text2) => createHash23("sha256").update(text2).digest("hex");
+var digest = (text2) => createHash24("sha256").update(text2).digest("hex");
 function parseConfig(text2, path, toml = false) {
   try {
     const value = toml ? Bun.TOML.parse(text2) : JSON.parse(text2);
@@ -20189,10 +20341,10 @@ function parseConfig(text2, path, toml = false) {
   }
 }
 function safe4(path) {
-  if (!isAbsolute18(path) || path.includes("\x00"))
+  if (!isAbsolute19(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
   for (let cursor = path;; cursor = dirname19(cursor)) {
-    if (lstatSync24(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync25(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
     if (dirname19(cursor) === cursor)
       break;
@@ -20202,12 +20354,12 @@ function read2(path, changes) {
   safe4(path);
   if (changes?.has(path))
     return changes.get(path);
-  const stat2 = lstatSync24(path, { throwIfNoEntry: false });
+  const stat2 = lstatSync25(path, { throwIfNoEntry: false });
   if (!stat2)
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
     throw new Error(`Unsupported or oversized native discovery input: ${path}`);
-  return readFileSync19(path, "utf8");
+  return readFileSync20(path, "utf8");
 }
 function projectNativeDiscoveryFields(text2, format, fields2, path) {
   const object6 = format === "yaml" ? parseHermesConfig(text2) : parseConfig(text2, path, format === "toml");
@@ -20253,10 +20405,10 @@ function projected(source, changes, budget2 = discoveryByteBudget()) {
   if (source.hashMode === "claude-marketplace-registry" || source.hashMode === "claude-marketplace-registry-v2") {
     if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256) || changes?.has(source.path))
       throw new Error("Claude marketplace witnesses require an exact reviewed registry without synthetic changes");
-    const sha2562 = (source.hashMode === "claude-marketplace-registry-v2" ? captureClaudeMarketplaceRegistryV2 : captureClaudeMarketplaceRegistry)(source.path, budget2).sha256;
-    if (sha2562 !== source.sha256)
+    const sha2563 = (source.hashMode === "claude-marketplace-registry-v2" ? captureClaudeMarketplaceRegistryV2 : captureClaudeMarketplaceRegistry)(source.path, budget2).sha256;
+    if (sha2563 !== source.sha256)
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
-    return sha2562;
+    return sha2563;
   }
   if (source.hashMode === "claude-plugin-registry") {
     if (source.format !== undefined || source.fields !== undefined || !source.managedPlugins || changes?.has(source.path))
@@ -20293,7 +20445,7 @@ function absentCodexSkillRoots(binding) {
     return [];
   if (binding.agent !== "codex" || !Array.isArray(controls) || controls.length > 4096)
     throw new Error("Invalid disabled Codex discovery proof");
-  if (binding.method !== "reviewed" || controls.every((control) => lstatSync24(control.pluginParent, { throwIfNoEntry: false })))
+  if (binding.method !== "reviewed" || controls.every((control) => lstatSync25(control.pluginParent, { throwIfNoEntry: false })))
     return [];
   const cache = dirname19(dirname19(controls[0].pluginParent)), config = join32(dirname19(dirname19(cache)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
@@ -20361,7 +20513,7 @@ function absentRetiredClaudeRoots(binding) {
       continue;
     const root2 = join32(cache, ...parts.slice(0, 3));
     safe4(root2);
-    if (lstatSync24(root2, { throwIfNoEntry: false }))
+    if (lstatSync25(root2, { throwIfNoEntry: false }))
       continue;
     const claude = dirname19(dirname19(cache)), settings = join32(claude, "settings.json"), registry = join32(claude, "plugins/installed_plugins.json");
     const full = (path) => binding.sources.find((item) => item.path === path && item.sha256 !== null && item.format === undefined && item.fields === undefined);
@@ -20380,7 +20532,7 @@ function absentRetiredClaudeRoots(binding) {
     if (!Array.isArray(rows) || rows.length !== 1 || rows[0]?.scope !== "user" || typeof rows[0]?.installPath !== "string")
       continue;
     const active = rows[0].installPath;
-    if (rows[0].version !== basename10(active) || resolve18(active) !== active || dirname19(active) !== dirname19(root2) || active === root2 || !lstatSync24(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync10(active) !== active)
+    if (rows[0].version !== basename10(active) || resolve18(active) !== active || dirname19(active) !== dirname19(root2) || active === root2 || !lstatSync25(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync11(active) !== active)
       continue;
     const activeManifest = full(join32(active, ".claude-plugin/plugin.json"));
     if (!activeManifest || projected(activeManifest) !== activeManifest.sha256)
@@ -20411,7 +20563,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
       const projection = binding.codexRetiredMaterializations.directories;
       if (projection.length !== ordinary.length || projection.some((item, index) => item.path !== ordinary[index]?.path))
         throw new Error("Missing retired Codex directory projection");
-      const omitted = [...retiredRoots, ...(binding.codexRetiredMaterializations.parents ?? []).filter((parent) => !lstatSync24(parent, { throwIfNoEntry: false }))];
+      const omitted = [...retiredRoots, ...(binding.codexRetiredMaterializations.parents ?? []).filter((parent) => !lstatSync25(parent, { throwIfNoEntry: false }))];
       if (projection.every((item) => Array.isArray(item.entries)))
         verifyDiscoveryDirectoryProjection(projection, omitted);
       else {
@@ -20425,7 +20577,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
       verifyDiscoveryDirectories(ordinary);
     verifyDiscoveryDirectories(projected2, installationRoots);
   }
-  const absentRoots = [...absentCodexSkillRoots(binding), ...absentRetiredClaudeRoots(binding), ...retiredRoots.filter((root2) => !lstatSync24(root2, { throwIfNoEntry: false }))];
+  const absentRoots = [...absentCodexSkillRoots(binding), ...absentRetiredClaudeRoots(binding), ...retiredRoots.filter((root2) => !lstatSync25(root2, { throwIfNoEntry: false }))];
   const budget2 = discoveryByteBudget();
   for (const source of binding.sources) {
     assertMarketplaceBinding(binding, source);
@@ -20451,7 +20603,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
     safe4(root2);
   for (const root2 of absentRoots) {
     safe4(root2);
-    if (lstatSync24(root2, { throwIfNoEntry: false }))
+    if (lstatSync25(root2, { throwIfNoEntry: false }))
       throw new Error("Retired native materialization changed during discovery verification");
   }
 }
@@ -20490,19 +20642,19 @@ function assertMarketplaceBinding(binding, source) {
 }
 function rebindAgentDiscovery(binding, changes) {
   const budget2 = discoveryByteBudget();
-  const installationRoots = codexInstallationRoots(binding), absentRoots = [...absentCodexSkillRoots(binding), ...absentRetiredClaudeRoots(binding), ...retiredCodexRoots(binding).filter((root2) => !lstatSync24(root2, { throwIfNoEntry: false }))];
+  const installationRoots = codexInstallationRoots(binding), absentRoots = [...absentCodexSkillRoots(binding), ...absentRetiredClaudeRoots(binding), ...retiredCodexRoots(binding).filter((root2) => !lstatSync25(root2, { throwIfNoEntry: false }))];
   const rebound = { ...binding, sources: binding.sources.map((source) => {
     assertMarketplaceBinding(binding, source);
     if (!changes.has(source.path) && (installationRoots.some((root2) => source.path.startsWith(root2 + sep8)) || absentRoots.some((root2) => source.path.startsWith(root2 + sep8)) && source.format === undefined && source.fields === undefined && source.managedPlugins === undefined && [undefined, "bytes"].includes(source.hashMode)))
       return source;
-    const sha2562 = projected(source, changes, budget2);
-    if (!changes.has(source.path) && sha2562 !== source.sha256)
+    const sha2563 = projected(source, changes, budget2);
+    if (!changes.has(source.path) && sha2563 !== source.sha256)
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
-    return { ...source, sha256: sha2562 };
+    return { ...source, sha256: sha2563 };
   }) };
   for (const root2 of absentRoots) {
     safe4(root2);
-    if (lstatSync24(root2, { throwIfNoEntry: false }))
+    if (lstatSync25(root2, { throwIfNoEntry: false }))
       throw new Error("Retired native materialization changed during discovery rebinding");
   }
   return rebound;
@@ -20557,13 +20709,13 @@ function assertProjectDiscovery(agent, directories, home, canonical7 = resolve18
       for (const name of ["plugin", "plugins"]) {
         const path = canonical7(join32(directory, ".sumi", name));
         safe4(path);
-        if (lstatSync24(path, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(path).length)
+        if (lstatSync25(path, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(path).length)
           throw new Error(`NATIVE_SKILL_DRIFT: project Sumi plugins require a dedicated discovery review: ${path}`);
       }
     if (agent === "claude") {
       const commands = canonical7(join32(directory, ".claude/commands"));
       safe4(commands);
-      if (lstatSync24(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length)
+      if (lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length)
         throw new Error("NATIVE_SKILL_DRIFT: legacy project command discovery requires a dedicated format adapter");
     }
   }
@@ -20603,7 +20755,7 @@ function resolveAgentDiscovery(options) {
     if (config.skills !== undefined && (!Array.isArray(config.skills) || config.skills.some((path) => typeof path !== "string")))
       unresolved("skills must be a string array");
     for (const value of config.skills ?? []) {
-      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute18(value) || value.startsWith("~/")))
+      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute19(value) || value.startsWith("~/")))
         unresolved("remote or relative skill sources need a dedicated discovery adapter");
       roots.add(canonical7(value.startsWith("~/") ? join32(home, value.slice(2)) : value));
     }
@@ -20613,19 +20765,19 @@ function resolveAgentDiscovery(options) {
     const plugins = [join32(directory, "plugin"), join32(directory, "plugins")];
     for (const path of plugins) {
       safe4(path);
-      if (lstatSync24(path, { throwIfNoEntry: false })?.isDirectory())
+      if (lstatSync25(path, { throwIfNoEntry: false })?.isDirectory())
         for (const name of readdirSync10(path).sort()) {
           if (name === "skills-cli.js" && path === plugins[1])
             continue;
           const target = join32(path, name);
-          if (!lstatSync24(target).isFile())
+          if (!lstatSync25(target).isFile())
             unresolved("local plugin packages need a dedicated discovery adapter");
           witness(target);
         }
     }
     for (const root2 of roots) {
       safe4(root2);
-      if (lstatSync24(root2, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(root2).some((name) => name.endsWith(".md")))
+      if (lstatSync25(root2, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(root2).some((name) => name.endsWith(".md")))
         unresolved("flat markdown skills require a dedicated native migration adapter");
     }
   }
@@ -20653,7 +20805,7 @@ function resolveAgentDiscovery(options) {
     const executable2 = Bun.which("gemini");
     if (executable2) {
       let packageRoot;
-      for (let directory = dirname19(realpathSync10(executable2)), depth = 0;depth < 8; directory = dirname19(directory), depth++) {
+      for (let directory = dirname19(realpathSync11(executable2)), depth = 0;depth < 8; directory = dirname19(directory), depth++) {
         const path = join32(directory, "package.json"), raw = read2(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
@@ -20667,7 +20819,7 @@ function resolveAgentDiscovery(options) {
         unresolved("installed Gemini package layout is not recognized");
       const builtinRoot = join32(packageRoot, "bundle/builtin");
       safe4(builtinRoot);
-      if (!lstatSync24(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
+      if (!lstatSync25(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
       for (const name of readdirSync10(builtinRoot).sort()) {
         const text2 = witness(join32(builtinRoot, name, "SKILL.md"));
@@ -20705,10 +20857,10 @@ function resolveAgentDiscovery(options) {
       throw new Error("Discovery review must include the agent configuration source");
     const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical7(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical7(configPath), source)) : sources;
     const reviewedSourcesWithManifestProjection = review.sources.map((source) => {
-      if (agent !== "claude" || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes" || basename10(source.path) !== "plugin.json" || !source.path.endsWith(join32(sep8, ".claude-plugin", "plugin.json")))
+      if (agent !== "claude" || source.sha256 === null || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes" || basename10(source.path) !== "plugin.json" || !source.path.endsWith(join32(sep8, ".claude-plugin", "plugin.json")))
         return source;
       const pluginRoot = dirname19(dirname19(source.path)), hooksPath = join32(pluginRoot, "hooks/hooks.json");
-      const hookStat = lstatSync24(hooksPath, { throwIfNoEntry: false });
+      const hookStat = lstatSync25(hooksPath, { throwIfNoEntry: false });
       const text2 = read2(source.path);
       if (text2 === null)
         throw new Error("Reviewed Claude plugin manifest is missing");
@@ -20749,7 +20901,7 @@ function resolveAgentDiscovery(options) {
       unresolved("plugin hooks require a separate no-skill-injection review");
     const commands = join32(root2, "commands");
     safe4(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync24(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
     const rootSkill = witness(join32(root2, "SKILL.md"));
     if (rootSkill !== null)
@@ -20771,7 +20923,7 @@ function resolveAgentDiscovery(options) {
     const installed = registrations === null ? {} : parseConfig(registrations, join32(home, ".claude/plugins/installed_plugins.json")).plugins;
     const commands = canonical7(join32(home, ".claude/commands"));
     safe4(commands);
-    if (lstatSync24(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length)
+    if (lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
     for (const [id, enabled] of Object.entries(config.enabledPlugins ?? {})) {
       if (enabled === false)
@@ -20791,7 +20943,7 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split = id.lastIndexOf("@"), name = id.slice(0, split), marketplace = id.slice(split + 1);
       const market = config.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute18(market.source))
+      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute19(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
       const catalogText = witness(join32(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
@@ -20807,13 +20959,13 @@ function resolveAgentDiscovery(options) {
     if ((config.plugin?.length ?? 0) > 0 || config.skills?.urls?.length)
       unresolved("external plugin or remote skill source");
     for (const path of config.skills?.paths ?? []) {
-      if (typeof path !== "string" || !isAbsolute18(path))
+      if (typeof path !== "string" || !isAbsolute19(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
     const localPlugins = join32(home, ".config/opencode/plugins");
     safe4(localPlugins);
-    if (lstatSync24(localPlugins, { throwIfNoEntry: false }) && readdirSync10(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync25(localPlugins, { throwIfNoEntry: false }) && readdirSync10(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "sumi") {
     if ((config.plugin?.length ?? 0) > 0 || (config.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical7(configPath) && source.path !== canonical7(join32(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
@@ -20821,7 +20973,7 @@ function resolveAgentDiscovery(options) {
   } else if (agent === "hermes") {
     for (const directory of [join32(home, ".hermes/plugins"), join32(home, ".hermes/hermes-agent")]) {
       safe4(directory);
-      if (lstatSync24(directory, { throwIfNoEntry: false }))
+      if (lstatSync25(directory, { throwIfNoEntry: false }))
         unresolved("installed runtime/plugin discovery requires reviewed source bindings");
     }
     if (Bun.which("hermes") || Object.keys(config.plugins ?? {}).length)
@@ -20831,11 +20983,11 @@ function resolveAgentDiscovery(options) {
       unresolved("custom extension or skill paths");
     const directory = join32(home, ".gemini/extensions");
     safe4(directory);
-    if (lstatSync24(directory, { throwIfNoEntry: false }))
+    if (lstatSync25(directory, { throwIfNoEntry: false }))
       for (const name of readdirSync10(directory)) {
         const root2 = join32(directory, name);
         safe4(root2);
-        if (!lstatSync24(root2)?.isDirectory())
+        if (!lstatSync25(root2)?.isDirectory())
           continue;
         const raw = witness(join32(root2, "gemini-extension.json"));
         if (raw === null)
@@ -20868,14 +21020,14 @@ function nativeRootMatch(path) {
 function physicalPath(path) {
   let cursor = resolve19(path);
   const suffix = [];
-  while (!lstatSync25(cursor, { throwIfNoEntry: false })) {
+  while (!lstatSync26(cursor, { throwIfNoEntry: false })) {
     suffix.unshift(basename11(cursor));
     const parent = dirname20(cursor);
     if (parent === cursor)
       return resolve19(path);
     cursor = parent;
   }
-  return resolve19(realpathSync11(cursor), ...suffix);
+  return resolve19(realpathSync12(cursor), ...suffix);
 }
 function contains(root2, path) {
   return path === root2 || path.startsWith(root2 + sep9);
@@ -20913,7 +21065,7 @@ function configuredRoots(home, explicitHome) {
       continue;
     }
     const nativeHome = join33(home, agent === "opencode" ? ".config/opencode" : `.${agent}`);
-    if (!lstatSync25(nativeHome, { throwIfNoEntry: false }))
+    if (!lstatSync26(nativeHome, { throwIfNoEntry: false }))
       continue;
     roots.push(...resolveAgentDiscovery({ home, agent, canonical: physicalPath }).roots);
   }
@@ -21091,14 +21243,14 @@ function physicalImportPath(path) {
     suffix.unshift(basename12(ancestor));
     ancestor = dirname21(ancestor);
   }
-  return join34(realpathSync12(ancestor), ...suffix);
+  return join34(realpathSync13(ancestor), ...suffix);
 }
 function assertDisjointImportPaths(source, destination) {
-  const sourcePath = realpathSync12(source);
+  const sourcePath = realpathSync13(source);
   const destinationPath = physicalImportPath(destination);
   const contains2 = (parent, child) => {
     const path = relative7(parent, child);
-    return path === "" || !isAbsolute19(path) && path !== ".." && !path.startsWith(`..${sep10}`);
+    return path === "" || !isAbsolute20(path) && path !== ".." && !path.startsWith(`..${sep10}`);
   };
   if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
@@ -21379,7 +21531,7 @@ function safeIsDirectory(path) {
   }
 }
 function isSafeRelativePath2(value) {
-  if (!value.trim() || isAbsolute19(value))
+  if (!value.trim() || isAbsolute20(value))
     return false;
   const normalized = normalize4(value).replace(/\\/g, "/");
   return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
@@ -21594,7 +21746,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         continue;
       let content;
       try {
-        content = readFileSync20(skillMdPath, "utf-8");
+        content = readFileSync21(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -21631,7 +21783,7 @@ function findExtensionSkillPath(name) {
         continue;
       let content;
       try {
-        content = readFileSync20(skillMdPath, "utf-8");
+        content = readFileSync21(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -21695,8 +21847,8 @@ function getAllTags(catalog) {
   return Array.from(tagSet).sort();
 }
 // src/lib/run-state.ts
-import { createHash as createHash24, randomBytes } from "crypto";
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync21, readdirSync as readdirSync13, statSync as statSync12, writeFileSync as writeFileSync10 } from "fs";
+import { createHash as createHash25, randomBytes } from "crypto";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync23, readdirSync as readdirSync13, statSync as statSync12, writeFileSync as writeFileSync10 } from "fs";
 import { extname, join as join36, relative as relative8 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now = new Date;
@@ -21768,7 +21920,7 @@ function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
   const path = join36(context.runDir, "events.ndjson");
-  const previous = existsSync16(path) ? readFileSync21(path, "utf-8") : "";
+  const previous = existsSync16(path) ? readFileSync23(path, "utf-8") : "";
   writeFileSync10(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
@@ -21818,11 +21970,11 @@ function collectRunArtifacts(context) {
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
     const stat2 = statSync12(path);
-    const bytes = readFileSync21(path);
+    const bytes = readFileSync23(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash24("sha256").update(bytes).digest("hex"),
+      sha256: createHash25("sha256").update(bytes).digest("hex"),
       sizeBytes: stat2.size
     });
   }
@@ -21833,7 +21985,7 @@ function readRunRecord(runDir) {
   if (!existsSync16(path))
     return null;
   try {
-    return JSON.parse(readFileSync21(path, "utf-8"));
+    return JSON.parse(readFileSync23(path, "utf-8"));
   } catch {
     return null;
   }
@@ -41241,7 +41393,7 @@ function clone2(value) {
   return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 // src/lib/canonical-json.ts
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -41285,7 +41437,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash25("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash26("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 
 // src/lib/remote-recurring-contract.ts
@@ -43348,7 +43500,7 @@ async function createRemoteSkillsClient(env = process.env) {
   return connection ? new RemoteSkillsClient(connection.apiKey, connection.apiOrigin) : null;
 }
 // src/lib/scheduler.ts
-import { existsSync as existsSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync25, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12 } from "fs";
 import { join as join37 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
   return join37(targetDir, ".skills", "schedules.json");
@@ -43357,7 +43509,7 @@ function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
   if (existsSync17(path)) {
     try {
-      return JSON.parse(readFileSync23(path, "utf-8"));
+      return JSON.parse(readFileSync25(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
@@ -43552,7 +43704,7 @@ function recordScheduleRun(id, status, targetDir) {
   saveSchedules(data, targetDir);
 }
 // src/lib/revision.ts
-import { createHash as createHash26 } from "crypto";
+import { createHash as createHash27 } from "crypto";
 var REVISION_ID_PATTERN = /^[0-9a-f]{64}$/;
 function revisionIdOf(content) {
   const canonicalContent = {
@@ -43574,13 +43726,13 @@ function revisionIdOf(content) {
     canonicalContent.replacementSlug = content.replacementSlug ?? null;
   }
   const canonical7 = JSON.stringify(canonicalContent);
-  return createHash26("sha256").update(canonical7).digest("hex");
+  return createHash27("sha256").update(canonical7).digest("hex");
 }
 function revisionIdOfRecord(record8) {
   return revisionIdOf(record8);
 }
 // src/lib/pull.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, readFileSync as readFileSync25, renameSync as renameSync7, rmSync as rmSync5, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, readFileSync as readFileSync26, renameSync as renameSync7, rmSync as rmSync5, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname22, join as join38 } from "path";
 
 // src/lib/skill-bundles.ts
@@ -43780,7 +43932,7 @@ function reconcileTombstone(slug2, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync25(join38(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync26(join38(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -44017,7 +44169,7 @@ function splitNameVersion(raw) {
   return version2 ? { name, version: version2 } : { name };
 }
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute20 } from "path";
+import { isAbsolute as isAbsolute21 } from "path";
 
 // src/lib/remote-invitation-recovery.ts
 class InvitationEmailInputError extends Error {
@@ -44115,7 +44267,7 @@ async function requestInvitationEmail(origin, action, input2) {
 }
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 var PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
 var failures2 = {
   INVALID_REQUEST: [400, "The publication request is invalid."],
@@ -44162,7 +44314,7 @@ var hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
 var record9 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var exact = (v, keys) => record9(v) && Object.keys(v).sort().join(",") === keys.sort().join(",");
 var date5 = (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) => createHash27("sha256").update(bytes).digest("hex");
+var publicationSha256 = (bytes) => createHash28("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 || !hash3(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
@@ -44676,7 +44828,7 @@ var stateSchema = exports_external.object({
 var uuid13 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
 var context = { userId: uuid13.optional(), membershipId: uuid13.optional() };
 var page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-var directory = exports_external.string().max(4096).refine(isAbsolute20, "Use an absolute recovery directory");
+var directory = exports_external.string().max(4096).refine(isAbsolute21, "Use an absolute recovery directory");
 var email4 = exports_external.string().trim().toLowerCase().email().max(254);
 var code = exports_external.string().regex(/^\d{6}$/);
 var recurringSurfaceSchemas = {
@@ -46028,11 +46180,11 @@ function isApiMode(env = process.env) {
   }
 }
 // src/lib/native-storage.ts
-import { createHash as createHash28, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash29, createHmac as createHmac2 } from "crypto";
 import {
   existsSync as existsSync20,
   mkdirSync as mkdirSync16,
-  readFileSync as readFileSync26,
+  readFileSync as readFileSync27,
   readdirSync as readdirSync14,
   statSync as statSync13,
   writeFileSync as writeFileSync14
@@ -46199,12 +46351,12 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const files = [];
   if (existsSync20(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync26(filePath);
+      const bytes = readFileSync27(filePath);
       const relativePath = toPosix(relative10(targetDir, filePath));
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash28("sha256").update(bytes).digest("hex"),
+        sha256: createHash29("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -46229,7 +46381,7 @@ function importSkillsLocalSnapshot(snapshot2, targetDir = process.cwd(), options
       continue;
     }
     const bytes = Buffer.from(file2.contentBase64, "base64");
-    const hash4 = createHash28("sha256").update(bytes).digest("hex");
+    const hash4 = createHash29("sha256").update(bytes).digest("hex");
     if (hash4 !== file2.sha256) {
       throw new Error(`Snapshot file checksum mismatch: ${file2.path}`);
     }
@@ -46561,7 +46713,7 @@ function toIsoString(value) {
   return Number.isNaN(date6.getTime()) ? value : date6.toISOString();
 }
 function sha256Hex2(value) {
-  return createHash28("sha256").update(value).digest("hex");
+  return createHash29("sha256").update(value).digest("hex");
 }
 function normalizeHeaders(headers) {
   const result = {};
@@ -46613,15 +46765,15 @@ function toArrayBuffer(bytes) {
   return buffer;
 }
 // src/lib/station-snapshot.ts
-import { createHash as createHash29 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 import {
   copyFileSync,
   mkdirSync as mkdirSync17,
-  readFileSync as readFileSync27,
+  readFileSync as readFileSync28,
   statSync as statSync15,
   writeFileSync as writeFileSync15
 } from "fs";
-import { dirname as dirname26, isAbsolute as isAbsolute21, relative as relative11, resolve as resolve21, sep as sep13 } from "path";
+import { dirname as dirname26, isAbsolute as isAbsolute22, relative as relative11, resolve as resolve21, sep as sep13 } from "path";
 
 // src/lib/portable-snapshot-filter.ts
 import { readdirSync as readdirSync15, statSync as statSync14 } from "fs";
@@ -46788,7 +46940,7 @@ function validateStationId(stationId) {
   }
 }
 function sha256File(filePath) {
-  return createHash29("sha256").update(readFileSync27(filePath)).digest("hex");
+  return createHash30("sha256").update(readFileSync28(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -46887,7 +47039,7 @@ function writeStationSnapshot(options) {
   for (const plan of plans) {
     const destination = resolve21(repoRoot, plan.destination);
     const destinationRelative = relative11(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep13) || isAbsolute21(destinationRelative)) {
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep13) || isAbsolute22(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -46939,12 +47091,12 @@ function writeStationSnapshot(options) {
   };
 }
 // src/lib/station-hydrate.ts
-import { createHash as createHash30 } from "crypto";
+import { createHash as createHash31 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync18,
   readdirSync as readdirSync16,
-  readFileSync as readFileSync28,
+  readFileSync as readFileSync29,
   statSync as statSync16,
   writeFileSync as writeFileSync16
 } from "fs";
@@ -46963,7 +47115,7 @@ function readSnapshotManifest(repoRoot, stationId) {
   const manifestPath = join42(snapshotRoot, "sync-manifest.json");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync28(manifestPath, "utf8"));
+    manifest = JSON.parse(readFileSync29(manifestPath, "utf8"));
   } catch (error61) {
     fail2("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error61.message}`);
   }
@@ -47099,7 +47251,7 @@ function planStationHydration(stationId, repoRoot) {
         for (const copy of copies) {
           let isStub = false;
           try {
-            isStub = isPointerSkillMd(readFileSync28(copy.fullPath, "utf8"));
+            isStub = isPointerSkillMd(readFileSync29(copy.fullPath, "utf8"));
           } catch {
             isStub = false;
           }
@@ -47145,7 +47297,7 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash30("sha256").update(joined.sort().join(`
+  return createHash31("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
@@ -47237,23 +47389,23 @@ function writeStationHydration(options) {
   };
 }
 // src/lib/private-publication-recovery.ts
-import { constants as constants14, closeSync as closeSync14, fsyncSync as fsyncSync6, fstatSync as fstatSync14, lstatSync as lstatSync26, mkdirSync as mkdirSync19, openSync as openSync14, readSync as readSync12, realpathSync as realpathSync13, renameSync as renameSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname28, isAbsolute as isAbsolute22, join as join43, resolve as resolve23 } from "path";
+import { constants as constants15, closeSync as closeSync15, fsyncSync as fsyncSync7, fstatSync as fstatSync15, lstatSync as lstatSync27, mkdirSync as mkdirSync19, openSync as openSync15, readSync as readSync12, realpathSync as realpathSync14, renameSync as renameSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname28, isAbsolute as isAbsolute23, join as join43, resolve as resolve23 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 var fail3 = () => {
   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(directory2) {
-  if (!isAbsolute22(directory2) || directory2 !== resolve23(directory2) || realpathSync13(directory2) !== directory2)
+  if (!isAbsolute23(directory2) || directory2 !== resolve23(directory2) || realpathSync14(directory2) !== directory2)
     return fail3();
   for (let path = directory2;; path = dirname28(path)) {
-    const stat2 = lstatSync26(path);
+    const stat2 = lstatSync27(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink())
       return fail3();
     if (path === dirname28(path))
       break;
   }
-  const own2 = lstatSync26(directory2);
+  const own2 = lstatSync27(directory2);
   if ((own2.mode & 63) !== 0 || process.getuid && own2.uid !== process.getuid())
     return fail3();
   return { dev: own2.dev, ino: own2.ino };
@@ -47265,9 +47417,9 @@ function unchangedDirectory(directory2, identity5) {
 }
 function readOwned(directory2, name, max) {
   const identity5 = safeDirectory(directory2), file2 = join43(directory2, name);
-  const fd = openSync14(file2, constants14.O_RDONLY | constants14.O_NOFOLLOW);
+  const fd = openSync15(file2, constants15.O_RDONLY | constants15.O_NOFOLLOW);
   try {
-    const stat2 = fstatSync14(fd);
+    const stat2 = fstatSync15(fd);
     if (!stat2.isFile() || stat2.nlink !== 1 || stat2.size > max || stat2.size < 1 || (stat2.mode & 63) !== 0 || process.getuid && stat2.uid !== process.getuid())
       return fail3();
     const buffer = Buffer.alloc(Math.min(max, stat2.size) + 1);
@@ -47278,22 +47430,22 @@ function readOwned(directory2, name, max) {
         break;
       length += count;
     }
-    const bytes = buffer.subarray(0, length), after = fstatSync14(fd);
+    const bytes = buffer.subarray(0, length), after = fstatSync15(fd);
     unchangedDirectory(directory2, identity5);
     if (bytes.length !== stat2.size || stat2.size !== after.size || stat2.mtimeMs !== after.mtimeMs || stat2.ctimeMs !== after.ctimeMs)
       return fail3();
     return bytes;
   } finally {
-    closeSync14(fd);
+    closeSync15(fd);
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync14(join43(directory2, name), constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
+  const fd = openSync15(join43(directory2, name), constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
   try {
     writeFileSync17(fd, bytes);
-    fsyncSync6(fd);
+    fsyncSync7(fd);
   } finally {
-    closeSync14(fd);
+    closeSync15(fd);
   }
 }
 function save(directory2, value) {
@@ -47302,11 +47454,11 @@ function save(directory2, value) {
 `);
   unchangedDirectory(directory2, identity5);
   renameSync8(join43(directory2, temporary), join43(directory2, "receipt.json"));
-  const fd = openSync14(directory2, constants14.O_RDONLY | constants14.O_NOFOLLOW);
+  const fd = openSync15(directory2, constants15.O_RDONLY | constants15.O_NOFOLLOW);
   try {
-    fsyncSync6(fd);
+    fsyncSync7(fd);
   } finally {
-    closeSync14(fd);
+    closeSync15(fd);
   }
 }
 function bind(client2, receipt) {
@@ -47317,20 +47469,20 @@ async function locked(directory2, action) {
   const identity5 = safeDirectory(directory2), file2 = join43(directory2, "operation.lock");
   let fd;
   try {
-    fd = openSync14(file2, constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
+    fd = openSync15(file2, constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
   } catch {
     throw new PrivatePublicationError("PUBLICATION_RECOVERY_BUSY", "Another operation holds this recovery directory. If it crashed, confirm that process has stopped before explicitly removing operation.lock and resuming.");
   }
-  const lock = fstatSync14(fd);
+  const lock = fstatSync15(fd);
   try {
     writeFileSync17(fd, JSON.stringify({ pid: process.pid }) + `
 `);
-    fsyncSync6(fd);
+    fsyncSync7(fd);
     return await action();
   } finally {
-    closeSync14(fd);
+    closeSync15(fd);
     unchangedDirectory(directory2, identity5);
-    const now = lstatSync26(file2);
+    const now = lstatSync27(file2);
     if (now.dev !== lock.dev || now.ino !== lock.ino || !now.isFile() || now.isSymbolicLink())
       fail3();
     unlinkSync6(file2);
@@ -47382,15 +47534,15 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute22(recoveryDirectory) || resolve23(recoveryDirectory) !== recoveryDirectory || realpathSync13(dirname28(recoveryDirectory)) !== dirname28(recoveryDirectory))
+  if (!isAbsolute23(recoveryDirectory) || resolve23(recoveryDirectory) !== recoveryDirectory || realpathSync14(dirname28(recoveryDirectory)) !== dirname28(recoveryDirectory))
     return fail3();
   mkdirSync19(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync14(dirname28(recoveryDirectory), constants14.O_RDONLY | constants14.O_NOFOLLOW);
+  const parent = openSync15(dirname28(recoveryDirectory), constants15.O_RDONLY | constants15.O_NOFOLLOW);
   try {
-    fsyncSync6(parent);
+    fsyncSync7(parent);
   } finally {
-    closeSync14(parent);
+    closeSync15(parent);
   }
   writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
   save(recoveryDirectory, receipt);
@@ -47473,7 +47625,7 @@ async function inspectLocked(client2, directory2, cancel) {
   return privatePublicationResult(directory2, receipt);
 }
 // src/lib/skill-context.ts
-import { createHash as createHash31 } from "crypto";
+import { createHash as createHash32 } from "crypto";
 import { resolve as resolve24 } from "path";
 function words(value) {
   return new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
@@ -47566,7 +47718,7 @@ ${content}`;
 `);
   const receipt = {
     schemaVersion: 1,
-    id: createHash31("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
+    id: createHash32("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
     profileId: profile.profileId,
     profileRevision: profile.profileRevision,
     authority: profile.authority,
@@ -47582,9 +47734,9 @@ ${content}`;
   return { context: context2, selections, omitted, receipt };
 }
 // src/lib/session-reconciliation.ts
-import { createHash as createHash32 } from "crypto";
+import { createHash as createHash33 } from "crypto";
 var SESSION_RECONCILIATION_PLAN_TTL_MS = 5 * 60 * 1000;
-var digest3 = (value) => createHash32("sha256").update(JSON.stringify(value)).digest("hex");
+var digest3 = (value) => createHash33("sha256").update(JSON.stringify(value)).digest("hex");
 function exactTimestamp(value) {
   const parsed = value === undefined ? Number.NaN : Date.parse(value);
   if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== value) {