@hasna/skills 0.10.47 → 0.10.49

package/bin/index.js

@@ -47,6 +47,26 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/lib/launch-cwd.ts
+function restoreLaunchCwd(env = process.env) {
+  const requested = env[LAUNCH_CWD_VARIABLE];
+  delete env[LAUNCH_CWD_VARIABLE];
+  if (!requested || !requested.startsWith("/"))
+    return { restored: false, cwd: process.cwd() };
+  try {
+    process.chdir(requested);
+    return { restored: true, cwd: process.cwd() };
+  } catch {
+    return { restored: false, cwd: process.cwd() };
+  }
+}
+var LAUNCH_CWD_VARIABLE = "HASNA_SKILLS_LAUNCH_CWD";
+
+// src/lib/launch-cwd-apply.ts
+var init_launch_cwd_apply = __esm(() => {
+  restoreLaunchCwd();
+});
+
 // src/cli/output.ts
 async function writeCliOutput(text, newline = true) {
   await new Promise((resolve, reject) => {
@@ -36868,7 +36888,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.47",
+    version: "0.10.49",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -53976,11 +53996,256 @@ function save(file, content) {
 var sameStat = (a, b) => ["dev", "ino", "uid", "nlink", "mode", "size", "mtimeNs", "ctimeNs"].every((key) => a[key] === b[key]);
 var init_codex_hook_trust_files = () => {};
 
+// src/cli/commands/runtime-launcher.ts
+import { createHash as createHash18 } from "crypto";
+import { closeSync as closeSync10, constants as constants11, fchmodSync, fstatSync as fstatSync10, fsyncSync as fsyncSync4, lstatSync as lstatSync19, openSync as openSync10, readFileSync as readFileSync15, readlinkSync as readlinkSync5, realpathSync as realpathSync9, symlinkSync, writeSync as writeSync2 } from "fs";
+import { isAbsolute as isAbsolute13 } from "path";
+function pinnedLauncherEnvironment(env3) {
+  const result2 = {};
+  for (const [name, value] of Object.entries(env3)) {
+    if (value === undefined || !ENV_NAME.test(name) || !ENV_EXACT.has(name) && !ENV_PREFIX.test(name))
+      continue;
+    result2[name] = value;
+  }
+  return result2;
+}
+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_VARIABLE2}=$(pwd -P 2>/dev/null || :)`,
+    `export ${LAUNCH_CWD_VARIABLE2}`,
+    `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(`
+`);
+}
+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;
+}
+function resolveLauncherCommand(path) {
+  const physical = realpathSync9(path);
+  const stat = lstatSync19(physical);
+  if (stat.isFile() && stat.size <= PINNED_LAUNCHER_MAX_BYTES) {
+    const text2 = readFileSync15(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 inspectLauncher(path) {
+  const stat = lstatSync19(path);
+  if (stat.isSymbolicLink()) {
+    const linkTarget = readlinkSync5(path);
+    let target;
+    try {
+      target = realpathSync9(path);
+    } catch {
+      throw new Error("LAUNCHER_TARGET_UNREADABLE");
+    }
+    return { kind: "symlink", linkTarget, target };
+  }
+  if (!stat.isFile())
+    return { kind: "foreign" };
+  const text2 = readFileSync15(path, "utf8");
+  const binding = parsePinnedLauncher(text2);
+  if (!binding)
+    return { kind: "foreign" };
+  return { kind: "pinned", runtime: binding.runtime, cwd: binding.cwd, target: binding.entry, sha256: sha2562(text2), text: text2 };
+}
+function launcherTarget(path) {
+  const inspected = inspectLauncher(path);
+  if (inspected.kind === "foreign")
+    throw new Error("LAUNCHER_SHAPE_UNSUPPORTED");
+  return inspected.target;
+}
+function launcherIs(path, state) {
+  let inspected;
+  try {
+    inspected = inspectLauncher(path);
+  } catch {
+    return false;
+  }
+  if (state.shape === "symlink")
+    return inspected.kind === "symlink" && inspected.linkTarget === state.linkTarget && inspected.target === state.target;
+  return inspected.kind === "pinned" && inspected.sha256 === state.sha256 && inspected.runtime === state.runtime && inspected.cwd === state.cwd && inspected.target === state.target;
+}
+function pinnedLauncherText(state) {
+  const text2 = renderPinnedLauncher({ runtime: state.runtime, cwd: state.cwd, entry: state.target });
+  if (sha2562(text2) !== state.sha256)
+    throw new Error("LAUNCHER_TEXT_DIGEST_MISMATCH");
+  return text2;
+}
+function pinnedLauncherState(runtime, cwd2, target) {
+  const text2 = renderPinnedLauncher({ runtime, cwd: cwd2, entry: target });
+  return { shape: "pinned", runtime, cwd: cwd2, target, sha256: sha2562(text2) };
+}
+function materializeLauncher(path, state) {
+  if (state.shape === "symlink") {
+    symlinkSync(state.linkTarget, path);
+    if (readlinkSync5(path) !== state.linkTarget || realpathSync9(path) !== state.target)
+      throw new Error("LAUNCHER_READBACK_MISMATCH");
+    return;
+  }
+  const text2 = pinnedLauncherText(state);
+  const fd = openSync10(path, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 493);
+  try {
+    const bytes = Buffer.from(text2, "utf8");
+    let written = 0;
+    while (written < bytes.length)
+      written += writeSync2(fd, bytes, written, bytes.length - written);
+    fchmodSync(fd, 493);
+    fsyncSync4(fd);
+    if ((fstatSync10(fd).mode & 511) !== 493)
+      throw new Error("LAUNCHER_READBACK_MISMATCH");
+  } finally {
+    closeSync10(fd);
+  }
+  const stat = lstatSync19(path);
+  if (!stat.isFile() || stat.isSymbolicLink() || readFileSync15(path, "utf8") !== text2)
+    throw new Error("LAUNCHER_READBACK_MISMATCH");
+}
+function pinnedLauncherRuntime() {
+  let runtime;
+  try {
+    runtime = realpathSync9(process.execPath);
+  } catch {
+    throw new Error("LAUNCHER_RUNTIME_UNREADABLE");
+  }
+  assertPinnedLauncherRuntimeSafe(runtime);
+  assertPinnedLauncherShell();
+  return runtime;
+}
+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");
+  }
+}
+function assertPinnedLauncherShell() {
+  for (const tool of ["/bin/sh", "/usr/bin/awk", "/usr/bin/env"]) {
+    let stat;
+    try {
+      stat = lstatSync19(realpathSync9(tool));
+    } catch {
+      throw new Error("LAUNCHER_SHELL_UNSUPPORTED");
+    }
+    if (!stat.isFile() || (stat.mode & 73) === 0)
+      throw new Error("LAUNCHER_SHELL_UNSUPPORTED");
+  }
+  const probe = Bun.spawnSync(["/bin/sh", "-p", "-c", "exit 0"], { env: {}, stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+  if (probe.exitCode !== 0)
+    throw new Error("LAUNCHER_SHELL_UNSUPPORTED");
+}
+var PINNED_LAUNCHER_SCHEMA = "hasna-skills-pinned-launcher-v1", LAUNCH_CWD_VARIABLE2 = "HASNA_SKILLS_LAUNCH_CWD", PINNED_LAUNCHER_BUN_FLAGS, PINNED_LAUNCHER_ENV_NAMES, PINNED_LAUNCHER_ENV_PREFIXES, ENV_NAME, ENV_PREFIX, ENV_EXACT, COMMAND_LINE, PINNED_LAUNCHER_MAX_BYTES;
+var init_runtime_launcher = __esm(() => {
+  PINNED_LAUNCHER_BUN_FLAGS = ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install"];
+  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"
+  ];
+  PINNED_LAUNCHER_ENV_PREFIXES = ["HASNA", "SKILLS", "SKILL", "MCP", "XDG", "LC", "AWS"];
+  ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  ENV_PREFIX = new RegExp(`^(${PINNED_LAUNCHER_ENV_PREFIXES.join("|")})_`);
+  ENV_EXACT = new Set(PINNED_LAUNCHER_ENV_NAMES);
+  COMMAND_LINE = new RegExp(`^set -- '([^']+)' ${PINNED_LAUNCHER_BUN_FLAGS.join(" ")} '--cwd=([^']+)' '([^']+)' "\\$@"$`, "m");
+  PINNED_LAUNCHER_MAX_BYTES = 16 * 1024;
+});
+
 // src/lib/agent-integration.ts
-import { createHash as createHash18, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash19, randomUUID as randomUUID6 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
-import { existsSync as existsSync13, lstatSync as lstatSync19, statSync as statSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync15, 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 constants11, linkSync as linkSync2 } from "fs";
-import { dirname as dirname14, join as join28, resolve as resolve14, relative as relative6, isAbsolute as isAbsolute13, sep as sep7 } from "path";
+import { existsSync as existsSync13, lstatSync as lstatSync20, statSync as statSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync16, 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 constants12, linkSync as linkSync2 } from "fs";
+import { dirname as dirname14, join as join28, resolve as resolve14, relative as relative6, isAbsolute as isAbsolute14, sep as sep7 } from "path";
 import { homedir as homedir3 } from "os";
 function hasTrustedDarwinAcl(fd, allowDenyOnly = false) {
   try {
@@ -54031,11 +54296,11 @@ function isSystemRootAlias(path) {
   const target = `/private${path}`, link2 = `private${path}`;
   const identity6 = (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}`;
   try {
-    const before2 = lstatSync19(path, { bigint: true });
-    if (!before2.isSymbolicLink() || before2.uid !== 0n || readlinkSync5(path) !== link2)
+    const before2 = lstatSync20(path, { bigint: true });
+    if (!before2.isSymbolicLink() || before2.uid !== 0n || readlinkSync6(path) !== link2)
       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") {
@@ -54043,23 +54308,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, constants11.O_RDONLY | constants11.O_DIRECTORY | constants11.O_NOFOLLOW);
+      const fd = openSync11(directory, constants12.O_RDONLY | constants12.O_DIRECTORY | constants12.O_NOFOLLOW);
       try {
-        if (identity6(fstatSync10(fd, { bigint: true })) !== identity6(stat) || !hasTrustedDarwinAcl(fd) || identity6(fstatSync10(fd, { bigint: true })) !== identity6(stat))
+        if (identity6(fstatSync11(fd, { bigint: true })) !== identity6(stat) || !hasTrustedDarwinAcl(fd) || identity6(fstatSync11(fd, { bigint: true })) !== identity6(stat))
           throw new Error("Unverified system alias directory ACL");
       } finally {
-        closeSync10(fd);
+        closeSync11(fd);
       }
       return { directory, identity: identity6(stat) };
     });
-    return realpathSync9(path) === target && readlinkSync5(path) === link2 && identity6(lstatSync19(path, { bigint: true })) === identity6(before2) && directories.every((item) => identity6(lstatSync19(item.directory, { bigint: true })) === item.identity);
+    return realpathSync10(path) === target && readlinkSync6(path) === link2 && identity6(lstatSync20(path, { bigint: true })) === identity6(before2) && directories.every((item) => identity6(lstatSync20(item.directory, { bigint: true })) === item.identity);
   } catch {
     return false;
   }
 }
 function canonicalSystemPath(path) {
   const absolute = resolve14(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}`);
@@ -54068,7 +54333,7 @@ function canonicalSystemPath(path) {
 function assertSafePath(path) {
   let cursor = resolve14(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)
@@ -54078,17 +54343,17 @@ function assertSafePath(path) {
 }
 function readRootAlias(home, agent) {
   assertSafePath(home);
-  const realHome = realpathSync9(home), alias = join28(realHome, `.${agent}`);
-  const stat = lstatSync19(alias, { throwIfNoEntry: false, bigint: true });
+  const realHome = realpathSync10(home), alias = join28(realHome, `.${agent}`);
+  const stat = lstatSync20(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link2 = readlinkSync5(alias), targetPath = resolve14(dirname14(alias), link2);
+  const link2 = readlinkSync6(alias), targetPath = resolve14(dirname14(alias), link2);
   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: link2, aliasIdentity: `${stat.dev}:${stat.ino}:${stat.ctimeNs}`, targetIdentity: `${targetStat.dev}:${targetStat.ino}` };
 }
@@ -54097,7 +54362,7 @@ function rootAliases(home, allowed = false) {
     return [];
   const result2 = [];
   for (const agent of ["claude", "codex"])
-    if (lstatSync19(join28(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync20(join28(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
       result2.push(readRootAlias(home, agent));
   if (result2.some((item, index) => result2.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");
@@ -54114,17 +54379,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 document3;
     try {
-      document3 = realpathSync9(canonicalAgentPath(entry.path, aliases));
+      document3 = realpathSync10(canonicalAgentPath(entry.path, aliases));
     } catch {
       continue;
     }
@@ -54145,16 +54410,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 before2 = lstatSync19(path);
+  const before2 = lstatSync20(path);
   if (!before2.isFile() || before2.size > maximum)
     throw new Error("Unsupported or oversized native skill file");
-  const descriptor = openSync10(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  const descriptor = openSync11(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
   try {
-    const opened = fstatSync10(descriptor);
+    const opened = fstatSync11(descriptor);
     if (!opened.isFile() || opened.dev !== before2.dev || opened.ino !== before2.ino || opened.size !== before2.size)
       throw new Error("Native skill file changed while reading");
     const bytes = Buffer.allocUnsafe(before2.size + 1);
@@ -54165,19 +54430,19 @@ function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
         break;
       length += count;
     }
-    const after2 = fstatSync10(descriptor), current = lstatSync19(path);
+    const after2 = fstatSync11(descriptor), current = lstatSync20(path);
     if (current.dev !== opened.dev || current.ino !== opened.ino || current.size !== after2.size || current.mtimeMs !== after2.mtimeMs || current.ctimeMs !== after2.ctimeMs || length !== before2.size || after2.size !== before2.size || after2.mtimeMs !== opened.mtimeMs || after2.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);
@@ -54225,16 +54490,16 @@ function parseNativeMigrationTargetManifest(input) {
       throw new Error("Invalid native migration target fields");
     if (!ROOTS.some(([agent]) => agent === item.agent))
       throw new Error(`Unsupported native migration target agent: ${item.agent}`);
-    if (!isAbsolute13(item.projectRoot) || resolve14(item.projectRoot) !== item.projectRoot)
+    if (!isAbsolute14(item.projectRoot) || resolve14(item.projectRoot) !== item.projectRoot)
       throw new Error(`Native migration target project root must be an existing absolute directory: ${item.projectRoot}`);
     const projectRoot = canonicalSystemPath(item.projectRoot);
-    if (!existsSync13(projectRoot) || !lstatSync19(projectRoot).isDirectory())
+    if (!existsSync13(projectRoot) || !lstatSync20(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${item.projectRoot}`);
     assertSafePath(projectRoot);
-    if (isAbsolute13(item.path) || item.path.includes("\\") || item.path.length === 0 || item.path.includes("\x00"))
+    if (isAbsolute14(item.path) || item.path.includes("\\") || item.path.length === 0 || item.path.includes("\x00"))
       throw new Error(`Native migration target path must be normalized and project-relative: ${item.path}`);
     const resolved = resolve14(projectRoot, item.path), normalized = relative6(projectRoot, resolved);
-    if (!normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || isAbsolute13(normalized) || normalized !== item.path)
+    if (!normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || isAbsolute14(normalized) || normalized !== item.path)
       throw new Error(`Native migration target path escapes or is not normalized: ${item.path}`);
     if (!/^[0-9a-f]{64}$/.test(item.treeSha256))
       throw new Error(`Invalid native migration tree digest for ${item.path}`);
@@ -54255,13 +54520,13 @@ function selectNativeMigrationTargets(inventory, manifest) {
   const identities = new Set;
   const selected = [];
   for (const target of manifest.targets) {
-    if (!isAbsolute13(target.projectRoot) || resolve14(target.projectRoot) !== target.projectRoot)
+    if (!isAbsolute14(target.projectRoot) || resolve14(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, resolve14(projectRoot, target.path));
-    if (!existsSync13(projectRoot) || !lstatSync19(projectRoot).isDirectory())
+    if (!existsSync13(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 identity6 = `${target.agent}\x00${canonicalSystemPath(projectRoot)}\x00${normalized}`;
     if (identities.has(identity6))
@@ -54304,9 +54569,9 @@ function isCodexSkillDiscoveryInput(path) {
 }
 function inventoryNativeSkills(home = homedir3(), options = {}) {
   home = canonicalSystemPath(home);
-  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute13(options.reviewedCacheAlias) || resolve14(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
+  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute14(options.reviewedCacheAlias) || resolve14(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) || resolve14(path) !== path))
+  if (options.disabledVendorPaths?.some((path) => !isAbsolute14(path) || resolve14(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));
@@ -54325,7 +54590,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
           roots.push(["sumi", canonicalAgentPath(join28(project, directory, name), aliases)]);
   }
   const installationInputs = options.codexInstallationInputRoots ?? [];
-  if (installationInputs.some((input) => resolve14(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) => resolve14(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;
@@ -54339,13 +54604,13 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
   }
   let reviewedCacheAliasFound = false;
   function verifiedSiblingCacheAlias(agent, path, parent) {
-    const link2 = readlinkSync5(path), lexicalTarget = resolve14(parent, link2);
-    if (isAbsolute13(link2) ? link2 !== lexicalTarget : dirname14(link2) !== ".")
+    const link2 = readlinkSync6(path), lexicalTarget = resolve14(parent, link2);
+    if (isAbsolute14(link2) ? link2 !== lexicalTarget : dirname14(link2) !== ".")
       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)
@@ -54370,7 +54635,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       return scan;
     if (!existsSync13(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");
@@ -54387,7 +54652,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       const marker = join28(path, ".hasna-skills.json");
       if (existsSync13(marker)) {
         try {
-          managed = JSON.parse(readFileSync15(marker, "utf8")).managedBy === "@hasna/skills";
+          managed = JSON.parse(readFileSync16(marker, "utf8")).managedBy === "@hasna/skills";
         } catch {}
       }
       const bridge = (!vendor || agent === "sumi") && isOwnedCliBridge(path, bridgePaths);
@@ -54419,7 +54684,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       if (isVendor && !options.includeVendor)
         continue;
       const child = join28(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++;
@@ -54462,7 +54727,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
 }
 function readOptional(path) {
   assertSafePath(path);
-  return existsSync13(path) ? readFileSync15(path, "utf8") : null;
+  return existsSync13(path) ? readFileSync16(path, "utf8") : null;
 }
 function jsonObject(text2, path) {
   if (text2 === null)
@@ -54794,23 +55059,23 @@ function projectedHookAcl(path, observed) {
   if (process.platform !== "darwin")
     return;
   const identity6 = (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}:${stat.nlink}:${stat.size}:${stat.mtimeNs}`;
-  const fd = openSync10(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK | (observed.isDirectory() ? constants11.O_DIRECTORY : 0));
+  const fd = openSync11(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK | (observed.isDirectory() ? constants12.O_DIRECTORY : 0));
   try {
-    if (identity6(fstatSync10(fd, { bigint: true })) !== identity6(observed) || !hasTrustedDarwinAcl(fd, true) || identity6(fstatSync10(fd, { bigint: true })) !== identity6(observed) || identity6(lstatSync19(path, { bigint: true })) !== identity6(observed))
+    if (identity6(fstatSync11(fd, { bigint: true })) !== identity6(observed) || !hasTrustedDarwinAcl(fd, true) || identity6(fstatSync11(fd, { bigint: true })) !== identity6(observed) || identity6(lstatSync20(path, { bigint: true })) !== identity6(observed))
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
   } finally {
-    closeSync10(fd);
+    closeSync11(fd);
   }
 }
 function projectedHookExecutable(command, expectedResolved) {
   try {
-    if (!isAbsolute13(command) || /[\0\r\n]/.test(command) || resolve14(command) !== command)
+    if (!isAbsolute14(command) || /[\0\r\n]/.test(command) || resolve14(command) !== command)
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     command = canonicalSystemPath(command);
     const parents2 = (file = command) => {
       const result2 = [];
       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);
@@ -54820,13 +55085,22 @@ function projectedHookExecutable(command, expectedResolved) {
       }
       return result2;
     };
-    const parentIdentity = parents2(), link2 = lstatSync19(command, { bigint: true });
+    const parentIdentity = parents2(), link2 = lstatSync20(command, { bigint: true });
     if (link2.uid !== BigInt(process.getuid()) || !link2.isFile() && !link2.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(join28(dirname14(dirname14(resolved)), "package.json"), false, { readOnlyPackage: true });
     projectedHookAcl(manifest.file, manifest.stat);
@@ -54839,8 +55113,15 @@ function projectedHookExecutable(command, expectedResolved) {
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     const recheck = () => {
       try {
-        if (realpathSync9(command) !== resolved || linkIdentity(lstatSync19(command, { bigint: true })) !== linkIdentity(link2) || !isDeepStrictEqual7(parents2(), parentIdentity) || !isDeepStrictEqual7(parents2(resolved), resolvedParentIdentity))
+        const again = resolveLauncherCommand(command);
+        if (again.entry !== resolved || again.physical !== target.physical || linkIdentity(lstatSync20(command, { bigint: true })) !== linkIdentity(link2) || !isDeepStrictEqual7(parents2(), parentIdentity) || !isDeepStrictEqual7(parents2(resolved), resolvedParentIdentity))
           hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+        if (launcher) {
+          if (!isDeepStrictEqual7(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);
@@ -55105,7 +55386,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
     if (change.before !== null) {
       const backup = join28(backupRoot, `${index}-${sha3(change.path).slice(0, 12)}.backup`);
       writeFileSync6(backup, change.before, { mode: 384, flag: "wx" });
-      if (readFileSync15(backup, "utf8") !== change.before)
+      if (readFileSync16(backup, "utf8") !== change.before)
         throw new Error("Native configuration preservation readback failed");
       backups.push(backup);
     }
@@ -55168,11 +55449,11 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
-  const descriptor = openSync10(path, constants11.O_RDONLY | constants11.O_DIRECTORY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  const descriptor = openSync11(path, constants12.O_RDONLY | constants12.O_DIRECTORY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
   try {
-    fsyncSync4(descriptor);
+    fsyncSync5(descriptor);
   } finally {
-    closeSync10(descriptor);
+    closeSync11(descriptor);
   }
 }
 function writeArchiveJournal(path, value) {
@@ -55180,18 +55461,18 @@ function writeArchiveJournal(path, value) {
   const temporary = `${path}.skills-${randomUUID6()}`;
   let descriptor;
   try {
-    descriptor = openSync10(temporary, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
+    descriptor = openSync11(temporary, constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.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);
   }
 }
@@ -55237,7 +55518,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)
@@ -55288,7 +55569,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;
@@ -55305,7 +55586,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;
@@ -55338,12 +55619,12 @@ function isInertCodexPluginCacheCopy(entry, cache3, allowedHostPaths, read2) {
       return false;
     const document3 = join28(entry.path, "SKILL.md");
     const inside = relative6(cache3, 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(cache3).isDirectory() || !lstatSync19(entry.path).isDirectory() || !lstatSync19(document3).isFile())
+    if (!lstatSync20(cache3).isDirectory() || !lstatSync20(entry.path).isDirectory() || !lstatSync20(document3).isFile())
       return false;
-    if (realpathSync9.native(cache3) !== cache3 || realpathSync9.native(entry.path) !== entry.path || realpathSync9.native(document3) !== document3)
+    if (realpathSync10.native(cache3) !== cache3 || realpathSync10.native(entry.path) !== entry.path || realpathSync10.native(document3) !== document3)
       return false;
     if (!classifyCodexPluginCacheDocument(document3, cache3, read2))
       return false;
@@ -55535,7 +55816,7 @@ function assertNativeExportAllowed(dataDir3 = getDataDirReadOnly()) {
   if (requiresCliSkillLoading(dataDir3))
     throw new Error("NATIVE_SKILL_EXPORT_DISABLED: this station loads skills through the Skills CLI; use skills sync --selection-profile <id>");
 }
-var sha3 = (data) => createHash18("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
+var sha3 = (data) => createHash19("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
 var init_agent_integration = __esm(() => {
   init_sumi_settings_witness();
   init_codex_corpus_write();
@@ -55555,6 +55836,7 @@ var init_agent_integration = __esm(() => {
   init_agent_hermes();
   init_claude_settings_witness();
   init_codex_hook_trust_files();
+  init_runtime_launcher();
   HOOK_EVENTS = ["UserPromptSubmit", "SessionStart", "SubagentStart"];
   ROOTS = NATIVE_SKILL_ROOTS;
 });
@@ -55698,10 +55980,10 @@ var init_home_migration = __esm(() => {
 import {
   cpSync as cpSync2,
   existsSync as existsSync15,
-  lstatSync as lstatSync20,
+  lstatSync as lstatSync21,
   mkdirSync as mkdirSync8,
   mkdtempSync,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   readdirSync as readdirSync10,
   renameSync as renameSync5,
   rmSync as rmSync2,
@@ -55716,9 +55998,9 @@ function isSkillsOwnershipMarker(marker) {
 function hasSkillsOwnershipMarker(dir) {
   const path = join30(dir, SYNC_MARKER_FILE);
   try {
-    if (!lstatSync20(path).isFile())
+    if (!lstatSync21(path).isFile())
       return false;
-    const marker = JSON.parse(readFileSync16(path, "utf8"));
+    const marker = JSON.parse(readFileSync17(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
   } catch {
     return false;
@@ -55934,7 +56216,7 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
   if (dirExists && managed && hasSkillMd && !options.force && isPointerSkillMd(skillMd)) {
     let existingIsStub = false;
     try {
-      existingIsStub = isPointerSkillMd(readFileSync16(skillMdPath, "utf-8"));
+      existingIsStub = isPointerSkillMd(readFileSync17(skillMdPath, "utf-8"));
     } catch {
       existingIsStub = false;
     }
@@ -55984,7 +56266,7 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
     assertCurrent();
     renameDirectory(candidateDir, dir);
     assertCurrent();
-    if (readFileSync16(skillMdPath, "utf8") !== (skillMd.endsWith(`
+    if (readFileSync17(skillMdPath, "utf8") !== (skillMd.endsWith(`
 `) ? skillMd : `${skillMd}
 `))
       throw new Error("Managed skill readback failed");
@@ -56016,7 +56298,7 @@ function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = f
   if (kind === undefined || kind === "instruction" || preferBundledDocs) {
     const skillMdPath = join30(skillPath, "SKILL.md");
     if (existsSync15(skillMdPath))
-      return readFileSync16(skillMdPath, "utf-8");
+      return readFileSync17(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -56067,7 +56349,7 @@ var init_skill_aliases = __esm(() => {
 });
 
 // src/lib/project-state.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync17, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
 import { join as join31 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
   return join31(targetDir, SKILLS_PROJECT_DIR);
@@ -56080,7 +56362,7 @@ function loadProjectConfig(targetDir = process.cwd()) {
   if (!existsSync16(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync17(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync18(path, "utf-8")));
   } catch {
     return null;
   }
@@ -56234,7 +56516,7 @@ __export(exports_installer, {
   AGENT_TARGETS: () => AGENT_TARGETS,
   AGENT_LABELS: () => AGENT_LABELS
 });
-import { existsSync as existsSync17, readFileSync as readFileSync18, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync19, rmSync as rmSync3 } from "fs";
 import { join as join32 } from "path";
 import { homedir as homedir5 } from "os";
 function getSkillPath(name) {
@@ -56333,7 +56615,7 @@ function createLocalSkillManifest(name, generateSkillMd) {
   let skillMd = "";
   const skillMdPath = join32(sourcePath, "SKILL.md");
   if (existsSync17(skillMdPath)) {
-    skillMd = readFileSync18(skillMdPath, "utf-8");
+    skillMd = readFileSync19(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -56467,7 +56749,7 @@ function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
   const skillMdPath = join32(sourcePath, "SKILL.md");
   if (existsSync17(skillMdPath))
-    return readFileSync18(skillMdPath, "utf-8");
+    return readFileSync19(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -56523,14 +56805,14 @@ function readBundledSkillVersion(name) {
   if (!existsSync17(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync17(path) ? readFileSync18(path, "utf-8") : null;
+  return existsSync17(path) ? readFileSync19(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
@@ -56606,7 +56888,7 @@ __export(exports_skillinfo, {
   generateEnvExample: () => generateEnvExample,
   detectProjectSkills: () => detectProjectSkills
 });
-import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync20 } from "fs";
 import { join as join33 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
@@ -56615,7 +56897,7 @@ function isInstructionSkillDir(skillPath, meta) {
   if (!existsSync18(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync19(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync20(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -56650,7 +56932,7 @@ function getSkillRequirements(name) {
   const meta = getSkill(name);
   let dependencies = {};
   try {
-    dependencies = JSON.parse(readFileSync19(join33(skillPath, "package.json"), "utf8")).dependencies || {};
+    dependencies = JSON.parse(readFileSync20(join33(skillPath, "package.json"), "utf8")).dependencies || {};
   } catch {}
   return getSkillRequirementsFromContent(name, texts, dependencies, meta);
 }
@@ -56739,7 +57021,7 @@ async function runSkill(name, args, options = {}) {
   }
   let entryPoint2;
   try {
-    const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint2 = binValues[0];
@@ -56784,7 +57066,7 @@ async function runSkill(name, args, options = {}) {
 function detectProjectSkills(cwd2 = process.cwd()) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync19(join33(cwd2, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync20(join33(cwd2, "package.json"), "utf8"));
   } catch {
     return { detected: [], recommended: [] };
   }
@@ -56870,7 +57152,7 @@ function generateSkillMd(name) {
   const pkgPath = join33(skillPath, "package.json");
   if (existsSync18(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -56944,7 +57226,7 @@ function extractEnvVars(text2) {
 function readIfExists(path) {
   try {
     if (existsSync18(path)) {
-      return readFileSync19(path, "utf-8");
+      return readFileSync20(path, "utf-8");
     }
   } catch {}
   return null;
@@ -57150,7 +57432,7 @@ var init_selection_resolver = __esm(() => {
 });
 
 // src/lib/plugin-projection.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import { posix } from "path";
 function pluginRefusal(message) {
   throw new SkillSelectionError("PLUGIN_ADMISSION_REFUSED", message);
@@ -57343,7 +57625,7 @@ function buildPluginProjection(entries) {
   files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
   return { manifest, payloads: manifest.payloads, files, witnesses: pluginFileWitnesses(files), originalTreeDigest, projectionTreeDigest: pluginTreeDigest(files), removed: removed.length ? pluginFileWitnesses(removed) : [] };
 }
-var PLUGIN_PROJECTION_MANIFEST = "plugin-projection.json", PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash19("sha256").update(bytes).digest("hex"), MANIFEST_FIELDS;
+var PLUGIN_PROJECTION_MANIFEST = "plugin-projection.json", PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash20("sha256").update(bytes).digest("hex"), MANIFEST_FIELDS;
 var init_plugin_projection = __esm(() => {
   init_selection_cache();
   PLUGIN_PROJECTION_LIMITS = Object.freeze({ files: 1024, bytes: 64 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, metadataBytes: 512 * 1024, registrations: 64, history: 128 });
@@ -57351,12 +57633,12 @@ var init_plugin_projection = __esm(() => {
 });
 
 // src/lib/plugin-projection-store.ts
-import { createHash as createHash20, randomUUID as randomUUID7 } from "crypto";
-import { constants as constants12, closeSync as closeSync11, fchmodSync, fstatSync as fstatSync11, fsyncSync as fsyncSync5, linkSync as linkSync3, lstatSync as lstatSync21, mkdirSync as mkdirSync10, openSync as openSync11, opendirSync as opendirSync4, readSync as readSync9, renameSync as renameSync6, rmdirSync as rmdirSync3, rmSync as rmSync4, unlinkSync as unlinkSync5, writeSync as writeSync2 } from "fs";
-import { dirname as dirname16, isAbsolute as isAbsolute14, join as join34, parse as parse6, resolve as resolve15 } from "path";
+import { createHash as createHash21, randomUUID as randomUUID7 } from "crypto";
+import { constants as constants13, closeSync as closeSync12, fchmodSync as fchmodSync2, fstatSync as fstatSync12, fsyncSync as fsyncSync6, linkSync as linkSync3, lstatSync as lstatSync22, mkdirSync as mkdirSync10, openSync as openSync12, opendirSync as opendirSync4, readSync as readSync9, renameSync as renameSync6, rmdirSync as rmdirSync3, rmSync as rmSync4, unlinkSync as unlinkSync5, writeSync as writeSync3 } from "fs";
+import { dirname as dirname16, isAbsolute as isAbsolute15, join as join34, parse as parse6, resolve as resolve15 } from "path";
 function stat(path) {
   try {
-    return lstatSync21(path, { bigint: true });
+    return lstatSync22(path, { bigint: true });
   } catch (error) {
     if (missing(error))
       return null;
@@ -57364,7 +57646,7 @@ function stat(path) {
   }
 }
 function canonical6(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute14(path) && resolve15(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
+  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute15(path) && resolve15(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -57432,8 +57714,8 @@ function readBytes(path, maximum, kind) {
   fileShape(before2, 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(before2, opened);
     fileShape(opened, maximum, kind);
     const bytes = new Uint8Array(Number(opened.size));
@@ -57444,7 +57726,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;
@@ -57454,7 +57736,7 @@ function readBytes(path, maximum, kind) {
     return pluginRefusal("Cannot safely read plugin file");
   } finally {
     if (fd !== undefined)
-      closeSync11(fd);
+      closeSync12(fd);
   }
 }
 function exactPaths(entries) {
@@ -57564,16 +57846,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);
@@ -57582,7 +57864,7 @@ function writeExclusive(path, bytes, mode) {
     throw error;
   } finally {
     if (fd !== undefined)
-      closeSync11(fd);
+      closeSync12(fd);
   }
 }
 function materializePluginTree(root, entries) {
@@ -57685,11 +57967,11 @@ function pluginExecutableDigest(path) {
   fileShape(before2, 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(before2, 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);
@@ -57698,7 +57980,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")}`;
@@ -57708,14 +57990,14 @@ function pluginExecutableDigest(path) {
     return pluginRefusal("Cannot safely hash plugin executable");
   } finally {
     if (fd !== undefined)
-      closeSync11(fd);
+      closeSync12(fd);
   }
 }
 var READ_FLAGS, WRITE_FLAGS, uid = () => typeof process.getuid === "function" ? BigInt(process.getuid()) : undefined, missing = (error) => Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 var init_plugin_projection_store = __esm(() => {
   init_plugin_projection();
-  READ_FLAGS = constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
-  WRITE_FLAGS = constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
+  READ_FLAGS = constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK;
+  WRITE_FLAGS = constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL | constants13.O_NOFOLLOW | constants13.O_NONBLOCK;
 });
 
 // src/lib/selected-manifest.ts
@@ -57746,7 +58028,7 @@ var init_selected_manifest = __esm(() => {
 
 // src/lib/plugin-admission.ts
 import { homedir as homedir6 } from "os";
-import { isAbsolute as isAbsolute15, join as join35, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute16, join as join35, resolve as resolve16 } from "path";
 function pluginAdmissionRoot() {
   return join35(homedir6(), ".hasna", "skills", "plugin-admission");
 }
@@ -57759,7 +58041,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) && resolve16(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) && resolve16(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);
@@ -57767,7 +58049,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) && resolve16(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute16(value[key].executable) && resolve16(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)");
@@ -57917,7 +58199,7 @@ function pluginResolverCommand(binding) {
 }
 function root(options) {
   const path = options.storeRoot ?? pluginAdmissionRoot();
-  pluginNeed(isAbsolute15(path) && resolve16(path) === path, "Invalid plugin admission store root");
+  pluginNeed(isAbsolute16(path) && resolve16(path) === path, "Invalid plugin admission store root");
   return path;
 }
 function pluginBindingPath(storeRoot, id) {
@@ -58124,8 +58406,8 @@ var init_plugin_admission = __esm(() => {
 });
 
 // src/lib/plugin-discovery.ts
-import { closeSync as closeSync12, constants as constants13, 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 join36, resolve as resolve17 } from "path";
+import { closeSync as closeSync13, constants as constants14, 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 join36, resolve as resolve17 } from "path";
 function validateManagedPluginWitnesses(value) {
   pluginNeed(Array.isArray(value) && value.length > 0 && value.length <= PLUGIN_PROJECTION_LIMITS.registrations, "Invalid managed plugin witness collection");
   const seen = new Set;
@@ -58134,25 +58416,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) && resolve17(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute17(item.storeRoot) && resolve17(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe3(path) {
   pluginText(path);
-  pluginNeed(isAbsolute16(path) && resolve17(path) === path, "Invalid plugin registry path");
+  pluginNeed(isAbsolute17(path) && resolve17(path) === path, "Invalid plugin registry path");
   for (let at2 = path;; at2 = dirname17(at2)) {
-    pluginNeed(!lstatSync22(at2, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
+    pluginNeed(!lstatSync23(at2, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
     if (at2 === dirname17(at2))
       break;
   }
 }
 function readRegistry(path) {
   safe3(path);
-  const initial2 = lstatSync22(path);
+  const initial2 = lstatSync23(path);
   pluginNeed(initial2.isFile() && initial2.size <= 1024 * 1024, "Plugin registry is not a bounded regular file");
-  const fd = openSync12(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+  const fd = openSync13(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
-    const opened = fstatSync12(fd);
+    const opened = fstatSync13(fd);
     pluginNeed(opened.isFile() && opened.ino === initial2.ino && opened.dev === initial2.dev, "Plugin registry changed during open");
     const bytes = Buffer.alloc(1024 * 1024 + 1);
     let length = 0;
@@ -58162,7 +58444,7 @@ function readRegistry(path) {
         break;
       length += count;
     }
-    const after2 = fstatSync12(fd), current = lstatSync22(path);
+    const after2 = fstatSync13(fd), current = lstatSync23(path);
     safe3(path);
     pluginNeed(length <= 1024 * 1024 && length === opened.size && after2.size === opened.size && after2.mtimeMs === opened.mtimeMs && after2.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;
@@ -58174,7 +58456,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) {
@@ -58235,7 +58517,7 @@ function hashManagedPluginRegistry(path, managed) {
       return Object.fromEntries(Object.entries(row).filter(([key]) => !["version", "installPath", "sourceProducerPath", "previousProducerPaths", "lastUpdated"].includes(key)));
     });
     safe3(cacheRoot);
-    const before2 = lstatSync22(cacheRoot);
+    const before2 = lstatSync23(cacheRoot);
     pluginNeed(before2.isDirectory(), "Invalid managed plugin cache root");
     const directory = opendirSync5(cacheRoot), names = [];
     try {
@@ -58258,7 +58540,7 @@ function hashManagedPluginRegistry(path, managed) {
     }
     for (const row of rows)
       pluginNeed(names.includes(row.version), "Managed native plugin installation is missing");
-    const after2 = lstatSync22(cacheRoot);
+    const after2 = lstatSync23(cacheRoot);
     safe3(cacheRoot);
     pluginNeed(before2.dev === after2.dev && before2.ino === after2.ino && before2.mtimeMs === after2.mtimeMs && before2.ctimeMs === after2.ctimeMs, "Managed cache version membership changed during verification");
   }
@@ -58272,20 +58554,20 @@ var init_plugin_discovery = __esm(() => {
 });
 
 // src/lib/claude-marketplace-registry.ts
-import { createHash as createHash21 } from "crypto";
-import { closeSync as closeSync13, constants as constants14, 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 resolve18 } from "path";
+import { createHash as createHash22 } from "crypto";
+import { closeSync as closeSync14, constants as constants15, 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 resolve18 } from "path";
 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) && resolve18(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) && resolve18(value) === value, "requires a normalized absolute path");
 }
 function parents2(path) {
   const result2 = [];
   for (let at2 = dirname18(path);; at2 = dirname18(at2)) {
-    const stat2 = lstatSync23(at2, { bigint: true });
+    const stat2 = lstatSync24(at2, { bigint: true });
     need6(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
     result2.push([at2, stat2]);
     if (at2 === dirname18(at2))
@@ -58296,12 +58578,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), initial2 = lstatSync23(path, { bigint: true });
+  const ancestors2 = parents2(path), initial2 = lstatSync24(path, { bigint: true });
   need6(initial2.isFile() && !initial2.isSymbolicLink() && initial2.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
   need6(initial2.size <= BigInt(budget2.remaining), "exceeds its aggregate byte limit");
-  const fd = openSync13(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
+  const fd = openSync14(path, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
   try {
-    const opened = fstatSync13(fd, { bigint: true });
+    const opened = fstatSync14(fd, { bigint: true });
     need6(opened.isFile() && sameFile2(initial2, opened), "changed during open");
     const bytes = Buffer.alloc(Number(opened.size) + 1);
     let length = 0;
@@ -58311,10 +58593,10 @@ function readRegistry2(path, budget2) {
         break;
       length += count;
     }
-    const after2 = fstatSync13(fd, { bigint: true }), current = lstatSync23(path, { bigint: true });
+    const after2 = fstatSync14(fd, { bigint: true }), current = lstatSync24(path, { bigint: true });
     need6(current.isFile() && sameFile2(opened, after2) && sameFile2(after2, current) && BigInt(length) === opened.size, "changed during read");
     for (const [ancestor, before2] of ancestors2) {
-      const now3 = lstatSync23(ancestor, { bigint: true });
+      const now3 = lstatSync24(ancestor, { bigint: true });
       need6(now3.isDirectory() && before2.dev === now3.dev && before2.ino === now3.ino && before2.mode === now3.mode, "parent changed during read");
     }
     budget2.remaining -= length;
@@ -58324,7 +58606,7 @@ function readRegistry2(path, budget2) {
       throw new Error("Claude marketplace registry is not strict UTF-8");
     }
   } finally {
-    closeSync13(fd);
+    closeSync14(fd);
   }
 }
 function parse7(text2) {
@@ -58438,15 +58720,15 @@ 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 };
 }
 var CLAUDE_MARKETPLACE_REGISTRY_LIMITS, 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, field = (object6, key) => object6.entries.find(([name]) => name === key)?.[1];
 var init_claude_marketplace_registry = __esm(() => {
@@ -58588,7 +58870,7 @@ var fail3 = () => new Error('CODEX_HOOK_TRUST_UNSUPPORTED_LAYOUT: preserve and c
 var init_codex_hook_trust_layout = () => {};
 
 // src/lib/codex-hook-additions-review.ts
-import { isAbsolute as isAbsolute18 } from "path";
+import { isAbsolute as isAbsolute19 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual9 } from "util";
 function exactKeys2(value, keys2) {
   need5(value && typeof value === "object" && !Array.isArray(value) && isDeepStrictEqual9(Object.keys(value).sort(), [...keys2].sort()), "RECONCILE_ADDITIONS_REVIEW_SCHEMA");
@@ -58602,7 +58884,7 @@ function readReviewedAdditionTrustStates(proof, before2, current, journalHooks)
   return captured.states;
 }
 function reviewNativeHookAdditions(options) {
-  need5(isAbsolute18(options.path), "RECONCILE_ADDITIONS_REVIEW_PATH");
+  need5(isAbsolute19(options.path), "RECONCILE_ADDITIONS_REVIEW_PATH");
   const reviewFile = snapshot(options.path, true), review = JSON.parse(reviewFile.text);
   exactKeys2(review, ["version", "kind", "reason", "producerEvidence", "journalIntentSha256", "policySha256", "configCurrentSha256", "hooksCurrentSha256", "producerBefore", "additions"]);
   need5((review.version === 1 || review.version === 2) && review.kind === "native-hook-additions" && text2(review.reason) && text2(review.producerEvidence), "RECONCILE_ADDITIONS_REVIEW_SCHEMA");
@@ -58610,7 +58892,7 @@ function reviewNativeHookAdditions(options) {
     need5(hash2(review[name]) && review[name] === expected, "RECONCILE_ADDITIONS_REVIEW_CHANGED");
   exactKeys2(review.producerBefore, ["configPath", "configSha256", "hooksPath", "hooksSha256"]);
   const before2 = review.producerBefore;
-  need5(isAbsolute18(before2.configPath) && isAbsolute18(before2.hooksPath) && hash2(before2.configSha256) && hash2(before2.hooksSha256), "RECONCILE_ADDITIONS_PRODUCER_PREIMAGE");
+  need5(isAbsolute19(before2.configPath) && isAbsolute19(before2.hooksPath) && hash2(before2.configSha256) && hash2(before2.hooksSha256), "RECONCILE_ADDITIONS_PRODUCER_PREIMAGE");
   const producerConfig = snapshot(before2.configPath, true), producerHooks = snapshot(before2.hooksPath, true);
   need5(producerConfig.sha256 === before2.configSha256 && producerHooks.sha256 === before2.hooksSha256 && producerHooks.sha256 === options.hooksBefore.sha256, "RECONCILE_ADDITIONS_PRODUCER_PREIMAGE");
   const original = structure(options.configBefore.text), producer = structure(producerConfig.text), expectedProducer = structuredClone(original), originalKeys = options.journalHooks.map((hook) => hook.key);
@@ -58671,7 +58953,7 @@ var init_codex_hook_additions_review = __esm(() => {
 });
 
 // src/lib/codex-hook-discovery-recovery.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual10 } from "util";
 function createCodexHookDiscoveryRecovery(binding, before2, current, hooks, additions) {
   const journalHooks = hooks.map(({ key, currentHash }) => ({ key, currentHash }));
@@ -58721,7 +59003,7 @@ function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witnes
   need5(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   return true;
 }
-var sha4 = (text3) => createHash22("sha256").update(text3).digest("hex"), fields, structure2 = (text3) => JSON.parse(JSON.stringify(Bun.TOML.parse(text3))), proofs2;
+var sha4 = (text3) => createHash23("sha256").update(text3).digest("hex"), fields, structure2 = (text3) => JSON.parse(JSON.stringify(Bun.TOML.parse(text3))), proofs2;
 var init_codex_hook_discovery_recovery = __esm(() => {
   init_codex_hook_trust_files();
   init_codex_hook_trust_layout();
@@ -58732,9 +59014,9 @@ var init_codex_hook_discovery_recovery = __esm(() => {
 });
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash23 } from "crypto";
-import { lstatSync as lstatSync24, readFileSync as readFileSync20, readdirSync as readdirSync11, realpathSync as realpathSync10 } from "fs";
-import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute19, join as join37, resolve as resolve19, sep as sep8 } from "path";
+import { createHash as createHash24 } from "crypto";
+import { lstatSync as lstatSync25, readFileSync as readFileSync21, readdirSync as readdirSync11, realpathSync as realpathSync11 } from "fs";
+import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute20, join as join37, resolve as resolve19, sep as sep8 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual11 } from "util";
 function parseConfig(text3, path, toml = false) {
   try {
@@ -58747,10 +59029,10 @@ function parseConfig(text3, path, toml = false) {
   }
 }
 function safe4(path) {
-  if (!isAbsolute19(path) || path.includes("\x00"))
+  if (!isAbsolute20(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;
@@ -58760,12 +59042,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 readFileSync20(path, "utf8");
+  return readFileSync21(path, "utf8");
 }
 function projectNativeDiscoveryFields(text3, format, fields2, path) {
   const object6 = format === "yaml" ? parseHermesConfig(text3) : parseConfig(text3, path, format === "toml");
@@ -58811,10 +59093,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))
@@ -58851,7 +59133,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 cache3 = dirname19(dirname19(controls[0].pluginParent)), config = join37(dirname19(dirname19(cache3)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
@@ -58919,7 +59201,7 @@ function absentRetiredClaudeRoots(binding) {
       continue;
     const root2 = join37(cache3, ...parts.slice(0, 3));
     safe4(root2);
-    if (lstatSync24(root2, { throwIfNoEntry: false }))
+    if (lstatSync25(root2, { throwIfNoEntry: false }))
       continue;
     const claude = dirname19(dirname19(cache3)), settings = join37(claude, "settings.json"), registry = join37(claude, "plugins/installed_plugins.json");
     const full = (path) => binding.sources.find((item) => item.path === path && item.sha256 !== null && item.format === undefined && item.fields === undefined);
@@ -58938,7 +59220,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) || resolve19(active) !== active || dirname19(active) !== dirname19(root2) || active === root2 || !lstatSync24(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync10(active) !== active)
+    if (rows[0].version !== basename10(active) || resolve19(active) !== active || dirname19(active) !== dirname19(root2) || active === root2 || !lstatSync25(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync11(active) !== active)
       continue;
     const activeManifest = full(join37(active, ".claude-plugin/plugin.json"));
     if (!activeManifest || projected(activeManifest) !== activeManifest.sha256)
@@ -58969,7 +59251,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 {
@@ -58983,7 +59265,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);
@@ -59009,7 +59291,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");
   }
 }
@@ -59048,19 +59330,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;
@@ -59103,13 +59385,13 @@ function assertProjectDiscovery(agent, directories, home, canonical7 = resolve19
       for (const name of ["plugin", "plugins"]) {
         const path = canonical7(join37(directory, ".sumi", name));
         safe4(path);
-        if (lstatSync24(path, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(path).length)
+        if (lstatSync25(path, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(path).length)
           throw new Error(`NATIVE_SKILL_DRIFT: project Sumi plugins require a dedicated discovery review: ${path}`);
       }
     if (agent === "claude") {
       const commands = canonical7(join37(directory, ".claude/commands"));
       safe4(commands);
-      if (lstatSync24(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(commands).length)
+      if (lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(commands).length)
         throw new Error("NATIVE_SKILL_DRIFT: legacy project command discovery requires a dedicated format adapter");
     }
   }
@@ -59149,7 +59431,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 || !(isAbsolute19(value) || value.startsWith("~/")))
+      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute20(value) || value.startsWith("~/")))
         unresolved("remote or relative skill sources need a dedicated discovery adapter");
       roots.add(canonical7(value.startsWith("~/") ? join37(home, value.slice(2)) : value));
     }
@@ -59159,19 +59441,19 @@ function resolveAgentDiscovery(options) {
     const plugins = [join37(directory, "plugin"), join37(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 readdirSync11(path).sort()) {
           if (name === "skills-cli.js" && path === plugins[1])
             continue;
           const target = join37(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() && readdirSync11(root2).some((name) => name.endsWith(".md")))
+      if (lstatSync25(root2, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(root2).some((name) => name.endsWith(".md")))
         unresolved("flat markdown skills require a dedicated native migration adapter");
     }
   }
@@ -59199,7 +59481,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 = join37(directory, "package.json"), raw = read2(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
@@ -59213,7 +59495,7 @@ function resolveAgentDiscovery(options) {
         unresolved("installed Gemini package layout is not recognized");
       const builtinRoot = join37(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 readdirSync11(builtinRoot).sort()) {
         const text3 = witness(join37(builtinRoot, name, "SKILL.md"));
@@ -59251,10 +59533,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(join37(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(join37(sep8, ".claude-plugin", "plugin.json")))
         return source;
       const pluginRoot = dirname19(dirname19(source.path)), hooksPath = join37(pluginRoot, "hooks/hooks.json");
-      const hookStat = lstatSync24(hooksPath, { throwIfNoEntry: false });
+      const hookStat = lstatSync25(hooksPath, { throwIfNoEntry: false });
       const text3 = read2(source.path);
       if (text3 === null)
         throw new Error("Reviewed Claude plugin manifest is missing");
@@ -59295,7 +59577,7 @@ function resolveAgentDiscovery(options) {
       unresolved("plugin hooks require a separate no-skill-injection review");
     const commands = join37(root2, "commands");
     safe4(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync24(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
     const rootSkill = witness(join37(root2, "SKILL.md"));
     if (rootSkill !== null)
@@ -59317,7 +59599,7 @@ function resolveAgentDiscovery(options) {
     const installed = registrations === null ? {} : parseConfig(registrations, join37(home, ".claude/plugins/installed_plugins.json")).plugins;
     const commands = canonical7(join37(home, ".claude/commands"));
     safe4(commands);
-    if (lstatSync24(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(commands).length)
+    if (lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync11(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
     for (const [id, enabled] of Object.entries(config.enabledPlugins ?? {})) {
       if (enabled === false)
@@ -59337,7 +59619,7 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split2 = id.lastIndexOf("@"), name = id.slice(0, split2), marketplace = id.slice(split2 + 1);
       const market = config.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split2 < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute19(market.source))
+      if (split2 < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute20(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
       const catalogText = witness(join37(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
@@ -59353,13 +59635,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" || !isAbsolute19(path))
+      if (typeof path !== "string" || !isAbsolute20(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
     const localPlugins = join37(home, ".config/opencode/plugins");
     safe4(localPlugins);
-    if (lstatSync24(localPlugins, { throwIfNoEntry: false }) && readdirSync11(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync25(localPlugins, { throwIfNoEntry: false }) && readdirSync11(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(join37(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
@@ -59367,7 +59649,7 @@ function resolveAgentDiscovery(options) {
   } else if (agent === "hermes") {
     for (const directory of [join37(home, ".hermes/plugins"), join37(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)
@@ -59377,11 +59659,11 @@ function resolveAgentDiscovery(options) {
       unresolved("custom extension or skill paths");
     const directory = join37(home, ".gemini/extensions");
     safe4(directory);
-    if (lstatSync24(directory, { throwIfNoEntry: false }))
+    if (lstatSync25(directory, { throwIfNoEntry: false }))
       for (const name of readdirSync11(directory)) {
         const root2 = join37(directory, name);
         safe4(root2);
-        if (!lstatSync24(root2)?.isDirectory())
+        if (!lstatSync25(root2)?.isDirectory())
           continue;
         const raw = witness(join37(root2, "gemini-extension.json"));
         if (raw === null)
@@ -59394,7 +59676,7 @@ function resolveAgentDiscovery(options) {
   }
   return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join37(home, ".hermes/plugins"), join37(home, ".hermes/hermes-agent")].map((path) => canonical7(path))) } : {} };
 }
-var digest = (text3) => createHash23("sha256").update(text3).digest("hex");
+var digest = (text3) => createHash24("sha256").update(text3).digest("hex");
 var init_agent_discovery = __esm(() => {
   init_sumi_settings_witness();
   init_agent_policy_limits();
@@ -59416,7 +59698,7 @@ var init_agent_discovery = __esm(() => {
 });
 
 // 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 homedir7 } from "os";
 import { basename as basename11, dirname as dirname20, join as join38, resolve as resolve20, sep as sep9 } from "path";
 function pathParts(path) {
@@ -59436,14 +59718,14 @@ function nativeRootMatch(path) {
 function physicalPath(path) {
   let cursor = resolve20(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 resolve20(path);
     cursor = parent;
   }
-  return resolve20(realpathSync11(cursor), ...suffix);
+  return resolve20(realpathSync12(cursor), ...suffix);
 }
 function contains(root2, path) {
   return path === root2 || path.startsWith(root2 + sep9);
@@ -59481,7 +59763,7 @@ function configuredRoots(home, explicitHome) {
       continue;
     }
     const nativeHome = join38(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);
   }
@@ -59526,13 +59808,13 @@ import {
   mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync2,
   readdirSync as readdirSync12,
-  realpathSync as realpathSync12,
+  realpathSync as realpathSync13,
   renameSync as renameSync7,
   rmSync as rmSync5,
   statSync as statSync12,
   writeFileSync as writeFileSync10
 } from "fs";
-import { basename as basename12, dirname as dirname21, isAbsolute as isAbsolute20, join as join39, normalize as normalize4, relative as relative7, resolve as resolve21, sep as sep10 } from "path";
+import { basename as basename12, dirname as dirname21, isAbsolute as isAbsolute21, join as join39, normalize as normalize4, relative as relative7, resolve as resolve21, sep as sep10 } from "path";
 function getPortableSkillsRoot(options = {}) {
   return resolvePortableSkillsRoot(options, true);
 }
@@ -59683,14 +59965,14 @@ function physicalImportPath(path) {
     suffix.unshift(basename12(ancestor));
     ancestor = dirname21(ancestor);
   }
-  return join39(realpathSync12(ancestor), ...suffix);
+  return join39(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 === "" || !isAbsolute20(path) && path !== ".." && !path.startsWith(`..${sep10}`);
+    return path === "" || !isAbsolute21(path) && path !== ".." && !path.startsWith(`..${sep10}`);
   };
   if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
@@ -59907,7 +60189,7 @@ function safeIsDirectory(path) {
   }
 }
 function isSafeRelativePath2(value) {
-  if (!value.trim() || isAbsolute20(value))
+  if (!value.trim() || isAbsolute21(value))
     return false;
   const normalized = normalize4(value).replace(/\\/g, "/");
   return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
@@ -60115,7 +60397,7 @@ __export(exports_registry, {
   CATEGORIES: () => CATEGORIES,
   BASIC_SKILL_NAMES: () => BASIC_SKILL_NAMES
 });
-import { existsSync as existsSync20, readFileSync as readFileSync21, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync23, readdirSync as readdirSync13 } from "fs";
 import { join as join40 } from "path";
 function isBasicSkillName(name) {
   return BASIC_SKILL_NAMES.includes(name);
@@ -60165,7 +60447,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         continue;
       let content;
       try {
-        content = readFileSync21(skillMdPath, "utf-8");
+        content = readFileSync23(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -60202,7 +60484,7 @@ function findExtensionSkillPath(name) {
         continue;
       let content;
       try {
-        content = readFileSync21(skillMdPath, "utf-8");
+        content = readFileSync23(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -61914,7 +62196,7 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/auth-store.ts
-import { chmodSync as chmodSync2, existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync23, renameSync as renameSync8, statSync as statSync13, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync25, renameSync as renameSync8, statSync as statSync13, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
 import { basename as basename13, dirname as dirname22, join as join41 } from "path";
 function getAuthFilePath(env3 = process.env) {
   return skillsCredentialFilePath(env3);
@@ -61928,7 +62210,7 @@ function getAuthIdentity(env3 = process.env) {
 }
 function readIdentity(env3 = process.env) {
   try {
-    const parsed = JSON.parse(readFileSync23(getIdentityFilePath(env3), "utf-8"));
+    const parsed = JSON.parse(readFileSync25(getIdentityFilePath(env3), "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
     const record3 = parsed;
@@ -61959,7 +62241,7 @@ function writeCredentialValues(values2, env3 = process.env) {
   const lines = [];
   const written = new Set;
   if (existsSync21(file)) {
-    for (const raw of readFileSync23(file, "utf-8").split(/\r?\n/)) {
+    for (const raw of readFileSync25(file, "utf-8").split(/\r?\n/)) {
       const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(raw);
       const key = match?.[1];
       if (key && key in values2) {
@@ -61997,7 +62279,7 @@ function readCredentialValue(key, env3 = process.env) {
   if (!existsSync21(file))
     return null;
   try {
-    for (const raw of readFileSync23(file, "utf-8").split(/\r?\n/)) {
+    for (const raw of readFileSync25(file, "utf-8").split(/\r?\n/)) {
       const match = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=\\s*(.*)$`).exec(raw);
       if (!match)
         continue;
@@ -62015,7 +62297,7 @@ function readCredentialValue(key, env3 = process.env) {
 }
 function readIdentityRecord(env3 = process.env) {
   try {
-    const parsed = JSON.parse(readFileSync23(getIdentityFilePath(env3), "utf-8"));
+    const parsed = JSON.parse(readFileSync25(getIdentityFilePath(env3), "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -62335,7 +62617,7 @@ var init_remote_workspace_selection = __esm(() => {
 });
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 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();
@@ -62596,7 +62878,7 @@ var PRIVATE_PUBLICATION_MAX_BYTES, failures, PrivatePublicationError, bad = () =
   throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
 }, invalid3 = () => {
   throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
-}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record5 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys2) => record5(v) && Object.keys(v).sort().join(",") === keys2.sort().join(","), date = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash24("sha256").update(bytes).digest("hex");
+}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record5 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys2) => record5(v) && Object.keys(v).sort().join(",") === keys2.sort().join(","), date = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash25("sha256").update(bytes).digest("hex");
 var init_remote_private_publications = __esm(() => {
   init_fleet_credentials();
   init_remote_workspace_selection();
@@ -81985,7 +82267,7 @@ var init_v4 = __esm(() => {
 });
 
 // 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);
 }
@@ -82029,7 +82311,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");
 }
 var init_canonical_json = () => {};
 
@@ -83943,8 +84225,8 @@ var init_remote_auth = __esm(() => {
 });
 
 // src/lib/sign-in.ts
-import { createHash as createHash26 } from "crypto";
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync13, readFileSync as readFileSync25, readdirSync as readdirSync14, renameSync as renameSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
+import { createHash as createHash27 } from "crypto";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync13, readFileSync as readFileSync26, readdirSync as readdirSync14, renameSync as renameSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
 import { basename as basename14, dirname as dirname23, join as join42 } from "path";
 function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -84094,7 +84376,7 @@ function pendingDeviceSignInStem(env3) {
 }
 function pendingDeviceSignInPath(origin, env3 = process.env) {
   const { dir, stem } = pendingDeviceSignInStem(env3);
-  return join42(dir, `${stem}-${createHash26("sha256").update(origin).digest("hex").slice(0, 16)}.json`);
+  return join42(dir, `${stem}-${createHash27("sha256").update(origin).digest("hex").slice(0, 16)}.json`);
 }
 function savePendingDeviceSignIn(origin, start, env3 = process.env, now3 = Date.now()) {
   const path = pendingDeviceSignInPath(origin, env3);
@@ -84120,7 +84402,7 @@ function loadPendingDeviceSignIn(origin, env3 = process.env, now3 = Date.now())
   let parsed;
   try {
     path = pendingDeviceSignInPath(origin, env3);
-    parsed = JSON.parse(readFileSync25(path, "utf8"));
+    parsed = JSON.parse(readFileSync26(path, "utf8"));
   } catch {
     return null;
   }
@@ -84165,7 +84447,7 @@ function pendingDeviceSignInOrigins(env3 = process.env, now3 = Date.now()) {
     if (!entry.startsWith(`${location.stem}-`) || !/-[0-9a-f]{16}\.json$/.test(entry))
       continue;
     try {
-      const parsed = JSON.parse(readFileSync25(join42(location.dir, entry), "utf8"));
+      const parsed = JSON.parse(readFileSync26(join42(location.dir, entry), "utf8"));
       if (isRecord7(parsed) && typeof parsed.origin === "string" && Number(parsed.expiresAt) > now3 && pendingDeviceSignInPath(parsed.origin, env3) === join42(location.dir, entry))
         origins.push(parsed.origin);
     } catch {}
@@ -84798,7 +85080,7 @@ function optionPrefix(program2, args) {
 }
 
 // src/lib/revision.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 function revisionIdOf(content) {
   const canonicalContent = {
     slug: content.slug,
@@ -84819,7 +85101,7 @@ function revisionIdOf(content) {
     canonicalContent.replacementSlug = content.replacementSlug ?? null;
   }
   const canonical7 = JSON.stringify(canonicalContent);
-  return createHash27("sha256").update(canonical7).digest("hex");
+  return createHash28("sha256").update(canonical7).digest("hex");
 }
 var REVISION_ID_PATTERN;
 var init_revision = __esm(() => {
@@ -84848,7 +85130,7 @@ var init_skill_bundles = __esm(() => {
 });
 
 // src/lib/pull.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync3, readFileSync as readFileSync26, renameSync as renameSync10, rmSync as rmSync6, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync3, readFileSync as readFileSync27, renameSync as renameSync10, rmSync as rmSync6, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname24, join as join43 } from "path";
 async function pullSkills(options = {}) {
   const client2 = options.client !== undefined ? options.client : await createRemoteSkillsClient();
@@ -85010,7 +85292,7 @@ function reconcileTombstone(slug2, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync26(join43(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync27(join43(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -85268,7 +85550,7 @@ var init_pull = __esm(() => {
 });
 
 // src/lib/skill-context.ts
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 import { resolve as resolve22 } from "path";
 function words2(value) {
   return new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
@@ -85361,7 +85643,7 @@ ${content}`;
 `);
   const receipt = {
     schemaVersion: 1,
-    id: createHash28("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
+    id: createHash29("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
     profileId: profile.profileId,
     profileRevision: profile.profileRevision,
     authority: profile.authority,
@@ -85383,7 +85665,7 @@ var init_skill_context = __esm(() => {
 });
 
 // src/lib/session-reconciliation.ts
-import { createHash as createHash29 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual12 } from "util";
 function exactTimestamp(value) {
   const parsed = value === undefined ? Number.NaN : Date.parse(value);
@@ -85591,7 +85873,7 @@ async function reconcileSkillSession(input2, options = {}) {
   const result2 = replaceSkillSession(skillSessionSnapshotBinding(snapshot2), replacement, { ...plan, planDigest }, options, () => assertPlanWindow(issuedAt, expiresAt, (options.now ?? Date.now)()));
   return { applied: true, plan, planDigest, ...result2 };
 }
-var SESSION_RECONCILIATION_PLAN_TTL_MS, digest3 = (value) => createHash29("sha256").update(JSON.stringify(value)).digest("hex"), SESSION_RENEWAL_TIMEOUT_MS = 4000, SESSION_RENEWAL_CONCURRENCY = 4;
+var SESSION_RECONCILIATION_PLAN_TTL_MS, digest3 = (value) => createHash30("sha256").update(JSON.stringify(value)).digest("hex"), SESSION_RENEWAL_TIMEOUT_MS = 4000, SESSION_RENEWAL_CONCURRENCY = 4;
 var init_session_reconciliation = __esm(() => {
   init_profile_client();
   init_selection_cache();
@@ -86517,7 +86799,7 @@ var exports_introspect = {};
 __export(exports_introspect, {
   registerIntrospect: () => registerIntrospect
 });
-import { existsSync as existsSync23, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync28 } from "fs";
 import { join as join44 } from "path";
 import { execSync } from "child_process";
 function registerIntrospect(parent) {
@@ -86739,7 +87021,7 @@ function handleDiff(name, options) {
     present: existsSync23(canonicalSkillMd),
     path: canonicalDir,
     ...existsSync23(canonicalSkillMd) ? { hash: hashSkillMarkdownFile(canonicalSkillMd) } : {},
-    ...existsSync23(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync27(canonicalSkillMd, "utf-8")) } : {}
+    ...existsSync23(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync28(canonicalSkillMd, "utf-8")) } : {}
   };
   const pinned = getInstalledSkills().includes(bare);
   const installMeta = getInstallMeta();
@@ -86748,7 +87030,7 @@ function handleDiff(name, options) {
   let registryVersion = "unknown";
   if (existsSync23(registryPkgPath)) {
     try {
-      registryVersion = JSON.parse(readFileSync27(registryPkgPath, "utf-8")).version || "unknown";
+      registryVersion = JSON.parse(readFileSync28(registryPkgPath, "utf-8")).version || "unknown";
     } catch {}
   }
   const upToDate = installedVersion === registryVersion;
@@ -86762,7 +87044,7 @@ function handleDiff(name, options) {
     let stub;
     if (present && existsSync23(skillMdPath)) {
       try {
-        stub = isPointerSkillMd(readFileSync27(skillMdPath, "utf-8"));
+        stub = isPointerSkillMd(readFileSync28(skillMdPath, "utf-8"));
       } catch {
         stub = undefined;
       }
@@ -87300,7 +87582,7 @@ var exports_init = {};
 __export(exports_init, {
   registerSetup: () => registerSetup
 });
-import { existsSync as existsSync24, readFileSync as readFileSync28, writeFileSync as writeFileSync14, appendFileSync } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync29, writeFileSync as writeFileSync14, appendFileSync } from "fs";
 import { join as join45 } from "path";
 function registerSetup(parent) {
   parent.command("init").option("--json", "Output as JSON", false).option("--for <agent>", "Detect project type and show MCP registration guidance for agent").option("--scope <scope>", "Deprecated; agent skill-folder installs are disabled", "global").description("Initialize project for pinned skills (.env.example, .gitignore)").action((options) => handleInit(options));
@@ -87395,7 +87677,7 @@ Use: skills render`));
     console.log(source_default.dim("  No environment variables detected across pinned skills"));
   const gitignorePath = join45(cwd2, ".gitignore");
   const gitignoreEntries = [".skills/runs/", ".skills/exports/", ".skills/tmp/"];
-  let gitignoreContent = existsSync24(gitignorePath) ? readFileSync28(gitignorePath, "utf-8") : "";
+  let gitignoreContent = existsSync24(gitignorePath) ? readFileSync29(gitignorePath, "utf-8") : "";
   let gitignoreUpdated = false;
   const missingEntries = gitignoreEntries.filter((entry) => !gitignoreContent.includes(entry));
   if (missingEntries.length > 0) {
@@ -87450,7 +87732,7 @@ async function handleImport(file2, options) {
         process.exitCode = 1;
         return;
       }
-      raw = readFileSync28(file2, "utf-8");
+      raw = readFileSync29(file2, "utf-8");
     }
   } catch (err) {
     const error61 = `Failed to read file: ${err.message}`;
@@ -87547,7 +87829,7 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { constants as constants15, closeSync as closeSync14, fstatSync as fstatSync14, lstatSync as lstatSync26, openSync as openSync14, readSync as readSync13, existsSync as existsSync25, mkdirSync as mkdirSync15, readdirSync as readdirSync15, readFileSync as readFileSync29, rmSync as rmSync7, statSync as statSync14, writeFileSync as writeFileSync15 } from "fs";
+import { constants as constants16, closeSync as closeSync15, fstatSync as fstatSync15, lstatSync as lstatSync27, openSync as openSync15, readSync as readSync13, existsSync as existsSync25, mkdirSync as mkdirSync15, readdirSync as readdirSync15, readFileSync as readFileSync30, rmSync as rmSync7, statSync as statSync14, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join46 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
@@ -87651,7 +87933,7 @@ function appendConflictsLedger(appDir, conflicts) {
   let ledger = { version: 1, entries: [] };
   if (existsSync25(ledgerPath)) {
     try {
-      const parsed = JSON.parse(readFileSync29(ledgerPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync30(ledgerPath, "utf-8"));
       if (parsed && typeof parsed === "object" && Array.isArray(parsed.entries)) {
         ledger = parsed;
       }
@@ -87687,7 +87969,7 @@ function adoptUnmarkedHomes(options = {}) {
     const canonical7 = indexCanonicalCorpus(resolveCorpusRoot(options));
     const markers = scan.adoptable.map((entry) => {
       const root2 = codexCorpusRootForPath(entry.path);
-      if (root2 && !roots.includes(root2) || !lstatSync26(entry.path).isDirectory() || existsSync25(join46(entry.path, SYNC_MARKER_FILE)) || hashSkillMarkdownFile(join46(entry.path, "SKILL.md")) !== entry.hash || canonical7.get(entry.skill) !== entry.hash)
+      if (root2 && !roots.includes(root2) || !lstatSync27(entry.path).isDirectory() || existsSync25(join46(entry.path, SYNC_MARKER_FILE)) || hashSkillMarkdownFile(join46(entry.path, "SKILL.md")) !== entry.hash || canonical7.get(entry.skill) !== entry.hash)
         throw new Error("Skill adoption target changed before apply");
       const marker = {
         managedBy: SYNC_MARKER_MANAGED_BY,
@@ -87708,7 +87990,7 @@ function adoptUnmarkedHomes(options = {}) {
 `;
       writeFileSync15(markerPath, bytes, { flag: "wx" });
       assertCurrent();
-      if (readFileSync29(markerPath, "utf8") !== bytes)
+      if (readFileSync30(markerPath, "utf8") !== bytes)
         throw new Error("Skill adoption readback failed");
     }
     assertCurrent();
@@ -87719,14 +88001,14 @@ function adoptUnmarkedHomes(options = {}) {
 function pruneOwnership(dir) {
   let descriptor;
   try {
-    const directory = lstatSync26(dir);
+    const directory = lstatSync27(dir);
     if (!directory.isDirectory())
       return;
-    const markerPath = join46(dir, SYNC_MARKER_FILE), markerPathBefore = lstatSync26(markerPath);
+    const markerPath = join46(dir, SYNC_MARKER_FILE), markerPathBefore = lstatSync27(markerPath);
     if (!markerPathBefore.isFile())
       return;
-    descriptor = openSync14(markerPath, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
-    const before2 = fstatSync14(descriptor);
+    descriptor = openSync15(markerPath, constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
+    const before2 = fstatSync15(descriptor);
     if (!before2.isFile() || before2.dev !== markerPathBefore.dev || before2.ino !== markerPathBefore.ino || before2.size !== markerPathBefore.size || before2.mtimeMs !== markerPathBefore.mtimeMs || before2.ctimeMs !== markerPathBefore.ctimeMs || before2.size < 1 || before2.size > 65536)
       return;
     const bytes = Buffer.alloc(before2.size + 1);
@@ -87737,7 +88019,7 @@ function pruneOwnership(dir) {
         break;
       length += count;
     }
-    const after2 = fstatSync14(descriptor), current = lstatSync26(dir), markerPathAfter = lstatSync26(markerPath);
+    const after2 = fstatSync15(descriptor), current = lstatSync27(dir), markerPathAfter = lstatSync27(markerPath);
     if (!markerPathAfter.isFile() || markerPathAfter.dev !== before2.dev || markerPathAfter.ino !== before2.ino || markerPathAfter.size !== before2.size || markerPathAfter.mtimeMs !== before2.mtimeMs || markerPathAfter.ctimeMs !== before2.ctimeMs || length !== before2.size || after2.size !== before2.size || after2.mtimeMs !== before2.mtimeMs || after2.ctimeMs !== before2.ctimeMs || !current.isDirectory() || current.dev !== directory.dev || current.ino !== directory.ino)
       return;
     const text4 = bytes.subarray(0, length).toString("utf8"), marker = JSON.parse(text4);
@@ -87748,7 +88030,7 @@ function pruneOwnership(dir) {
     return;
   } finally {
     if (descriptor !== undefined)
-      closeSync14(descriptor);
+      closeSync15(descriptor);
   }
 }
 function pruneStrayHomes(options = {}) {
@@ -87834,7 +88116,7 @@ var init_home_adoption = __esm(() => {
 });
 
 // src/lib/home-census.ts
-import { existsSync as existsSync26, readFileSync as readFileSync30, readdirSync as readdirSync16, statSync as statSync15 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync31, readdirSync as readdirSync16, statSync as statSync15 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join47 } from "path";
 function sortEntries(entries) {
@@ -87905,14 +88187,14 @@ function censusHomeDrift(options = {}) {
       if (homeHash !== canonicalHash) {
         let homeStub;
         try {
-          homeStub = isPointerSkillMd(readFileSync30(skillMdPath, "utf-8"));
+          homeStub = isPointerSkillMd(readFileSync31(skillMdPath, "utf-8"));
         } catch {
           homeStub = undefined;
         }
         let canonicalStub;
         const canonicalSkillMd = join47(corpusRoot, skill, "SKILL.md");
         try {
-          canonicalStub = isPointerSkillMd(readFileSync30(canonicalSkillMd, "utf-8"));
+          canonicalStub = isPointerSkillMd(readFileSync31(canonicalSkillMd, "utf-8"));
         } catch {
           canonicalStub = undefined;
         }
@@ -87950,7 +88232,7 @@ var init_home_census = __esm(() => {
 });
 
 // src/cli/env-assignment.ts
-import { closeSync as closeSync15, constants as constants16, fstatSync as fstatSync15, ftruncateSync as ftruncateSync2, lstatSync as lstatSync27, openSync as openSync15, readFileSync as readFileSync31, writeSync as writeSync3 } from "fs";
+import { closeSync as closeSync16, constants as constants17, fstatSync as fstatSync16, ftruncateSync as ftruncateSync2, lstatSync as lstatSync28, openSync as openSync16, readFileSync as readFileSync32, writeSync as writeSync4 } from "fs";
 function serializeValue(value) {
   if (controls.test(value))
     throw new EnvAssignmentError("Environment values cannot contain control characters or newlines.");
@@ -88029,7 +88311,7 @@ function setEnvAssignment(path, assignment) {
   try {
     const previous = (() => {
       try {
-        return lstatSync27(path);
+        return lstatSync28(path);
       } catch (error61) {
         if (error61.code === "ENOENT")
           return;
@@ -88038,14 +88320,14 @@ function setEnvAssignment(path, assignment) {
     })();
     if (previous && !previous.isFile())
       throw new EnvAssignmentError("The project .env must be a regular file, not a symlink or special file.");
-    descriptor = openSync15(path, previous ? constants16.O_RDWR | constants16.O_NOFOLLOW | constants16.O_NONBLOCK : constants16.O_WRONLY | constants16.O_CREAT | constants16.O_EXCL | constants16.O_NOFOLLOW, 384);
-    const opened = fstatSync15(descriptor);
+    descriptor = openSync16(path, previous ? constants17.O_RDWR | constants17.O_NOFOLLOW | constants17.O_NONBLOCK : constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.O_NOFOLLOW, 384);
+    const opened = fstatSync16(descriptor);
     if (!opened.isFile() || previous && (opened.ino !== previous.ino || opened.dev !== previous.dev)) {
       throw new EnvAssignmentError("The project .env changed while opening it; retry with a regular file.");
     }
     let prepared = initial2;
     if (previous) {
-      const original = readFileSync31(descriptor), text4 = original.toString("utf8");
+      const original = readFileSync32(descriptor), text4 = original.toString("utf8");
       if (!Buffer.from(text4, "utf8").equals(original))
         throw new EnvAssignmentError(INVALID_LAYOUT);
       prepared = prepareEnvAssignment(assignment, text4);
@@ -88053,7 +88335,7 @@ function setEnvAssignment(path, assignment) {
     const bytes = Buffer.from(prepared.content, "utf8");
     let written = 0;
     while (written < bytes.length) {
-      const count = writeSync3(descriptor, bytes, written, bytes.length - written, written);
+      const count = writeSync4(descriptor, bytes, written, bytes.length - written, written);
       if (count === 0)
         throw new Error("Incomplete file write");
       written += count;
@@ -88066,7 +88348,7 @@ function setEnvAssignment(path, assignment) {
     throw new EnvAssignmentError("Cannot safely read or write the project .env file.");
   } finally {
     if (descriptor !== undefined)
-      closeSync15(descriptor);
+      closeSync16(descriptor);
   }
 }
 var INVALID_LAYOUT = "Cannot safely update .env with multiline or unsupported assignments. Use single-line KEY=VALUE entries or edit the file manually.", controls, EnvAssignmentError;
@@ -88132,7 +88414,7 @@ var exports_diagnostic = {};
 __export(exports_diagnostic, {
   registerDiagnostic: () => registerDiagnostic
 });
-import { existsSync as existsSync27, readFileSync as readFileSync32, readdirSync as readdirSync17, statSync as statSync16 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync33, readdirSync as readdirSync17, statSync as statSync16 } from "fs";
 import { join as join48 } from "path";
 import { execSync as execSync2 } from "child_process";
 function registerDiagnostic(parent) {
@@ -88373,7 +88655,7 @@ function handleOutdated(options) {
     let registryVersion = "unknown";
     if (existsSync27(registryPkgPath))
       try {
-        registryVersion = JSON.parse(readFileSync32(registryPkgPath, "utf-8")).version || "unknown";
+        registryVersion = JSON.parse(readFileSync33(registryPkgPath, "utf-8")).version || "unknown";
       } catch {}
     if (installedVersion !== registryVersion)
       pins.push({ skill: name, installedVersion, registryVersion });
@@ -88584,11 +88866,11 @@ var init_cloud_executions = __esm(() => {
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP3 } from "net";
 import { spawnSync as spawnSync3 } from "child_process";
-import { closeSync as closeSync16, fstatSync as fstatSync16, openSync as openSync16, readFileSync as readFileSync33 } from "fs";
+import { closeSync as closeSync17, fstatSync as fstatSync17, openSync as openSync17, readFileSync as readFileSync34 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW3, O_NONBLOCK as O_NONBLOCK3, O_RDONLY as O_RDONLY3 } from "constants";
 import { createRequire as createRequire2 } from "module";
 import { hostname as osHostname2 } from "os";
-import { isAbsolute as isAbsolute21, join as join49 } from "path";
+import { isAbsolute as isAbsolute22, join as join49 } from "path";
 import { createRequire as createRequire22 } from "module";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -88612,7 +88894,7 @@ function homeDir2(env3) {
 }
 function absoluteOverride2(env3, key) {
   const value = env3[key]?.trim();
-  return value && isAbsolute21(value) ? value : null;
+  return value && isAbsolute22(value) ? value : null;
 }
 function hasnaHomeDir2(env3) {
   const override = absoluteOverride2(env3, HASNA_HOME_ENV_KEY2);
@@ -88689,7 +88971,7 @@ function readAppConfigFile2(path) {
   };
   let fd = -1;
   try {
-    fd = openSync16(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
+    fd = openSync17(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
   } catch (error61) {
     const code = error61.code;
     if (code === "ENOENT" || code === "ENOTDIR")
@@ -88699,7 +88981,7 @@ function readAppConfigFile2(path) {
     unsafe(`the path could not be opened (${code ?? "unknown error"})`);
   }
   try {
-    const before2 = fstatSync16(fd);
+    const before2 = fstatSync17(fd);
     if (!before2.isFile())
       unsafe("the path is not a regular file");
     if (!configFileModeAllowed2(before2.mode)) {
@@ -88710,15 +88992,15 @@ function readAppConfigFile2(path) {
       unsafe("the file is not owned by the current user");
     if (before2.size > MAX_CREDENTIAL_FILE_BYTES2)
       unsafe("the file exceeds the size limit");
-    const bytes = readFileSync33(fd);
-    const after2 = fstatSync16(fd);
+    const bytes = readFileSync34(fd);
+    const after2 = fstatSync17(fd);
     if (!configFileReadsCoherent2(before2, after2)) {
       unsafe("the file changed while being read");
     }
     return parseEnvFile2(bytes.toString("utf8"));
   } finally {
     if (fd !== -1)
-      closeSync16(fd);
+      closeSync17(fd);
   }
 }
 function readCredentialFile2(path, apiKeyKeys) {
@@ -89884,7 +90166,7 @@ var init_sdk = __esm(() => {
 });
 
 // src/lib/execution-secrets.ts
-import { constants as constants17, closeSync as closeSync17, fstatSync as fstatSync17, openSync as openSync17, readSync as readSync14, realpathSync as realpathSync13 } from "fs";
+import { constants as constants18, closeSync as closeSync18, fstatSync as fstatSync18, openSync as openSync18, readSync as readSync14, realpathSync as realpathSync14 } from "fs";
 import { hostname as stationHostname } from "os";
 function selectedSecretBindingsTemplate(scope, names, createClient2 = createSecretsClientFromEnv) {
   let secretsAuthority;
@@ -89897,7 +90179,7 @@ function selectedSecretBindingsTemplate(scope, names, createClient2 = createSecr
   return {
     schema: "hasna.skills-secret-bindings.v1",
     selection: { authority, workspaceId, profileId: scope.profileId, profileRevision, slug: slug2, version: version2, bundleDigest },
-    consumer: { stationId: process.env.HASNA_STATION || stationHostname(), workspaceDirectory: realpathSync13(scope.cwd) },
+    consumer: { stationId: process.env.HASNA_STATION || stationHostname(), workspaceDirectory: realpathSync14(scope.cwd) },
     secretsAuthority,
     bindings: Object.fromEntries(names.map((name) => [name, ""]))
   };
@@ -89928,8 +90210,8 @@ function declaredSecretNames(value) {
 function readSelectedSecretBindings(path) {
   let fd;
   try {
-    fd = openSync17(path, constants17.O_RDONLY | constants17.O_NOFOLLOW | constants17.O_NONBLOCK);
-    const stat2 = fstatSync17(fd);
+    fd = openSync18(path, constants18.O_RDONLY | constants18.O_NOFOLLOW | constants18.O_NONBLOCK);
+    const stat2 = fstatSync18(fd);
     if (!stat2.isFile() || stat2.size > 65536)
       throw new Error;
     const bytes = Buffer.alloc(65537);
@@ -89944,7 +90226,7 @@ function readSelectedSecretBindings(path) {
     return refuse4("INVALID_SECRET_BINDINGS", "Secret bindings must be a regular JSON file of at most 64 KiB, containing reference names only.");
   } finally {
     if (fd !== undefined)
-      closeSync17(fd);
+      closeSync18(fd);
   }
 }
 function validateSelectedSecretBindings(value, scope, names) {
@@ -89957,7 +90239,7 @@ function validateSelectedSecretBindings(value, scope, names) {
   }
   let workspaceDirectory;
   try {
-    workspaceDirectory = realpathSync13(scope.cwd);
+    workspaceDirectory = realpathSync14(scope.cwd);
   } catch {
     return refuse4("SECRET_BINDING_CONSUMER_MISMATCH", "The execution workspace cannot be resolved.");
   }
@@ -90233,9 +90515,9 @@ __export(exports_selected_run, {
   prepareSelectedSecretBindings: () => prepareSelectedSecretBindings,
   executeSelectedLocal: () => executeSelectedLocal
 });
-import { createHash as createHash30 } from "crypto";
+import { createHash as createHash31 } from "crypto";
 import { spawn as spawn3 } from "child_process";
-import { mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync4, writeFileSync as writeFileSync16, realpathSync as realpathSync14 } from "fs";
+import { mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync4, writeFileSync as writeFileSync16, realpathSync as realpathSync15 } from "fs";
 import { dirname as dirname25, join as join50, resolve as resolve23 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 async function resolveSelectedRun(spec, profileId, options = {}) {
@@ -90342,7 +90624,7 @@ async function executeSelectedLocal(selected, options = {}) {
     const { authority: authority2, workspaceId, profileRevision, slug: slug2, version: version2, bundleDigest } = selection2;
     const request2 = {
       selection: { authority: authority2, workspaceId, profileId, profileRevision, slug: slug2, version: version2, bundleDigest },
-      consumer: { stationId: process.env.HASNA_STATION || stationHostname2(), workspaceDirectory: realpathSync14(options.cwd ?? process.cwd()) }
+      consumer: { stationId: process.env.HASNA_STATION || stationHostname2(), workspaceDirectory: realpathSync15(options.cwd ?? process.cwd()) }
     };
     const grant = await (options.resolveExecutionGrant ?? resolveExecutionGrant)(request2);
     if (!grant || !grantIdentifier(grant.policyRevision) || !grantIdentifier(grant.grantId))
@@ -90359,7 +90641,7 @@ async function executeSelectedLocal(selected, options = {}) {
     selection: selection2,
     target: "local",
     runtime: runtimeName,
-    inputDigest: `sha256:${createHash30("sha256").update(input2).digest("hex")}`,
+    inputDigest: `sha256:${createHash31("sha256").update(input2).digest("hex")}`,
     runDirectory,
     ...executionGrant ? { executionGrant } : {},
     ...bindings ? { secretBinding: { schema: bindings.schema, selection: bindings.selection, consumer: bindings.consumer, secretsAuthority: bindings.secretsAuthority, bindings: bindings.bindings } } : {},
@@ -94576,8 +94858,8 @@ var init_runs = __esm(() => {
 });
 
 // src/lib/run-state.ts
-import { createHash as createHash31, randomBytes } from "crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync34, readdirSync as readdirSync18, statSync as statSync17, writeFileSync as writeFileSync17 } from "fs";
+import { createHash as createHash32, randomBytes } from "crypto";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync35, readdirSync as readdirSync18, statSync as statSync17, writeFileSync as writeFileSync17 } from "fs";
 import { extname, join as join51, relative as relative8 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now3 = new Date;
@@ -94649,7 +94931,7 @@ function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
   const path = join51(context.runDir, "events.ndjson");
-  const previous = existsSync28(path) ? readFileSync34(path, "utf-8") : "";
+  const previous = existsSync28(path) ? readFileSync35(path, "utf-8") : "";
   writeFileSync17(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
@@ -94709,11 +94991,11 @@ function collectRunArtifacts(context) {
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
     const stat2 = statSync17(path);
-    const bytes = readFileSync34(path);
+    const bytes = readFileSync35(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash31("sha256").update(bytes).digest("hex"),
+      sha256: createHash32("sha256").update(bytes).digest("hex"),
       sizeBytes: stat2.size
     });
   }
@@ -94724,7 +95006,7 @@ function readRunRecord(runDir) {
   if (!existsSync28(path))
     return null;
   try {
-    return JSON.parse(readFileSync34(path, "utf-8"));
+    return JSON.parse(readFileSync35(path, "utf-8"));
   } catch {
     return null;
   }
@@ -98670,11 +98952,11 @@ var require_codegen = __commonJS((exports) => {
       const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       if (!names[this.name.str])
         return;
       if (this.rhs)
-        this.rhs = optimizeExpr(this.rhs, names, constants18);
+        this.rhs = optimizeExpr(this.rhs, names, constants19);
       return this;
     }
     get names() {
@@ -98692,10 +98974,10 @@ var require_codegen = __commonJS((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
         return;
-      this.rhs = optimizeExpr(this.rhs, names, constants18);
+      this.rhs = optimizeExpr(this.rhs, names, constants19);
       return this;
     }
     get names() {
@@ -98761,8 +99043,8 @@ var require_codegen = __commonJS((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : undefined;
     }
-    optimizeNames(names, constants18) {
-      this.code = optimizeExpr(this.code, names, constants18);
+    optimizeNames(names, constants19) {
+      this.code = optimizeExpr(this.code, names, constants19);
       return this;
     }
     get names() {
@@ -98792,12 +99074,12 @@ var require_codegen = __commonJS((exports) => {
       }
       return nodes.length > 0 ? this : undefined;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n2 = nodes[i];
-        if (n2.optimizeNames(names, constants18))
+        if (n2.optimizeNames(names, constants19))
           continue;
         subtractNames(names, n2.names);
         nodes.splice(i, 1);
@@ -98854,12 +99136,12 @@ var require_codegen = __commonJS((exports) => {
         return;
       return this;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       var _a3;
-      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants18);
-      if (!(super.optimizeNames(names, constants18) || this.else))
+      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants19);
+      if (!(super.optimizeNames(names, constants19) || this.else))
         return;
-      this.condition = optimizeExpr(this.condition, names, constants18);
+      this.condition = optimizeExpr(this.condition, names, constants19);
       return this;
     }
     get names() {
@@ -98884,10 +99166,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants18) {
-      if (!super.optimizeNames(names, constants18))
+    optimizeNames(names, constants19) {
+      if (!super.optimizeNames(names, constants19))
         return;
-      this.iteration = optimizeExpr(this.iteration, names, constants18);
+      this.iteration = optimizeExpr(this.iteration, names, constants19);
       return this;
     }
     get names() {
@@ -98925,10 +99207,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants18) {
-      if (!super.optimizeNames(names, constants18))
+    optimizeNames(names, constants19) {
+      if (!super.optimizeNames(names, constants19))
         return;
-      this.iterable = optimizeExpr(this.iterable, names, constants18);
+      this.iterable = optimizeExpr(this.iterable, names, constants19);
       return this;
     }
     get names() {
@@ -98973,11 +99255,11 @@ var require_codegen = __commonJS((exports) => {
       (_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants18) {
+    optimizeNames(names, constants19) {
       var _a3, _b;
-      super.optimizeNames(names, constants18);
-      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants18);
-      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants18);
+      super.optimizeNames(names, constants19);
+      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants19);
+      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants19);
       return this;
     }
     get names() {
@@ -99251,7 +99533,7 @@ var require_codegen = __commonJS((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants18) {
+  function optimizeExpr(expr, names, constants19) {
     if (expr instanceof code_1.Name)
       return replaceName(expr);
     if (!canOptimize(expr))
@@ -99266,14 +99548,14 @@ var require_codegen = __commonJS((exports) => {
       return items;
     }, []));
     function replaceName(n2) {
-      const c = constants18[n2.str];
+      const c = constants19[n2.str];
       if (c === undefined || names[n2.str] !== 1)
         return n2;
       delete names[n2.str];
       return c;
     }
     function canOptimize(e2) {
-      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants18[c.str] !== undefined);
+      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants19[c.str] !== undefined);
     }
   }
   function subtractNames(names, from) {
@@ -106749,11 +107031,11 @@ var init_remote_customer_operations = __esm(() => {
 });
 
 // src/lib/workspace-profile.ts
-import { constants as constants18, closeSync as closeSync18, fstatSync as fstatSync18, lstatSync as lstatSync28, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync5, openSync as openSync18, readFileSync as readFileSync35, renameSync as renameSync11, rmSync as rmSync8, writeFileSync as writeFileSync18 } from "fs";
+import { constants as constants19, closeSync as closeSync19, fstatSync as fstatSync19, lstatSync as lstatSync29, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync5, openSync as openSync19, readFileSync as readFileSync36, renameSync as renameSync11, rmSync as rmSync8, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname26, join as join52 } from "path";
 function stat2(path) {
   try {
-    return lstatSync28(path);
+    return lstatSync29(path);
   } catch (error61) {
     if (error61.code === "ENOENT")
       return null;
@@ -106763,14 +107045,14 @@ function stat2(path) {
 function safeText(file2) {
   if (stat2(file2) === null)
     return null;
-  const fd = openSync18(file2, constants18.O_RDONLY | constants18.O_NOFOLLOW | constants18.O_NONBLOCK);
+  const fd = openSync19(file2, constants19.O_RDONLY | constants19.O_NOFOLLOW | constants19.O_NONBLOCK);
   try {
-    const s = fstatSync18(fd);
+    const s = fstatSync19(fd);
     if (!s.isFile() || s.size > 65536 || ![256, 384].includes(s.mode & 4095) || process.getuid && s.uid !== process.getuid())
       return fail4("The selected profile must use bounded owner-only regular files.");
-    return readFileSync35(fd, "utf8");
+    return readFileSync36(fd, "utf8");
   } finally {
-    closeSync18(fd);
+    closeSync19(fd);
   }
 }
 function checkIdentityMetadata(file2, identity6) {
@@ -107117,8 +107399,8 @@ var init_recurring_customer = __esm(() => {
 });
 
 // src/lib/recurring-recovery.ts
-import { constants as constants19, closeSync as closeSync19, fsyncSync as fsyncSync6, fstatSync as fstatSync19, lstatSync as lstatSync29, mkdirSync as mkdirSync19, openSync as openSync19, readSync as readSync15, realpathSync as realpathSync15, renameSync as renameSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname27, isAbsolute as isAbsolute22, join as join53, resolve as resolve24 } from "path";
+import { constants as constants20, closeSync as closeSync20, fsyncSync as fsyncSync7, fstatSync as fstatSync20, lstatSync as lstatSync30, mkdirSync as mkdirSync19, openSync as openSync20, readSync as readSync15, realpathSync as realpathSync16, renameSync as renameSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname27, isAbsolute as isAbsolute23, join as join53, resolve as resolve24 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 
 class RecoveryOwner {
@@ -107126,10 +107408,10 @@ class RecoveryOwner {
   parents = [];
   constructor(directory) {
     this.directory = directory;
-    if (!isAbsolute22(directory) || resolve24(directory) !== directory || realpathSync15(directory) !== directory)
+    if (!isAbsolute23(directory) || resolve24(directory) !== directory || realpathSync16(directory) !== directory)
       invalid6();
     for (let path = directory;; path = dirname27(path)) {
-      const stat3 = lstatSync29(path);
+      const stat3 = lstatSync30(path);
       if (!stat3.isDirectory() || stat3.isSymbolicLink())
         invalid6();
       this.parents.push({ path, dev: stat3.dev, ino: stat3.ino });
@@ -107139,22 +107421,22 @@ class RecoveryOwner {
     this.assert();
   }
   assert() {
-    if (realpathSync15(this.directory) !== this.directory)
+    if (realpathSync16(this.directory) !== this.directory)
       invalid6();
     for (const prior of this.parents) {
-      const now3 = lstatSync29(prior.path);
+      const now3 = lstatSync30(prior.path);
       if (!now3.isDirectory() || now3.isSymbolicLink() || now3.dev !== prior.dev || now3.ino !== prior.ino)
         invalid6();
     }
-    const own2 = lstatSync29(this.directory);
+    const own2 = lstatSync30(this.directory);
     if ((own2.mode & 511) !== 448 || (own2.mode & 3584) !== 0 || process.getuid && own2.uid !== process.getuid())
       invalid6();
   }
   read(name) {
     this.assert();
-    const fd = openSync19(join53(this.directory, name), constants19.O_RDONLY | constants19.O_NOFOLLOW | constants19.O_NONBLOCK);
+    const fd = openSync20(join53(this.directory, name), constants20.O_RDONLY | constants20.O_NOFOLLOW | constants20.O_NONBLOCK);
     try {
-      const before2 = fstatSync19(fd);
+      const before2 = fstatSync20(fd);
       if (!before2.isFile() || before2.nlink !== 1 || (before2.mode & 4095) !== 384 || before2.size < 1 || before2.size > 8192 || process.getuid && before2.uid !== process.getuid())
         invalid6();
       const bytes = Buffer.alloc(before2.size + 1);
@@ -107165,36 +107447,36 @@ class RecoveryOwner {
           break;
         size2 += n2;
       }
-      const after2 = fstatSync19(fd), path = lstatSync29(join53(this.directory, name));
+      const after2 = fstatSync20(fd), path = lstatSync30(join53(this.directory, name));
       if (size2 !== before2.size || after2.size !== before2.size || before2.mtimeMs !== after2.mtimeMs || before2.ctimeMs !== after2.ctimeMs || path.dev !== before2.dev || path.ino !== before2.ino || !path.isFile() || path.isSymbolicLink())
         invalid6();
       this.assert();
       return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size2));
     } finally {
-      closeSync19(fd);
+      closeSync20(fd);
     }
   }
   write(name, value) {
     this.assert();
     const bytes = canonicalJson2(value, 8192) + `
 `;
-    const fd = openSync19(join53(this.directory, name), constants19.O_WRONLY | constants19.O_CREAT | constants19.O_EXCL | constants19.O_NOFOLLOW, 384);
+    const fd = openSync20(join53(this.directory, name), constants20.O_WRONLY | constants20.O_CREAT | constants20.O_EXCL | constants20.O_NOFOLLOW, 384);
     try {
       writeFileSync19(fd, bytes);
-      fsyncSync6(fd);
+      fsyncSync7(fd);
     } finally {
-      closeSync19(fd);
+      closeSync20(fd);
     }
     this.assert();
     this.sync();
   }
   sync() {
     this.assert();
-    const fd = openSync19(this.directory, constants19.O_RDONLY | constants19.O_NOFOLLOW);
+    const fd = openSync20(this.directory, constants20.O_RDONLY | constants20.O_NOFOLLOW);
     try {
-      fsyncSync6(fd);
+      fsyncSync7(fd);
     } finally {
-      closeSync19(fd);
+      closeSync20(fd);
     }
   }
   saveState(state, expected) {
@@ -107212,20 +107494,20 @@ class RecoveryOwner {
     this.assert();
     let fd;
     try {
-      fd = openSync19(join53(this.directory, "operation.lock"), constants19.O_WRONLY | constants19.O_CREAT | constants19.O_EXCL | constants19.O_NOFOLLOW, 384);
+      fd = openSync20(join53(this.directory, "operation.lock"), constants20.O_WRONLY | constants20.O_CREAT | constants20.O_EXCL | constants20.O_NOFOLLOW, 384);
     } catch {
       throw new RecurringCustomerError("RECURRING_RECOVERY_BUSY", "Recovery is locked. Confirm the original process has stopped before explicitly reconciling the retained lock; no request was retried.");
     }
-    const owner2 = fstatSync19(fd);
+    const owner2 = fstatSync20(fd);
     try {
       writeFileSync19(fd, JSON.stringify({ pid: process.pid }));
-      fsyncSync6(fd);
+      fsyncSync7(fd);
       this.sync();
       return await action();
     } finally {
-      closeSync19(fd);
+      closeSync20(fd);
       this.assert();
-      const now3 = lstatSync29(join53(this.directory, "operation.lock"));
+      const now3 = lstatSync30(join53(this.directory, "operation.lock"));
       if (owner2.dev !== now3.dev || owner2.ino !== now3.ino || !now3.isFile() || now3.isSymbolicLink())
         invalid6();
       unlinkSync8(join53(this.directory, "operation.lock"));
@@ -107261,7 +107543,7 @@ function base2(customer, organizationId) {
   };
 }
 function create3(directory, intent) {
-  if (!isAbsolute22(directory) || resolve24(directory) !== directory || realpathSync15(dirname27(directory)) !== dirname27(directory))
+  if (!isAbsolute23(directory) || resolve24(directory) !== directory || realpathSync16(dirname27(directory)) !== dirname27(directory))
     invalid6();
   mkdirSync19(directory, { mode: 448 });
   const owner2 = new RecoveryOwner(directory), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
@@ -107424,7 +107706,7 @@ var init_recurring_recovery = __esm(() => {
 });
 
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute23 } from "path";
+import { isAbsolute as isAbsolute24 } from "path";
 function recurringMcpSchema(action) {
   return action === "activate" ? recurringSurfaceSchemas.activate.extend({ code, confirm: exports_external.literal(true) }) : recurringSurfaceSchemas[action];
 }
@@ -107529,7 +107811,7 @@ var init_recurring_surface = __esm(() => {
   uuid12 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
   context = { userId: uuid12.optional(), membershipId: uuid12.optional() };
   page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-  directory = exports_external.string().max(4096).refine(isAbsolute23, "Use an absolute recovery directory");
+  directory = exports_external.string().max(4096).refine(isAbsolute24, "Use an absolute recovery directory");
   email4 = exports_external.string().trim().toLowerCase().email().max(254);
   code = exports_external.string().regex(/^\d{6}$/);
   recurringSurfaceSchemas = {
@@ -109646,7 +109928,7 @@ var init_resource_meta_tools = __esm(() => {
 });
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync31, readFileSync as readFileSync36, writeFileSync as writeFileSync20, mkdirSync as mkdirSync21 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync37, writeFileSync as writeFileSync20, mkdirSync as mkdirSync21 } from "fs";
 import { join as join56 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
   return join56(targetDir, ".skills", "schedules.json");
@@ -109655,7 +109937,7 @@ function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
   if (existsSync31(path)) {
     try {
-      return JSON.parse(readFileSync36(path, "utf-8"));
+      return JSON.parse(readFileSync37(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
@@ -109961,11 +110243,11 @@ var init_schedule_tools = __esm(() => {
 });
 
 // src/lib/native-storage.ts
-import { createHash as createHash32, createHmac as createHmac3 } from "crypto";
+import { createHash as createHash33, createHmac as createHmac3 } from "crypto";
 import {
   existsSync as existsSync32,
   mkdirSync as mkdirSync22,
-  readFileSync as readFileSync37,
+  readFileSync as readFileSync38,
   readdirSync as readdirSync20,
   statSync as statSync19,
   writeFileSync as writeFileSync21
@@ -110033,12 +110315,12 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const files = [];
   if (existsSync32(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync37(filePath);
+      const bytes = readFileSync38(filePath);
       const relativePath = toPosix(relative9(targetDir, filePath));
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash32("sha256").update(bytes).digest("hex"),
+        sha256: createHash33("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -110330,20 +110612,20 @@ var init_private_publication_customer = __esm(() => {
 });
 
 // src/lib/private-publication-recovery.ts
-import { constants as constants20, closeSync as closeSync20, fsyncSync as fsyncSync7, fstatSync as fstatSync20, lstatSync as lstatSync30, mkdirSync as mkdirSync23, openSync as openSync20, readSync as readSync16, realpathSync as realpathSync16, renameSync as renameSync13, unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname30, isAbsolute as isAbsolute24, join as join58, resolve as resolve25 } from "path";
+import { constants as constants21, closeSync as closeSync21, fsyncSync as fsyncSync8, fstatSync as fstatSync21, lstatSync as lstatSync31, mkdirSync as mkdirSync23, openSync as openSync21, readSync as readSync16, realpathSync as realpathSync17, renameSync as renameSync13, unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname30, isAbsolute as isAbsolute25, join as join58, resolve as resolve25 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
 function safeDirectory(directory2) {
-  if (!isAbsolute24(directory2) || directory2 !== resolve25(directory2) || realpathSync16(directory2) !== directory2)
+  if (!isAbsolute25(directory2) || directory2 !== resolve25(directory2) || realpathSync17(directory2) !== directory2)
     return fail5();
   for (let path = directory2;; path = dirname30(path)) {
-    const stat3 = lstatSync30(path);
+    const stat3 = lstatSync31(path);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
       return fail5();
     if (path === dirname30(path))
       break;
   }
-  const own2 = lstatSync30(directory2);
+  const own2 = lstatSync31(directory2);
   if ((own2.mode & 63) !== 0 || process.getuid && own2.uid !== process.getuid())
     return fail5();
   return { dev: own2.dev, ino: own2.ino };
@@ -110355,9 +110637,9 @@ function unchangedDirectory(directory2, identity6) {
 }
 function readOwned(directory2, name, max2) {
   const identity6 = safeDirectory(directory2), file2 = join58(directory2, name);
-  const fd = openSync20(file2, constants20.O_RDONLY | constants20.O_NOFOLLOW);
+  const fd = openSync21(file2, constants21.O_RDONLY | constants21.O_NOFOLLOW);
   try {
-    const stat3 = fstatSync20(fd);
+    const stat3 = fstatSync21(fd);
     if (!stat3.isFile() || stat3.nlink !== 1 || stat3.size > max2 || stat3.size < 1 || (stat3.mode & 63) !== 0 || process.getuid && stat3.uid !== process.getuid())
       return fail5();
     const buffer = Buffer.alloc(Math.min(max2, stat3.size) + 1);
@@ -110368,22 +110650,22 @@ function readOwned(directory2, name, max2) {
         break;
       length += count;
     }
-    const bytes = buffer.subarray(0, length), after2 = fstatSync20(fd);
+    const bytes = buffer.subarray(0, length), after2 = fstatSync21(fd);
     unchangedDirectory(directory2, identity6);
     if (bytes.length !== stat3.size || stat3.size !== after2.size || stat3.mtimeMs !== after2.mtimeMs || stat3.ctimeMs !== after2.ctimeMs)
       return fail5();
     return bytes;
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync20(join58(directory2, name), constants20.O_WRONLY | constants20.O_CREAT | constants20.O_EXCL | constants20.O_NOFOLLOW, 384);
+  const fd = openSync21(join58(directory2, name), constants21.O_WRONLY | constants21.O_CREAT | constants21.O_EXCL | constants21.O_NOFOLLOW, 384);
   try {
     writeFileSync22(fd, bytes);
-    fsyncSync7(fd);
+    fsyncSync8(fd);
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
   }
 }
 function save2(directory2, value) {
@@ -110392,11 +110674,11 @@ function save2(directory2, value) {
 `);
   unchangedDirectory(directory2, identity6);
   renameSync13(join58(directory2, temporary), join58(directory2, "receipt.json"));
-  const fd = openSync20(directory2, constants20.O_RDONLY | constants20.O_NOFOLLOW);
+  const fd = openSync21(directory2, constants21.O_RDONLY | constants21.O_NOFOLLOW);
   try {
-    fsyncSync7(fd);
+    fsyncSync8(fd);
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
   }
 }
 function bind2(client2, receipt) {
@@ -110407,20 +110689,20 @@ async function locked(directory2, action) {
   const identity6 = safeDirectory(directory2), file2 = join58(directory2, "operation.lock");
   let fd;
   try {
-    fd = openSync20(file2, constants20.O_WRONLY | constants20.O_CREAT | constants20.O_EXCL | constants20.O_NOFOLLOW, 384);
+    fd = openSync21(file2, constants21.O_WRONLY | constants21.O_CREAT | constants21.O_EXCL | constants21.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 = fstatSync20(fd);
+  const lock = fstatSync21(fd);
   try {
     writeFileSync22(fd, JSON.stringify({ pid: process.pid }) + `
 `);
-    fsyncSync7(fd);
+    fsyncSync8(fd);
     return await action();
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
     unchangedDirectory(directory2, identity6);
-    const now3 = lstatSync30(file2);
+    const now3 = lstatSync31(file2);
     if (now3.dev !== lock.dev || now3.ino !== lock.ino || !now3.isFile() || now3.isSymbolicLink())
       fail5();
     unlinkSync9(file2);
@@ -110472,15 +110754,15 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute24(recoveryDirectory) || resolve25(recoveryDirectory) !== recoveryDirectory || realpathSync16(dirname30(recoveryDirectory)) !== dirname30(recoveryDirectory))
+  if (!isAbsolute25(recoveryDirectory) || resolve25(recoveryDirectory) !== recoveryDirectory || realpathSync17(dirname30(recoveryDirectory)) !== dirname30(recoveryDirectory))
     return fail5();
   mkdirSync23(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync20(dirname30(recoveryDirectory), constants20.O_RDONLY | constants20.O_NOFOLLOW);
+  const parent = openSync21(dirname30(recoveryDirectory), constants21.O_RDONLY | constants21.O_NOFOLLOW);
   try {
-    fsyncSync7(parent);
+    fsyncSync8(parent);
   } finally {
-    closeSync20(parent);
+    closeSync21(parent);
   }
   writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
   save2(recoveryDirectory, receipt);
@@ -110573,10 +110855,10 @@ var init_private_publication_recovery = __esm(() => {
 });
 
 // src/mcp/private-publication-tools.ts
-import { isAbsolute as isAbsolute25 } from "path";
+import { isAbsolute as isAbsolute26 } from "path";
 function registerPrivatePublicationTools(server) {
   const uuid9 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
-  const directory2 = exports_external.string().max(4096).refine(isAbsolute25, "Use an absolute local directory");
+  const directory2 = exports_external.string().max(4096).refine(isAbsolute26, "Use an absolute local directory");
   const verification2 = { email: exports_external.string().email().max(254), code: exports_external.string().regex(/^\d{6}$/), userId: uuid9, membershipId: uuid9, recoveryDirectory: directory2 };
   const description = "Manage a private source publication using fresh workspace-bound verification and a host-local recovery directory. Publishing requires explicit UUID current-version comparison and upload consent. Resume reuses immutable saved bytes and intent; an uncertain PUT is finalized for server verification, never uploaded twice. Sessions and signed URLs are not returned or persisted. Private execution is unavailable. Host request history may contain the supplied verification code.";
   const handler = (action) => async (value) => {
@@ -110918,6 +111200,7 @@ async function startMcpStdio() {
 }
 var args;
 var init_mcp2 = __esm(() => {
+  init_launch_cwd_apply();
   init_stdio2();
   init_package();
   init_fleet_credentials();
@@ -110938,7 +111221,7 @@ var exports_runtime_mcp = {};
 __export(exports_runtime_mcp, {
   handleMcp: () => handleMcp
 });
-import { existsSync as existsSync33, mkdirSync as mkdirSync24, readFileSync as readFileSync38, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync24, readFileSync as readFileSync39, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir10 } from "os";
 import { dirname as dirname31, join as join59 } from "path";
 async function handleMcp(options) {
@@ -111049,7 +111332,7 @@ function registerCodexMcp(command) {
   const config2 = `[mcp_servers.${MCP_SERVER_NAME}]
 command = ${JSON.stringify(command)}`;
   try {
-    const current = existsSync33(path) ? readFileSync38(path, "utf-8") : "";
+    const current = existsSync33(path) ? readFileSync39(path, "utf-8") : "";
     writeTextFile(path, upsertTomlSection(current, `[mcp_servers.${MCP_SERVER_NAME}]`, `command = ${JSON.stringify(command)}`));
     return { agent: "codex", success: true, path, config: config2 };
   } catch (err) {
@@ -111101,7 +111384,7 @@ function registerJsonMcpServer(agent, path, containerKey, server2) {
 function readJsonObject2(path) {
   if (!existsSync33(path))
     return {};
-  const raw = readFileSync38(path, "utf-8").trim();
+  const raw = readFileSync39(path, "utf-8").trim();
   if (!raw)
     return {};
   const parsed = JSON.parse(raw);
@@ -111220,7 +111503,7 @@ var init_remote_account2 = __esm(() => {
 });
 
 // src/cli/commands/reviewed-runtime-lock.ts
-import { createHash as createHash33 } from "crypto";
+import { createHash as createHash34 } from "crypto";
 function row(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error("REVIEWED_LOCK_SHAPE_INVALID");
@@ -111271,10 +111554,10 @@ async function metadata(name, context2) {
     throw new Error("REVIEWED_LOCK_METADATA_INVALID");
   }
 }
-async function validateReviewedRuntimeLock(bytes, sha2562, context2) {
-  if (!/^[a-f0-9]{64}$/.test(sha2562))
+async function validateReviewedRuntimeLock(bytes, sha2563, context2) {
+  if (!/^[a-f0-9]{64}$/.test(sha2563))
     throw new Error("REVIEWED_LOCK_SHA256_INVALID");
-  if (bytes.byteLength > MAX_LOCK_BYTES || createHash33("sha256").update(bytes).digest("hex") !== sha2562)
+  if (bytes.byteLength > MAX_LOCK_BYTES || createHash34("sha256").update(bytes).digest("hex") !== sha2563)
     throw new Error("REVIEWED_LOCK_HASH_MISMATCH");
   if (!Number.isSafeInteger(context2.minReleaseAge) || context2.minReleaseAge < 1)
     throw new Error("REVIEWED_LOCK_RELEASE_AGE_REQUIRED");
@@ -111351,39 +111634,76 @@ var init_reviewed_runtime_lock = __esm(() => {
 });
 
 // src/cli/commands/runtime-copyfile.ts
-import { createHash as createHash34, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash35, randomUUID as randomUUID10 } from "crypto";
 import { Readable } from "stream";
 import { createGunzip as createGunzip2 } from "zlib";
 import {
   chmodSync as chmodSync4,
   copyFileSync,
   existsSync as existsSync34,
-  lstatSync as lstatSync31,
+  lstatSync as lstatSync32,
   mkdirSync as mkdirSync25,
-  readFileSync as readFileSync39,
+  readFileSync as readFileSync40,
   readdirSync as readdirSync21,
-  readlinkSync as readlinkSync6,
-  realpathSync as realpathSync17,
+  readlinkSync as readlinkSync7,
+  realpathSync as realpathSync18,
   renameSync as renameSync14,
-  symlinkSync,
   writeFileSync as writeFileSync24
 } from "fs";
-import { basename as basename15, delimiter as delimiter2, dirname as dirname32, isAbsolute as isAbsolute26, join as join60, relative as relative10, resolve as resolve26, sep as sep12 } from "path";
+import { basename as basename15, delimiter as delimiter2, dirname as dirname32, isAbsolute as isAbsolute27, join as join60, relative as relative10, resolve as resolve26, sep as sep12 } from "path";
+function oldLauncherState(item) {
+  if (item.oldShape === "pinned")
+    return { shape: "pinned", runtime: item.oldRuntime, cwd: item.oldCwd, target: item.oldTarget, sha256: item.oldSha256 };
+  return { shape: "symlink", linkTarget: item.oldLinkTarget, target: item.oldTarget };
+}
+function newLauncherState(item) {
+  if (item.newShape === "pinned")
+    return { shape: "pinned", runtime: item.newRuntime, cwd: item.newCwd, target: item.newTarget, sha256: item.newSha256 };
+  return { shape: "symlink", linkTarget: item.newTarget, target: item.newTarget };
+}
+function assertLauncherRecordShapes(item) {
+  const hex3 = /^[a-f0-9]{64}$/;
+  for (const side of ["old", "new"]) {
+    const shape = item[`${side}Shape`], runtime = item[`${side}Runtime`], cwd2 = item[`${side}Cwd`], sha6 = item[`${side}Sha256`];
+    if (shape === undefined) {
+      if (runtime !== undefined || cwd2 !== undefined || sha6 !== undefined)
+        throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
+      continue;
+    }
+    if (shape === "symlink") {
+      if (runtime !== undefined || cwd2 !== undefined || sha6 !== undefined)
+        throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
+      continue;
+    }
+    if (shape !== "pinned" || typeof runtime !== "string" || !isAbsolute27(runtime) || typeof cwd2 !== "string" || !isAbsolute27(cwd2) || typeof sha6 !== "string" || !hex3.test(sha6)) {
+      throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
+    }
+    const target = side === "old" ? item.oldTarget : item.newTarget;
+    if (side === "old" && item.oldLinkTarget !== item.oldTarget)
+      throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
+    if (pinnedLauncherState(runtime, cwd2, target).sha256 !== sha6)
+      throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
+  }
+}
+function pinnedRecordFields(runtime, cwd2, target) {
+  const state = pinnedLauncherState(runtime, cwd2, target);
+  return { newShape: "pinned", newRuntime: state.runtime, newCwd: state.cwd, newSha256: state.sha256 };
+}
 function object10(value, code2) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error(code2);
   return value;
 }
 function hash5(bytes) {
-  return createHash34("sha256").update(bytes).digest("hex");
+  return createHash35("sha256").update(bytes).digest("hex");
 }
 function isWithin(parent, child) {
   const rel = relative10(parent, child);
-  return rel === "" || !rel.startsWith(`..${sep12}`) && rel !== ".." && !isAbsolute26(rel);
+  return rel === "" || !rel.startsWith(`..${sep12}`) && rel !== ".." && !isAbsolute27(rel);
 }
 function entryExists(path) {
   try {
-    lstatSync31(path);
+    lstatSync32(path);
     return true;
   } catch {
     return false;
@@ -111395,7 +111715,7 @@ function assertNoSymlinkAncestors(path) {
   let current = sep12;
   for (const part of parts) {
     current = join60(current, part);
-    const stat3 = lstatSync31(current);
+    const stat3 = lstatSync32(current);
     if (stat3.isSymbolicLink())
       throw new Error("PATH_ANCESTOR_SYMLINK_UNSUPPORTED");
     if (!stat3.isDirectory())
@@ -111428,7 +111748,7 @@ function packageBins(pkg) {
   const entries = typeof raw === "string" ? [[PACKAGE_NAME.slice(PACKAGE_NAME.lastIndexOf("/") + 1), raw]] : raw && typeof raw === "object" && !Array.isArray(raw) ? Object.entries(raw) : [];
   const output2 = {};
   for (const [name, value] of entries) {
-    if (!/^[a-zA-Z0-9._-]+$/.test(name) || typeof value !== "string" || !value || isAbsolute26(value)) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(name) || typeof value !== "string" || !value || isAbsolute27(value)) {
       throw new Error("PACKAGE_BIN_INVALID");
     }
     const normalized = value.replaceAll("\\", "/");
@@ -111443,7 +111763,7 @@ function packageBins(pkg) {
 function readPackage(path) {
   let data;
   try {
-    data = object10(JSON.parse(readFileSync39(path, "utf8")), "PACKAGE_JSON_INVALID");
+    data = object10(JSON.parse(readFileSync40(path, "utf8")), "PACKAGE_JSON_INVALID");
   } catch {
     throw new Error("PACKAGE_JSON_INVALID");
   }
@@ -111453,10 +111773,10 @@ function readPackage(path) {
   return { data, version: data.version, bins: packageBins(data) };
 }
 function resolveRuntimeLayout(homeInput, pathInput) {
-  const home = realpathSync17(homeInput);
+  const home = realpathSync18(homeInput);
   const runtimeRoot = join60(home, ".hasna", "skills", "runtime");
   assertNoSymlinkAncestors(runtimeRoot);
-  const runtimeRootStat = lstatSync31(runtimeRoot);
+  const runtimeRootStat = lstatSync32(runtimeRoot);
   if (!runtimeRootStat.isDirectory() || runtimeRootStat.isSymbolicLink() || (runtimeRootStat.mode & 63) !== 0) {
     throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
   }
@@ -111465,10 +111785,18 @@ function resolveRuntimeLayout(homeInput, pathInput) {
     throw new Error("ACTIVE_SKILLS_LAUNCHER_NOT_FOUND");
   const launcherPath = resolve26(selectedLauncher);
   assertNoSymlinkAncestors(dirname32(launcherPath));
-  const launcherStat = lstatSync31(launcherPath);
-  if (!launcherStat.isSymbolicLink())
+  const activeLauncher = inspectLauncher(launcherPath);
+  if (activeLauncher.kind === "foreign")
     throw new Error("ACTIVE_SKILLS_LAUNCHER_NOT_MANAGED_LINK");
-  const activeBinary = realpathSync17(launcherPath);
+  const activeBinary = activeLauncher.target;
+  let activePhysical;
+  try {
+    activePhysical = realpathSync18(activeBinary);
+  } catch {
+    throw new Error("ACTIVE_RUNTIME_ENTRYPOINT_MISMATCH");
+  }
+  if (activePhysical !== activeBinary)
+    throw new Error("ACTIVE_RUNTIME_ENTRYPOINT_MISMATCH");
   const currentPackageRoot = dirname32(dirname32(activeBinary));
   assertNoSymlinkAncestors(currentPackageRoot);
   if (!isWithin(runtimeRoot, currentPackageRoot))
@@ -111493,27 +111821,28 @@ function resolveRuntimeLayout(homeInput, pathInput) {
       if (!existsSync34(path))
         continue;
       assertNoSymlinkAncestors(dir);
-      let stat3;
+      let launcher;
       try {
-        stat3 = lstatSync31(path);
-      } catch {
+        launcher = inspectLauncher(path);
+      } catch (error61) {
+        if (error61 instanceof Error && error61.message === "LAUNCHER_TARGET_UNREADABLE")
+          throw error61;
         continue;
       }
-      if (!stat3.isSymbolicLink())
+      if (launcher.kind === "foreign")
         continue;
-      let actual;
-      try {
-        actual = realpathSync17(path);
-      } catch {
-        throw new Error("LAUNCHER_TARGET_UNREADABLE");
-      }
+      const actual = launcher.target;
       if (actual !== join60(currentPackageRoot, target))
         continue;
-      const oldLinkTarget = readlinkSync6(path);
-      if (resolve26(dirname32(path), oldLinkTarget) !== actual)
-        throw new Error("LAUNCHER_SYMLINK_CHAIN_UNSUPPORTED");
       const newTarget = join60(runtimeRoot, "__target__", "node_modules", "@hasna", "skills", target);
-      launchers.push({ path, oldTarget: actual, oldLinkTarget, newTarget, backupPath: `${path}.skills-prev-${randomUUID10()}` });
+      const backupPath = `${path}.skills-prev-${randomUUID10()}`;
+      if (launcher.kind === "symlink") {
+        if (resolve26(dirname32(path), launcher.linkTarget) !== actual)
+          throw new Error("LAUNCHER_SYMLINK_CHAIN_UNSUPPORTED");
+        launchers.push({ path, oldTarget: actual, oldLinkTarget: launcher.linkTarget, newTarget, backupPath, oldShape: "symlink" });
+      } else {
+        launchers.push({ path, oldTarget: actual, oldLinkTarget: actual, newTarget, backupPath, oldShape: "pinned", oldRuntime: launcher.runtime, oldCwd: launcher.cwd, oldSha256: launcher.sha256 });
+      }
     }
   }
   if (!launchers.some((item) => item.path === launcherPath))
@@ -111526,7 +111855,7 @@ function verifyIntegrity(bytes, integrity) {
   const match = /^sha512-([A-Za-z0-9+/]+={0,2})$/.exec(integrity);
   if (!match)
     throw new Error("REGISTRY_INTEGRITY_UNSUPPORTED");
-  const actual = createHash34("sha512").update(bytes).digest("base64");
+  const actual = createHash35("sha512").update(bytes).digest("base64");
   if (actual !== match[1])
     throw new Error("TARBALL_INTEGRITY_MISMATCH");
 }
@@ -111671,7 +112000,7 @@ async function downloadPackage(version2, stagingRoot, registryOrigin, fetcher) {
   const extracted = readTree(extractedPackage, false);
   const tarballPath = join60(stagingRoot, "verified-package.tgz");
   writeFileSync24(tarballPath, bytes, { flag: "wx", mode: 384 });
-  if (!readFileSync39(tarballPath).equals(Buffer.from(bytes)))
+  if (!readFileSync40(tarballPath).equals(Buffer.from(bytes)))
     throw new Error("TARBALL_READBACK_MISMATCH");
   return {
     tarballPath,
@@ -111713,26 +112042,26 @@ async function readBodyCapped(response, limit, errorCode) {
   return bytes;
 }
 function readTree(root2, includeModes, excludeNpmDependencies = false) {
-  const base3 = realpathSync17(root2);
+  const base3 = realpathSync18(root2);
   const entries = [];
   const walk2 = (dir, prefix = "") => {
     for (const item of readdirSync21(dir).sort()) {
       const path = join60(dir, item);
       const rel = prefix ? `${prefix}/${item}` : item;
-      const stat3 = lstatSync31(path);
+      const stat3 = lstatSync32(path);
       if (excludeNpmDependencies && !prefix && item === "node_modules") {
         if (!stat3.isDirectory() || stat3.isSymbolicLink())
           throw new Error("INSTALLED_DEPENDENCY_DIRECTORY_UNSAFE");
         continue;
       }
       if (stat3.isSymbolicLink()) {
-        const link2 = readlinkSync6(path);
+        const link2 = readlinkSync7(path);
         const resolved = resolve26(dirname32(path), link2);
         if (!isWithin(base3, resolved))
           throw new Error("TREE_SYMLINK_ESCAPES_ROOT");
         let physicalTarget2;
         try {
-          physicalTarget2 = realpathSync17(path);
+          physicalTarget2 = realpathSync18(path);
         } catch {
           throw new Error("TREE_SYMLINK_TARGET_MISSING");
         }
@@ -111745,7 +112074,7 @@ function readTree(root2, includeModes, excludeNpmDependencies = false) {
       } else if (stat3.isFile()) {
         if (stat3.nlink !== 1)
           throw new Error("TREE_HARDLINK_UNSUPPORTED");
-        const bytes = readFileSync39(path);
+        const bytes = readFileSync40(path);
         entries.push({ path: rel, kind: "file", sha256: hash5(bytes), ...includeModes ? { mode: stat3.mode & 511 } : {} });
       } else
         throw new Error("TREE_ENTRY_TYPE_UNSUPPORTED");
@@ -111755,14 +112084,14 @@ function readTree(root2, includeModes, excludeNpmDependencies = false) {
   return { entries, digest: hash5(new TextEncoder().encode(JSON.stringify(entries))) };
 }
 function normalizeModes(root2) {
-  const rootStat = lstatSync31(root2);
+  const rootStat = lstatSync32(root2);
   if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
     throw new Error("RUNTIME_ENTRY_TYPE_UNSUPPORTED");
   chmodSync4(root2, rootStat.mode & 493);
   const walk2 = (dir) => {
     for (const item of readdirSync21(dir)) {
       const path = join60(dir, item);
-      const stat3 = lstatSync31(path);
+      const stat3 = lstatSync32(path);
       if (stat3.isSymbolicLink())
         continue;
       if (stat3.isDirectory()) {
@@ -111781,7 +112110,7 @@ function writeJsonPrivate(path, value) {
 `);
   writeFileSync24(path, bytes, { flag: "wx", mode: 384 });
   chmodSync4(path, 384);
-  if (!readFileSync39(path).equals(bytes))
+  if (!readFileSync40(path).equals(bytes))
     throw new Error("PRIVATE_JSON_READBACK_MISMATCH");
 }
 function writePreimageManifest(stage, configs, launchers) {
@@ -111791,13 +112120,13 @@ function writePreimageManifest(stage, configs, launchers) {
 `);
   writeFileSync24(path, bytes, { flag: "wx", mode: 256 });
   chmodSync4(path, 256);
-  if (!readFileSync39(path).equals(bytes))
+  if (!readFileSync40(path).equals(bytes))
     throw new Error("PREIMAGE_MANIFEST_READBACK_MISMATCH");
   return hash5(bytes);
 }
 function verifyPreimageManifest(runtimePath, receipt, home) {
   const path = join60(runtimePath, "preimage", "manifest.json");
-  const bytes = readFileSync39(path);
+  const bytes = readFileSync40(path);
   if (hash5(bytes) !== receipt.preimageSha256)
     throw new Error("PREIMAGE_MANIFEST_DRIFT");
   const manifest = object10(JSON.parse(bytes.toString("utf8")), "PREIMAGE_MANIFEST_INVALID");
@@ -111812,8 +112141,8 @@ function verifyPreimageManifest(runtimePath, receipt, home) {
       throw new Error("PREIMAGE_CONFIG_BINDING_INVALID");
     if (config2.present) {
       const backup = join60(runtimePath, "preimage", "configs", relativePath);
-      const stat3 = lstatSync31(backup);
-      const saved = readFileSync39(backup);
+      const stat3 = lstatSync32(backup);
+      const saved = readFileSync40(backup);
       if (!stat3.isFile() || stat3.isSymbolicLink() || hash5(saved) !== config2.sha256 || saved.byteLength !== config2.byteSize)
         throw new Error("PREIMAGE_CONFIG_DRIFT");
     }
@@ -111826,15 +112155,15 @@ function captureConfigPreimages(home, stage) {
     const sourcePath = join60(home, relativePath);
     if (!entryExists(sourcePath))
       return { sourcePath, relativePath, present: false };
-    const stat3 = lstatSync31(sourcePath);
+    const stat3 = lstatSync32(sourcePath);
     if (!stat3.isFile() || stat3.isSymbolicLink())
       throw new Error("CONFIG_PREIMAGE_NOT_REGULAR_FILE");
-    const bytes = readFileSync39(sourcePath);
+    const bytes = readFileSync40(sourcePath);
     const backupPath = join60(root2, relativePath);
     mkdirSync25(dirname32(backupPath), { recursive: true, mode: 448 });
     writeFileSync24(backupPath, bytes, { flag: "wx", mode: 384 });
     chmodSync4(backupPath, 384);
-    const readback = readFileSync39(backupPath);
+    const readback = readFileSync40(backupPath);
     if (!readback.equals(bytes))
       throw new Error("CONFIG_PREIMAGE_READBACK_MISMATCH");
     return { sourcePath, relativePath, present: true, sha256: hash5(bytes), byteSize: bytes.byteLength };
@@ -111846,8 +112175,8 @@ function assertConfigUnchanged(configs) {
     if (present !== config2.present)
       throw new Error("CONFIG_DRIFT_DURING_UPDATE");
     if (present) {
-      const stat3 = lstatSync31(config2.sourcePath);
-      if (!stat3.isFile() || stat3.isSymbolicLink() || hash5(readFileSync39(config2.sourcePath)) !== config2.sha256) {
+      const stat3 = lstatSync32(config2.sourcePath);
+      if (!stat3.isFile() || stat3.isSymbolicLink() || hash5(readFileSync40(config2.sourcePath)) !== config2.sha256) {
         throw new Error("CONFIG_DRIFT_DURING_UPDATE");
       }
     }
@@ -111910,7 +112239,7 @@ ignore-scripts=true
   const capabilityNpmrc = join60(staging, "npm-capability.npmrc");
   if (policy && !existsSync34(capabilityNpmrc))
     writeFileSync24(capabilityNpmrc, baseConfig, { mode: 384, flag: "wx" });
-  if (policy && readFileSync39(capabilityNpmrc, "utf8") !== baseConfig)
+  if (policy && readFileSync40(capabilityNpmrc, "utf8") !== baseConfig)
     throw new Error("NPM_ISOLATED_CONFIG_DRIFT");
   const npmVersion = policy ? await npmReleaseAgeCapability(cwd2, { ...env3, NPM_CONFIG_USERCONFIG: capabilityNpmrc }) : undefined;
   const config2 = baseConfig + (policy ? `min-release-age=${policy.minReleaseAge}
@@ -111918,7 +112247,7 @@ ${policy.minReleaseAgeExclude.map((pattern) => `min-release-age-exclude[]=${patt
 `).join("")}` : "");
   if (!existsSync34(userNpmrc))
     writeFileSync24(userNpmrc, config2, { mode: 384, flag: "wx" });
-  if (readFileSync39(userNpmrc, "utf8") !== config2 || readFileSync39(globalNpmrc, "utf8") !== baseConfig)
+  if (readFileSync40(userNpmrc, "utf8") !== config2 || readFileSync40(globalNpmrc, "utf8") !== baseConfig)
     throw new Error("NPM_ISOLATED_CONFIG_DRIFT");
   const proc = Bun.spawn(["npm", ...args2, "--registry", `${REGISTRY_ORIGIN}/`, "--ignore-scripts", "--no-audit", "--no-fund"], {
     cwd: cwd2,
@@ -111941,18 +112270,26 @@ function comparePackageTrees(expectedRoot, installedRoot) {
     throw new Error("INSTALLED_PACKAGE_BYTES_MISMATCH");
   return expected.digest;
 }
-function replaceLink(path, target, backupPath, oldLinkTarget, oldTarget = resolve26(dirname32(path), oldLinkTarget)) {
-  const stat3 = lstatSync31(path);
-  if (!stat3.isSymbolicLink() || entryExists(backupPath))
+function replaceLauncher(item) {
+  const oldState = oldLauncherState(item), newState = newLauncherState(item);
+  if (!launcherIs(item.path, oldState) || entryExists(item.backupPath))
     throw new Error("LAUNCHER_PREIMAGE_DRIFT");
-  const temp = `${path}.skills-next-${randomUUID10()}`;
-  symlinkSync(oldLinkTarget, backupPath);
-  if (readlinkSync6(backupPath) !== oldLinkTarget || realpathSync17(backupPath) !== oldTarget)
+  const temp = `${item.path}.skills-next-${randomUUID10()}`;
+  try {
+    materializeLauncher(item.backupPath, oldState);
+  } catch {
     throw new Error("LAUNCHER_BACKUP_READBACK_MISMATCH");
-  symlinkSync(target, temp);
-  if (realpathSync17(temp) !== target)
+  }
+  if (!launcherIs(item.backupPath, oldState))
+    throw new Error("LAUNCHER_BACKUP_READBACK_MISMATCH");
+  try {
+    materializeLauncher(temp, newState);
+  } catch {
     throw new Error("LAUNCHER_NEW_LINK_READBACK_MISMATCH");
-  renameSync14(temp, path);
+  }
+  if (!launcherIs(temp, newState))
+    throw new Error("LAUNCHER_NEW_LINK_READBACK_MISMATCH");
+  renameSync14(temp, item.path);
 }
 function atomicJson(path, value) {
   const temp = `${path}.next-${randomUUID10()}`;
@@ -111961,12 +112298,12 @@ function atomicJson(path, value) {
   writeFileSync24(temp, bytes, { flag: "wx", mode: 384 });
   chmodSync4(temp, 384);
   renameSync14(temp, path);
-  if (!readFileSync39(path).equals(bytes))
+  if (!readFileSync40(path).equals(bytes))
     throw new Error("RECEIPT_READBACK_MISMATCH");
 }
 function persistReceipt(path, value) {
   if (entryExists(path)) {
-    const priorBytes = readFileSync39(path);
+    const priorBytes = readFileSync40(path);
     const prior = object10(JSON.parse(priorBytes.toString("utf8")), "RECEIPT_INVALID");
     if (prior.id !== value.id || prior.schema !== "skills.copyfile-runtime-receipt.v1" || typeof prior.state !== "string" || !/^[a-z-]{1,32}$/.test(prior.state))
       throw new Error("RECEIPT_ID_DRIFT");
@@ -111977,20 +112314,20 @@ function persistReceipt(path, value) {
     const historyRoot = join60(dirname32(path), "receipt-history");
     if (!entryExists(historyRoot))
       mkdirSync25(historyRoot, { mode: 448 });
-    const historyStat = lstatSync31(historyRoot);
+    const historyStat = lstatSync32(historyRoot);
     if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
       throw new Error("RECEIPT_HISTORY_NOT_PRIVATE");
     const historyPath = join60(historyRoot, `${value.id}-${String(prior.state)}-${randomUUID10()}.json`);
     writeFileSync24(historyPath, priorBytes, { flag: "wx", mode: 256 });
     chmodSync4(historyPath, 256);
-    if (!readFileSync39(historyPath).equals(priorBytes))
+    if (!readFileSync40(historyPath).equals(priorBytes))
       throw new Error("RECEIPT_HISTORY_READBACK_MISMATCH");
   }
   atomicJson(path, value);
 }
 function persistAliasReceipt(path, value) {
   if (entryExists(path)) {
-    const priorBytes = readFileSync39(path);
+    const priorBytes = readFileSync40(path);
     const prior = object10(JSON.parse(priorBytes.toString("utf8")), "ALIAS_RECEIPT_INVALID");
     if (prior.schema !== value.schema || prior.id !== value.id || typeof prior.state !== "string")
       throw new Error("ALIAS_RECEIPT_DRIFT");
@@ -112001,13 +112338,13 @@ function persistAliasReceipt(path, value) {
     const history = join60(dirname32(path), "history");
     if (!entryExists(history))
       mkdirSync25(history, { mode: 448 });
-    const historyStat = lstatSync31(history);
+    const historyStat = lstatSync32(history);
     if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
       throw new Error("ALIAS_RECEIPT_HISTORY_UNSAFE");
     const saved = join60(history, `${value.id}-${String(prior.state)}-${randomUUID10()}.json`);
     writeFileSync24(saved, priorBytes, { flag: "wx", mode: 256 });
     chmodSync4(saved, 256);
-    if (!readFileSync39(saved).equals(priorBytes))
+    if (!readFileSync40(saved).equals(priorBytes))
       throw new Error("ALIAS_RECEIPT_HISTORY_READBACK_MISMATCH");
   }
   atomicJson(path, value);
@@ -112015,7 +112352,7 @@ function persistAliasReceipt(path, value) {
 function assertOwnedSafePath(path, home, requireWritable = false) {
   assertNoSymlinkAncestors(path);
   for (let current = path;; current = dirname32(current)) {
-    const stat3 = lstatSync31(current);
+    const stat3 = lstatSync32(current);
     if (!stat3.isDirectory() || ![0, process.getuid?.() ?? -1].includes(stat3.uid) || stat3.mode & 18)
       throw new Error("ALIAS_PATH_UNSAFE");
     if (current === path && requireWritable && (stat3.uid !== (process.getuid?.() ?? -1) || (stat3.mode & 128) === 0))
@@ -112028,8 +112365,8 @@ function activeAliasRuntime(home, pathValue) {
   const layout = resolveRuntimeLayout(home, pathValue);
   const runtimePath = dirname32(dirname32(dirname32(layout.currentPackageRoot)));
   const receiptPath = join60(runtimePath, "rollout-receipt.json");
-  const rollout = object10(JSON.parse(readFileSync39(receiptPath, "utf8")), "ROLLOUT_RECEIPT_INVALID");
-  if (rollout.schema !== "skills.copyfile-runtime-receipt.v1" || rollout.state !== "switched" || rollout.targetPackageRoot !== layout.currentPackageRoot || rollout.targetVersion !== layout.currentVersion || rollout.runtimeRoot !== layout.runtimeRoot || rollout.package !== PACKAGE_NAME || hash5(readFileSync39(join60(runtimePath, "verified-package.tgz"))) !== rollout.tarballSha256 || readTree(join60(runtimePath, "node_modules"), true).digest !== rollout.runtimeTreeSha256) {
+  const rollout = object10(JSON.parse(readFileSync40(receiptPath, "utf8")), "ROLLOUT_RECEIPT_INVALID");
+  if (rollout.schema !== "skills.copyfile-runtime-receipt.v1" || rollout.state !== "switched" || rollout.targetPackageRoot !== layout.currentPackageRoot || rollout.targetVersion !== layout.currentVersion || rollout.runtimeRoot !== layout.runtimeRoot || rollout.package !== PACKAGE_NAME || hash5(readFileSync40(join60(runtimePath, "verified-package.tgz"))) !== rollout.tarballSha256 || readTree(join60(runtimePath, "node_modules"), true).digest !== rollout.runtimeTreeSha256) {
     throw new Error("ACTIVE_RUNTIME_RECEIPT_DRIFT");
   }
   verifyPreimageManifest(runtimePath, rollout, home);
@@ -112063,9 +112400,9 @@ function inspectAliasPackageChain(home, aliasPath, oldLinkTarget, oldTarget, bin
   assertOwnedSafePath(dirname32(packageLinkPath), home);
   let stat3, packageLinkTarget, resolved;
   try {
-    stat3 = lstatSync31(packageLinkPath);
-    packageLinkTarget = readlinkSync6(packageLinkPath);
-    resolved = realpathSync17(packageLinkPath);
+    stat3 = lstatSync32(packageLinkPath);
+    packageLinkTarget = readlinkSync7(packageLinkPath);
+    resolved = realpathSync18(packageLinkPath);
   } catch {
     throw new Error("ALIAS_LINK_CHAIN_UNSUPPORTED");
   }
@@ -112086,22 +112423,24 @@ function validateAliasSource(home, name, actual) {
   }
   assertOwnedSafePath(packageRoot, home);
   const manifestPath = join60(packageRoot, "package.json");
-  const manifestStat = lstatSync31(manifestPath), binaryStat = lstatSync31(actual);
+  const manifestStat = lstatSync32(manifestPath), binaryStat = lstatSync32(actual);
   if (!manifestStat.isFile() || manifestStat.isSymbolicLink() || !binaryStat.isFile() || binaryStat.isSymbolicLink() || ![0, process.getuid?.() ?? -1].includes(manifestStat.uid) || ![0, process.getuid?.() ?? -1].includes(binaryStat.uid) || manifestStat.mode & 18)
     throw new Error("ALIAS_SOURCE_UNSAFE");
   const pkg = readPackage(manifestPath);
   if (!pkg.bins[name] || actual !== join60(packageRoot, pkg.bins[name]))
     throw new Error("ALIAS_SOURCE_BIN_MISMATCH");
-  return { version: pkg.version, packageRoot, binarySha256: hash5(readFileSync39(actual)) };
+  return { version: pkg.version, packageRoot, binarySha256: hash5(readFileSync40(actual)) };
 }
 function adoptCopyfileAliases(options = {}) {
-  const home = realpathSync17(resolve26(options.homeDir ?? process.env.HOME ?? ""));
+  const home = realpathSync18(resolve26(options.homeDir ?? process.env.HOME ?? ""));
   const pathValue = options.pathValue ?? process.env.PATH ?? "";
   const { layout, rollout } = activeAliasRuntime(home, pathValue);
+  const currentRuntime = dirname32(dirname32(dirname32(layout.currentPackageRoot)));
+  const launcherRuntime = pinnedLauncherRuntime();
+  pinnedLauncherState(launcherRuntime, currentRuntime, join60(layout.currentPackageRoot, layout.bin.skills ?? "bin/index.js"));
   const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
   const id2 = randomUUID10();
   const aliases = [];
-  const currentRuntime = dirname32(dirname32(dirname32(layout.currentPackageRoot)));
   const receiptDir = join60(currentRuntime, "alias-adoptions");
   const receiptPath = join60(receiptDir, `${id2}.json`);
   let receipt;
@@ -112117,16 +112456,19 @@ function adoptCopyfileAliases(options = {}) {
         if (!entryExists(path))
           continue;
         assertOwnedSafePath(dir, home, true);
-        const stat3 = lstatSync31(path);
-        if (!stat3.isSymbolicLink() || stat3.uid !== (process.getuid?.() ?? -1))
+        const stat3 = lstatSync32(path);
+        if (stat3.uid !== (process.getuid?.() ?? -1))
           throw new Error("ALIAS_LINK_NOT_OWNED");
-        const oldLinkTarget = readlinkSync6(path);
-        let actual;
+        let launcher;
         try {
-          actual = realpathSync17(path);
+          launcher = inspectLauncher(path);
         } catch {
           throw new Error("ALIAS_LINK_CHAIN_UNSUPPORTED");
         }
+        if (launcher.kind === "foreign")
+          throw new Error("ALIAS_LINK_NOT_OWNED");
+        const actual = launcher.target;
+        const oldLinkTarget = launcher.kind === "symlink" ? launcher.linkTarget : actual;
         const newTarget = join60(layout.currentPackageRoot, target);
         if (actual === newTarget)
           continue;
@@ -112135,13 +112477,25 @@ function adoptCopyfileAliases(options = {}) {
         const backupPath = `${path}.skills-alias-prev-${id2}`;
         if (entryExists(backupPath))
           throw new Error("ALIAS_BACKUP_COLLISION");
-        aliases.push({ path, oldTarget: actual, oldLinkTarget, oldVersion: source.version, oldBinarySha256: source.binarySha256, newTarget, backupPath, ...chain ? { chain } : {} });
+        const oldFields = launcher.kind === "symlink" ? { oldShape: "symlink" } : { oldShape: "pinned", oldRuntime: launcher.runtime, oldCwd: launcher.cwd, oldSha256: launcher.sha256 };
+        aliases.push({
+          path,
+          oldTarget: actual,
+          oldLinkTarget,
+          oldVersion: source.version,
+          oldBinarySha256: source.binarySha256,
+          newTarget,
+          backupPath,
+          ...oldFields,
+          ...pinnedRecordFields(launcherRuntime, currentRuntime, newTarget),
+          ...chain ? { chain } : {}
+        });
       }
     }
     if (!aliases.length)
       return { adopted: true, version: layout.currentVersion, aliasCount: 0 };
     mkdirSync25(receiptDir, { recursive: true, mode: 448 });
-    const receiptDirStat = lstatSync31(receiptDir);
+    const receiptDirStat = lstatSync32(receiptDir);
     if (!receiptDirStat.isDirectory() || receiptDirStat.isSymbolicLink() || receiptDirStat.mode & 63)
       throw new Error("ALIAS_RECEIPT_DIRECTORY_UNSAFE");
     receipt = {
@@ -112157,7 +112511,7 @@ function adoptCopyfileAliases(options = {}) {
     };
     writeJsonPrivate(receiptPath, receipt);
     for (const item of aliases) {
-      if (readlinkSync6(item.path) !== item.oldLinkTarget || realpathSync17(item.path) !== item.oldTarget)
+      if (!launcherIs(item.path, oldLauncherState(item)))
         throw new Error("ALIAS_CHANGED_BEFORE_SWITCH");
       inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename15(item.path)], item.chain, true);
       const source = validateAliasSource(home, basename15(item.path), item.oldTarget);
@@ -112166,15 +112520,15 @@ function adoptCopyfileAliases(options = {}) {
       receipt.state = "switching";
       receipt.switchedAliases = [...receipt.switchedAliases, item.path];
       persistAliasReceipt(receiptPath, receipt);
-      replaceLink(item.path, item.newTarget, item.backupPath, item.oldLinkTarget, item.oldTarget);
-      if (realpathSync17(item.path) !== item.newTarget || realpathSync17(item.backupPath) !== item.oldTarget)
+      replaceLauncher(item);
+      if (!launcherIs(item.path, newLauncherState(item)) || !launcherIs(item.backupPath, oldLauncherState(item)))
         throw new Error("ALIAS_SWITCH_READBACK_MISMATCH");
       inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename15(item.path)], item.chain, true);
       options.onAliasSwitched?.(item.path);
     }
     for (const item of aliases) {
       inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename15(item.path)], item.chain, true);
-      if (readlinkSync6(item.backupPath) !== item.oldLinkTarget || realpathSync17(item.backupPath) !== item.oldTarget)
+      if (!launcherIs(item.backupPath, oldLauncherState(item)))
         throw new Error("ALIAS_BACKUP_DRIFT");
     }
     receipt.state = "switched";
@@ -112188,28 +112542,28 @@ function adoptCopyfileAliases(options = {}) {
           if (!entryExists(item.backupPath)) {
             inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename15(item.path)], item.chain, true);
             const source2 = validateAliasSource(home, basename15(item.path), item.oldTarget);
-            if (!entryExists(item.path) || readlinkSync6(item.path) !== item.oldLinkTarget || realpathSync17(item.path) !== item.oldTarget || source2.version !== item.oldVersion || source2.binarySha256 !== item.oldBinarySha256)
+            if (!entryExists(item.path) || !launcherIs(item.path, oldLauncherState(item)) || source2.version !== item.oldVersion || source2.binarySha256 !== item.oldBinarySha256)
               failed = true;
             continue;
           }
-          if (readlinkSync6(item.backupPath) !== item.oldLinkTarget || realpathSync17(item.backupPath) !== item.oldTarget)
+          if (!launcherIs(item.backupPath, oldLauncherState(item)))
             throw new Error("ALIAS_BACKUP_DRIFT");
           inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename15(item.path)], item.chain, true);
           const source = validateAliasSource(home, basename15(item.path), item.oldTarget);
           if (source.version !== item.oldVersion || source.binarySha256 !== item.oldBinarySha256)
             throw new Error("ALIAS_SOURCE_DRIFT");
-          if (realpathSync17(item.path) === item.oldTarget && readlinkSync6(item.path) === item.oldLinkTarget)
+          if (launcherIs(item.path, oldLauncherState(item)))
             continue;
-          if (realpathSync17(item.path) !== item.newTarget)
+          if (launcherTarget(item.path) !== item.newTarget)
             throw new Error("ALIAS_CHANGED_DURING_ROLLBACK");
           const after2 = `${item.path}.skills-alias-after-${id2}`;
           if (entryExists(after2))
             throw new Error("ALIAS_AFTER_COLLISION");
-          symlinkSync(item.newTarget, after2);
+          materializeLauncher(after2, newLauncherState(item));
           const temp = `${item.path}.skills-alias-rollback-${randomUUID10()}`;
-          symlinkSync(item.oldLinkTarget, temp);
+          materializeLauncher(temp, oldLauncherState(item));
           renameSync14(temp, item.path);
-          if (readlinkSync6(item.path) !== item.oldLinkTarget)
+          if (!launcherIs(item.path, oldLauncherState(item)))
             throw new Error("ALIAS_ROLLBACK_READBACK_MISMATCH");
           receipt.rollbackCompletedAliases = [...receipt.rollbackCompletedAliases, item.path];
           persistAliasReceipt(receiptPath, receipt);
@@ -112233,7 +112587,7 @@ function adoptCopyfileAliases(options = {}) {
 function rollbackCopyfileAliases(receiptId, options = {}) {
   if (!/^[0-9a-f-]{36}$/.test(receiptId))
     throw new Error("ALIAS_RECEIPT_ID_INVALID");
-  const home = realpathSync17(resolve26(options.homeDir ?? process.env.HOME ?? ""));
+  const home = realpathSync18(resolve26(options.homeDir ?? process.env.HOME ?? ""));
   const pathValue = options.pathValue ?? process.env.PATH ?? "";
   const { layout, rollout } = activeAliasRuntime(home, pathValue);
   const runtimePath = dirname32(dirname32(dirname32(layout.currentPackageRoot)));
@@ -112243,7 +112597,7 @@ function rollbackCopyfileAliases(receiptId, options = {}) {
     const locked2 = activeAliasRuntime(home, pathValue);
     if (locked2.layout.currentPackageRoot !== layout.currentPackageRoot || locked2.rollout.id !== rollout.id)
       throw new Error("ACTIVE_RUNTIME_CHANGED_BEFORE_ALIAS_ROLLBACK");
-    const receipt = object10(JSON.parse(readFileSync39(receiptPath, "utf8")), "ALIAS_RECEIPT_INVALID");
+    const receipt = object10(JSON.parse(readFileSync40(receiptPath, "utf8")), "ALIAS_RECEIPT_INVALID");
     if (receipt.schema !== "skills.copyfile-alias-adoption.v1" || receipt.id !== receiptId || !["switched", "switching", "rollback-required"].includes(receipt.state) || receipt.targetPackageRoot !== layout.currentPackageRoot || receipt.targetVersion !== layout.currentVersion || receipt.rolloutReceiptId !== rollout.id || !Array.isArray(receipt.aliases))
       throw new Error("ALIAS_RECEIPT_BINDING_INVALID");
     const seen = new Set;
@@ -112253,20 +112607,25 @@ function rollbackCopyfileAliases(receiptId, options = {}) {
         throw new Error("ALIAS_RECEIPT_LAUNCHER_INVALID");
       }
       inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, target, item.chain, true);
+      assertLauncherRecordShapes(item);
       seen.add(item.path);
       assertOwnedSafePath(dirname32(item.path), home, true);
       const source = validateAliasSource(home, name, item.oldTarget);
       if (source.version !== item.oldVersion || source.binarySha256 !== item.oldBinarySha256)
         throw new Error("ALIAS_PREIMAGE_DRIFT");
-      const stat3 = lstatSync31(item.path);
-      if (!stat3.isSymbolicLink() || stat3.uid !== (process.getuid?.() ?? -1))
+      const stat3 = lstatSync32(item.path);
+      if (stat3.uid !== (process.getuid?.() ?? -1))
         throw new Error("ALIAS_LINK_DRIFT");
-      const current = realpathSync17(item.path);
-      if (current !== item.newTarget && (current !== item.oldTarget || readlinkSync6(item.path) !== item.oldLinkTarget))
+      let current;
+      try {
+        current = launcherTarget(item.path);
+      } catch {
+        throw new Error("ALIAS_LINK_DRIFT");
+      }
+      if (!launcherIs(item.path, newLauncherState(item)) && !launcherIs(item.path, oldLauncherState(item)))
         throw new Error("ALIAS_TARGET_DRIFT");
       if (entryExists(item.backupPath)) {
-        const backup = lstatSync31(item.backupPath);
-        if (!backup.isSymbolicLink() || readlinkSync6(item.backupPath) !== item.oldLinkTarget || realpathSync17(item.backupPath) !== item.oldTarget)
+        if (!launcherIs(item.backupPath, oldLauncherState(item)))
           throw new Error("ALIAS_PREIMAGE_DRIFT");
       } else if (current !== item.oldTarget) {
         throw new Error("ALIAS_BACKUP_MISSING_FOR_SWITCH");
@@ -112274,23 +112633,25 @@ function rollbackCopyfileAliases(receiptId, options = {}) {
     }
     let restored = 0;
     for (const item of [...receipt.aliases].reverse()) {
-      if (realpathSync17(item.path) === item.oldTarget && readlinkSync6(item.path) === item.oldLinkTarget)
+      if (launcherIs(item.path, oldLauncherState(item)))
         continue;
       receipt.state = "rollback-required";
       persistAliasReceipt(receiptPath, receipt);
       const after2 = `${item.path}.skills-alias-after-${receiptId}`;
       if (!entryExists(after2)) {
-        symlinkSync(item.newTarget, after2);
-        if (realpathSync17(after2) !== item.newTarget)
+        try {
+          materializeLauncher(after2, newLauncherState(item));
+        } catch {
           throw new Error("ALIAS_AFTER_READBACK_MISMATCH");
-      } else if (realpathSync17(after2) !== item.newTarget)
+        }
+      } else if (!launcherIs(after2, newLauncherState(item)))
         throw new Error("ALIAS_AFTER_DRIFT");
-      if (realpathSync17(item.path) !== item.newTarget)
+      if (launcherTarget(item.path) !== item.newTarget)
         throw new Error("ALIAS_TARGET_DRIFT");
       const temp = `${item.path}.skills-alias-rollback-${randomUUID10()}`;
-      symlinkSync(item.oldLinkTarget, temp);
+      materializeLauncher(temp, oldLauncherState(item));
       renameSync14(temp, item.path);
-      if (readlinkSync6(item.path) !== item.oldLinkTarget || realpathSync17(item.path) !== item.oldTarget)
+      if (!launcherIs(item.path, oldLauncherState(item)))
         throw new Error("ALIAS_ROLLBACK_READBACK_MISMATCH");
       receipt.rollbackCompletedAliases = [...new Set([...receipt.rollbackCompletedAliases, item.path])];
       persistAliasReceipt(receiptPath, receipt);
@@ -112318,13 +112679,13 @@ async function updateCopyfileRuntime(version2, options = {}) {
       throw new Error("REVIEWED_LOCK_INPUT_PAIR_REQUIRED");
     if (!policy)
       throw new Error("REVIEWED_LOCK_RELEASE_AGE_REQUIRED");
-    if (!isAbsolute26(options.reviewedLock))
+    if (!isAbsolute27(options.reviewedLock))
       throw new Error("REVIEWED_LOCK_ABSOLUTE_PATH_REQUIRED");
     assertNoSymlinkAncestors(dirname32(options.reviewedLock));
-    const stat3 = lstatSync31(options.reviewedLock);
+    const stat3 = lstatSync32(options.reviewedLock);
     if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.nlink !== 1 || stat3.uid !== process.getuid?.() || stat3.mode & 63 || stat3.size > 8 * 1024 * 1024)
       throw new Error("REVIEWED_LOCK_FILE_UNSAFE");
-    reviewedLockBytes = readFileSync39(options.reviewedLock);
+    reviewedLockBytes = readFileSync40(options.reviewedLock);
     if (!/^[a-f0-9]{64}$/.test(options.reviewedLockSha256))
       throw new Error("REVIEWED_LOCK_SHA256_INVALID");
     if (hash5(reviewedLockBytes) !== options.reviewedLockSha256)
@@ -112342,14 +112703,18 @@ async function updateCopyfileRuntime(version2, options = {}) {
     throw new Error("REGISTRY_ORIGIN_INVALID");
   if (origin.username || origin.password || origin.search || origin.hash)
     throw new Error("REGISTRY_ORIGIN_INVALID");
-  const runtimeRootStat = lstatSync31(layout.runtimeRoot);
+  const runtimeRootStat = lstatSync32(layout.runtimeRoot);
   if ((runtimeRootStat.mode & 63) !== 0)
     throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
   const id2 = randomUUID10();
-  const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
   const stagePath = join60(layout.runtimeRoot, `.stage-${version2}-${id2}`);
   const finalPath = join60(layout.runtimeRoot, `${version2}-copyfile`);
-  const launchers = layout.launchers.map((item) => ({ ...item, newTarget: join60(finalPath, "node_modules", "@hasna", "skills", layout.bin[basename15(item.path)]) }));
+  const launcherRuntime = pinnedLauncherRuntime();
+  const launchers = layout.launchers.map((item) => {
+    const newTarget = join60(finalPath, "node_modules", "@hasna", "skills", layout.bin[basename15(item.path)]);
+    return { ...item, newTarget, ...pinnedRecordFields(launcherRuntime, finalPath, newTarget) };
+  });
+  const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
   let switched = [];
   let moved = false;
   try {
@@ -112372,13 +112737,13 @@ async function updateCopyfileRuntime(version2, options = {}) {
       await validateReviewedRuntimeLock(reviewedLockBytes, options.reviewedLockSha256, {
         version: version2,
         archiveIntegrity: artifact.integrity,
-        packageManifest: object10(JSON.parse(readFileSync39(join60(stagePath, "verified-archive", "package", "package.json"), "utf8")), "PACKAGE_MANIFEST_INVALID"),
+        packageManifest: object10(JSON.parse(readFileSync40(join60(stagePath, "verified-archive", "package", "package.json"), "utf8")), "PACKAGE_MANIFEST_INVALID"),
         registryOrigin: REGISTRY_ORIGIN,
         ...policy,
         fetcher
       });
       writeFileSync24(join60(stagePackage, "package-lock.json"), reviewedLockBytes, { mode: 384, flag: "wx" });
-      if (!readFileSync39(join60(stagePackage, "package-lock.json")).equals(reviewedLockBytes))
+      if (!readFileSync40(join60(stagePackage, "package-lock.json")).equals(reviewedLockBytes))
         throw new Error("REVIEWED_LOCK_COPY_MISMATCH");
     } else {
       npmVersion = await runNpm(["install", "--package-lock-only", "--prefix", stagePackage], stagePackage, home, stagePath, policy);
@@ -112387,14 +112752,14 @@ async function updateCopyfileRuntime(version2, options = {}) {
     if (!reviewedLockBytes && npmVersion !== ciNpmVersion)
       throw new Error("NPM_VERSION_DRIFT_DURING_UPDATE");
     npmVersion = ciNpmVersion;
-    const lockBytes = readFileSync39(join60(stagePackage, "package-lock.json"));
+    const lockBytes = readFileSync40(join60(stagePackage, "package-lock.json"));
     if (reviewedLockBytes) {
       if (!lockBytes.equals(reviewedLockBytes))
         throw new Error("REVIEWED_LOCK_DRIFT_DURING_INSTALL");
       const treeNpmVersion = await runNpm(["sbom", "--sbom-format=cyclonedx", "--package-lock-only=false", "--omit=dev", "--prefix", stagePackage], stagePackage, home, stagePath, policy);
       if (treeNpmVersion !== npmVersion)
         throw new Error("NPM_VERSION_DRIFT_DURING_UPDATE");
-      if (!readFileSync39(join60(stagePackage, "package-lock.json")).equals(reviewedLockBytes))
+      if (!readFileSync40(join60(stagePackage, "package-lock.json")).equals(reviewedLockBytes))
         throw new Error("REVIEWED_LOCK_DRIFT_DURING_INSTALL");
     }
     const installedPackage = join60(stagePackage, "node_modules", "@hasna", "skills");
@@ -112458,17 +112823,17 @@ async function updateCopyfileRuntime(version2, options = {}) {
     moved = true;
     const finalReceiptBytes = Buffer.from(`${JSON.stringify(receipt, null, 2)}
 `);
-    if (!readFileSync39(join60(finalPath, "rollout-receipt.json")).equals(finalReceiptBytes))
+    if (!readFileSync40(join60(finalPath, "rollout-receipt.json")).equals(finalReceiptBytes))
       throw new Error("RECEIPT_MOVE_READBACK_MISMATCH");
     assertConfigUnchanged(configPreimages);
     for (const item of launchers) {
-      if (realpathSync17(item.path) !== item.oldTarget)
+      if (launcherTarget(item.path) !== item.oldTarget)
         throw new Error("LAUNCHER_DRIFT_BEFORE_SWITCH");
       receipt.state = "switching";
       receipt.switchedLaunchers = [...receipt.switchedLaunchers, item.path];
       persistReceipt(join60(finalPath, "rollout-receipt.json"), receipt);
-      replaceLink(item.path, item.newTarget, item.backupPath, item.oldLinkTarget);
-      if (realpathSync17(item.path) !== item.newTarget || realpathSync17(item.backupPath) !== item.oldTarget) {
+      replaceLauncher(item);
+      if (!launcherIs(item.path, newLauncherState(item)) || !launcherIs(item.backupPath, oldLauncherState(item))) {
         throw new Error("LAUNCHER_SWITCH_READBACK_MISMATCH");
       }
       switched.push(item.path);
@@ -112482,17 +112847,16 @@ async function updateCopyfileRuntime(version2, options = {}) {
       let rollbackFailed = false;
       for (const item of [...launchers].reverse()) {
         try {
-          const currentTarget = realpathSync17(item.path);
-          if (currentTarget === item.oldTarget && readlinkSync6(item.path) === item.oldLinkTarget)
+          if (launcherIs(item.path, oldLauncherState(item)))
             continue;
-          if (currentTarget !== item.newTarget)
+          if (launcherTarget(item.path) !== item.newTarget)
             throw new Error("LAUNCHER_CHANGED_DURING_ROLLBACK");
           const temp = `${item.path}.skills-rollback-${id2}`;
           const afterPath = `${item.path}.skills-after-${id2}`;
           if (entryExists(afterPath))
             throw new Error("ROLLBACK_PRESERVATION_PATH_EXISTS");
-          symlinkSync(item.newTarget, afterPath);
-          symlinkSync(item.oldLinkTarget, temp);
+          materializeLauncher(afterPath, newLauncherState(item));
+          materializeLauncher(temp, oldLauncherState(item));
           renameSync14(temp, item.path);
         } catch {
           rollbackFailed = true;
@@ -112500,7 +112864,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
       }
       try {
         const receiptPath = join60(finalPath, "rollout-receipt.json");
-        const receipt = JSON.parse(readFileSync39(receiptPath, "utf8"));
+        const receipt = JSON.parse(readFileSync40(receiptPath, "utf8"));
         receipt.state = rollbackFailed ? "rollback-required" : "rolled-back";
         persistReceipt(receiptPath, receipt);
       } catch {
@@ -112519,9 +112883,9 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
   const home = resolve26(options.homeDir ?? process.env.HOME ?? "");
   if (!home || !existsSync34(home))
     throw new Error("HOME_NOT_FOUND");
-  const runtimeRoot = join60(realpathSync17(home), ".hasna", "skills", "runtime");
+  const runtimeRoot = join60(realpathSync18(home), ".hasna", "skills", "runtime");
   assertNoSymlinkAncestors(runtimeRoot);
-  const rootStat = lstatSync31(runtimeRoot);
+  const rootStat = lstatSync32(runtimeRoot);
   if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || (rootStat.mode & 63) !== 0)
     throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
   const releaseLock = acquireRuntimeLock(runtimeRoot);
@@ -112533,7 +112897,7 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
       if (!existsSync34(receipt2))
         return false;
       try {
-        return JSON.parse(readFileSync39(receipt2, "utf8")).id === receiptId;
+        return JSON.parse(readFileSync40(receipt2, "utf8")).id === receiptId;
       } catch {
         return false;
       }
@@ -112541,7 +112905,7 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
     if (matches2.length !== 1)
       throw new Error("RECEIPT_NOT_FOUND_OR_AMBIGUOUS");
     const receiptPath = join60(runtimeRoot, matches2[0], "rollout-receipt.json");
-    const receipt = object10(JSON.parse(readFileSync39(receiptPath, "utf8")), "RECEIPT_INVALID");
+    const receipt = object10(JSON.parse(readFileSync40(receiptPath, "utf8")), "RECEIPT_INVALID");
     if (receipt.schema !== "skills.copyfile-runtime-receipt.v1" || !["switched", "switching", "rollback-required"].includes(receipt.state) || receipt.runtimeRoot !== runtimeRoot) {
       throw new Error("RECEIPT_STATE_INVALID");
     }
@@ -112562,43 +112926,40 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
     const seen = new Set;
     for (const item of receipt.launchers) {
       const bin = oldBins[basename15(item.path)];
-      if (!bin || !isAbsolute26(item.path) || seen.has(item.path) || item.oldTarget !== join60(receipt.currentPackageRoot, bin) || item.newTarget !== join60(receipt.targetPackageRoot, bin) || !/^.+\.skills-prev-[0-9a-f-]{36}$/.test(item.backupPath) || !item.backupPath.startsWith(`${item.path}.skills-prev-`) || typeof item.oldLinkTarget !== "string" || resolve26(dirname32(item.path), item.oldLinkTarget) !== item.oldTarget)
+      if (!bin || !isAbsolute27(item.path) || seen.has(item.path) || item.oldTarget !== join60(receipt.currentPackageRoot, bin) || item.newTarget !== join60(receipt.targetPackageRoot, bin) || !/^.+\.skills-prev-[0-9a-f-]{36}$/.test(item.backupPath) || !item.backupPath.startsWith(`${item.path}.skills-prev-`) || typeof item.oldLinkTarget !== "string" || resolve26(dirname32(item.path), item.oldLinkTarget) !== item.oldTarget)
         throw new Error("RECEIPT_LAUNCHER_BINDING_INVALID");
       assertNoSymlinkAncestors(dirname32(item.path));
+      assertLauncherRecordShapes(item);
       seen.add(item.path);
-      const stat3 = lstatSync31(item.path);
-      if (!stat3.isSymbolicLink())
+      const oldState = oldLauncherState(item), newState = newLauncherState(item);
+      let activeTarget;
+      try {
+        activeTarget = launcherTarget(item.path);
+      } catch {
         throw new Error("LAUNCHER_DRIFT_ROLLBACK_REFUSED");
-      const activeTarget = realpathSync17(item.path);
-      if (activeTarget !== item.newTarget && (activeTarget !== item.oldTarget || readlinkSync6(item.path) !== item.oldLinkTarget))
+      }
+      if (!launcherIs(item.path, newState) && !launcherIs(item.path, oldState))
         throw new Error("LAUNCHER_DRIFT_ROLLBACK_REFUSED");
       const hasBackup = entryExists(item.backupPath);
       if (activeTarget === item.newTarget && !hasBackup)
         throw new Error("LAUNCHER_PREIMAGE_DRIFT_ROLLBACK_REFUSED");
-      if (hasBackup) {
-        const backup = lstatSync31(item.backupPath);
-        if (!backup.isSymbolicLink() || readlinkSync6(item.backupPath) !== item.oldLinkTarget || realpathSync17(item.backupPath) !== item.oldTarget)
-          throw new Error("LAUNCHER_PREIMAGE_DRIFT_ROLLBACK_REFUSED");
-      }
+      if (hasBackup && !launcherIs(item.backupPath, oldState))
+        throw new Error("LAUNCHER_PREIMAGE_DRIFT_ROLLBACK_REFUSED");
       const afterPath = `${item.path}.skills-after-${receiptId}`;
-      if (entryExists(afterPath)) {
-        const after2 = lstatSync31(afterPath);
-        if (!after2.isSymbolicLink() || realpathSync17(afterPath) !== item.newTarget)
-          throw new Error("ROLLBACK_PRESERVATION_DRIFT");
-      }
+      if (entryExists(afterPath) && !launcherIs(afterPath, newState))
+        throw new Error("ROLLBACK_PRESERVATION_DRIFT");
       switched.push(item);
     }
     for (const item of switched.reverse()) {
-      const activeTarget = realpathSync17(item.path);
-      if (activeTarget === item.oldTarget && readlinkSync6(item.path) === item.oldLinkTarget)
+      if (launcherIs(item.path, oldLauncherState(item)))
         continue;
       receipt.state = "rollback-required";
       persistReceipt(receiptPath, receipt);
       const afterPath = `${item.path}.skills-after-${receiptId}`;
       if (!entryExists(afterPath))
-        symlinkSync(item.newTarget, afterPath);
+        materializeLauncher(afterPath, newLauncherState(item));
       const temp = `${item.path}.skills-rollback-${receiptId}-${randomUUID10()}`;
-      symlinkSync(item.oldLinkTarget, temp);
+      materializeLauncher(temp, oldLauncherState(item));
       renameSync14(temp, item.path);
       receipt.rollbackCompletedLaunchers = [...new Set([...receipt.rollbackCompletedLaunchers, item.path])];
       persistReceipt(receiptPath, receipt);
@@ -112614,6 +112975,7 @@ var PACKAGE_NAME = "@hasna/skills", REGISTRY_ORIGIN = "https://registry.npmjs.or
 var init_runtime_copyfile = __esm(() => {
   init_skill_contract();
   init_reviewed_runtime_lock();
+  init_runtime_launcher();
   STABLE_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
   MAX_TARBALL_BYTES = 100 * 1024 * 1024;
   MAX_TARBALL_EXPANDED_BYTES = 256 * 1024 * 1024;
@@ -112628,11 +112990,12 @@ var init_runtime_copyfile = __esm(() => {
 // src/cli/commands/runtime.ts
 var exports_runtime = {};
 __export(exports_runtime, {
+  selectedSkillsCommand: () => selectedSkillsCommand,
   registerRuntime: () => registerRuntime
 });
-import { createHash as createHash35, randomUUID as randomUUID11 } from "crypto";
-import { lstatSync as lstatSync32, mkdirSync as mkdirSync26, readFileSync as readFileSync40, realpathSync as realpathSync18, writeFileSync as writeFileSync25 } from "fs";
-import { basename as basename16, isAbsolute as isAbsolute27, join as join61 } from "path";
+import { createHash as createHash36, randomUUID as randomUUID11 } from "crypto";
+import { lstatSync as lstatSync33, mkdirSync as mkdirSync26, readFileSync as readFileSync41, writeFileSync as writeFileSync25 } from "fs";
+import { basename as basename16, isAbsolute as isAbsolute28, join as join61 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
   parent.command("run").argument("<skill>", "Skill name").argument("[args...]", "Arguments to pass to the skill; use -- to end Skills options").allowUnknownOption(true).passThroughOptions(true).option("--json", "Output result as JSON", false).option("--remote", "Run on the configured server, using its catalog and quote", false).option("--target <target>", "Execution target: local or cloud").option("--secret-bindings <path>", "Reviewed, exact-selection local execution vault bindings (JSON file)").option("--secret-bindings-template", "Print a scoped bindings template without resolving secrets or running the skill", false).option("--input <json>", "Structured cloud execution input").option("--skill-version <version>", "Exact selected skill version").option("--selection-profile <id>", "Selected Skills profile").option("--session <id>", "Pinned Skills session").option("--cached", "Use the explicit verified selected cache", false).option("--yes", "Approve the server's quoted credit cost for this run", false).option("--idempotency-key <key>", "Reuse this key when retrying the same remote submission").option("--file <path>", "Attach a local input file to a remote run (repeatable)", (value, prior) => [...prior, value], []).option("--wait", "Poll remote runs until a terminal status", false).option("--poll-interval-ms <ms>", "Remote polling interval in milliseconds", "1000").option("--poll-timeout-ms <ms>", "Maximum time to wait for a remote run", "300000").description("Run a skill directly").action(async (name, args2, options, command) => {
@@ -112671,7 +113034,7 @@ function registerRuntime(parent) {
       if (!expected)
         throw new Error("Cloud artifact not found");
       const bytes = await client2.download(id2, name);
-      if (bytes.length !== expected.byteSize || createHash35("sha256").update(bytes).digest("hex") !== expected.sha256)
+      if (bytes.length !== expected.byteSize || createHash36("sha256").update(bytes).digest("hex") !== expected.sha256)
         throw new Error("Cloud artifact integrity verification failed");
       writeFileSync25(options.output, bytes, { flag: "wx", mode: 384 });
       console.log(JSON.stringify({ path: options.output, sha256: expected.sha256, byteSize: bytes.length }));
@@ -112831,20 +113194,29 @@ Updating ${name}...
 async function readUpdatedVersion(bunExecutable) {
   const output2 = await readUpdateCommand([bunExecutable, "pm", "bin", "-g"]);
   const globalBin = output2.replace(/\r?\n$/, "");
-  if (!globalBin || !isAbsolute27(globalBin) || /[\r\n\0]/.test(globalBin))
+  if (!globalBin || !isAbsolute28(globalBin) || /[\r\n\0]/.test(globalBin))
     throw new Error("Update bin discovery failed");
   const installed = Bun.which("skills", { PATH: globalBin, cwd: globalBin });
   const selected = Bun.which("skills");
   if (!installed || !selected)
     throw new Error("Updated command is unavailable");
-  const selectedPath = realpathSync18(selected);
-  if (selectedPath !== realpathSync18(installed))
-    throw new Error("Updated command is shadowed on PATH");
-  const version2 = (await readUpdateCommand([selectedPath, "--version"])).trim();
+  const version2 = (await readUpdateCommand([selectedSkillsCommand(selected, installed), "--version"])).trim();
   if (!new RegExp(SEMVER_PATTERN).test(version2))
     throw new Error("Update version verification failed");
   return version2;
 }
+function selectedSkillsCommand(selected, installed) {
+  let chosen, expected;
+  try {
+    chosen = resolveLauncherCommand(selected);
+    expected = resolveLauncherCommand(installed);
+  } catch {
+    throw new Error("Updated command is unavailable");
+  }
+  if (chosen.entry !== expected.entry)
+    throw new Error("Updated command is shadowed on PATH");
+  return chosen.pinned ? chosen.physical : chosen.entry;
+}
 async function readUpdateCommand(command) {
   const proc = Bun.spawn(command, { stdout: "pipe" });
   try {
@@ -113153,10 +113525,10 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
     try {
       parsePollingOptions(options);
       inputFiles = (options.file ?? []).map((path) => {
-        const info = lstatSync32(path);
+        const info = lstatSync33(path);
         if (!info.isFile() || info.size > 20 * 1024 * 1024)
           throw new Error("Input must be a regular file no larger than 20 MiB");
-        return { name: basename16(path), bytes: new Uint8Array(readFileSync40(path)) };
+        return { name: basename16(path), bytes: new Uint8Array(readFileSync41(path)) };
       });
       describeRemoteFiles(inputFiles);
       client2 = new RemoteSkillsClient(routing.apiKey, routing.apiOrigin);
@@ -113583,7 +113955,7 @@ function ensureSafeExportParent(root2, relativePath) {
     if (part)
       parent = join61(parent, part);
     try {
-      if (!lstatSync32(parent).isDirectory() || lstatSync32(parent).isSymbolicLink())
+      if (!lstatSync33(parent).isDirectory() || lstatSync33(parent).isSymbolicLink())
         throw new Error("Unsafe artifact directory");
     } catch (error61) {
       if (error61.code !== "ENOENT")
@@ -113793,6 +114165,7 @@ var init_runtime = __esm(() => {
   init_remote_account2();
   init_remote_files();
   init_runtime_copyfile();
+  init_runtime_launcher();
 });
 
 // src/cli/commands/customer-verification.ts
@@ -113876,12 +114249,12 @@ var exports_recurring = {};
 __export(exports_recurring, {
   registerRecurringCommands: () => registerRecurringCommands
 });
-import { constants as constants21, closeSync as closeSync21, fstatSync as fstatSync21, lstatSync as lstatSync33, openSync as openSync21, readSync as readSync17 } from "fs";
+import { constants as constants22, closeSync as closeSync23, fstatSync as fstatSync23, lstatSync as lstatSync34, openSync as openSync23, readSync as readSync17 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 function readRequest(path) {
-  const fd = openSync21(path, constants21.O_RDONLY | constants21.O_NOFOLLOW | constants21.O_NONBLOCK);
+  const fd = openSync23(path, constants22.O_RDONLY | constants22.O_NOFOLLOW | constants22.O_NONBLOCK);
   try {
-    const before2 = fstatSync21(fd);
+    const before2 = fstatSync23(fd);
     if (!before2.isFile() || before2.size > 1048576 || before2.size < 1)
       throw new RecurringInputError;
     const bytes = Buffer.alloc(before2.size + 1);
@@ -113892,14 +114265,14 @@ function readRequest(path) {
         break;
       length += n2;
     }
-    const after2 = fstatSync21(fd), current = lstatSync33(path);
+    const after2 = fstatSync23(fd), current = lstatSync34(path);
     if (length !== before2.size || after2.size !== before2.size || before2.mtimeMs !== after2.mtimeMs || before2.ctimeMs !== after2.ctimeMs || current.dev !== before2.dev || current.ino !== before2.ino || !current.isFile() || current.isSymbolicLink())
       throw new RecurringInputError;
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
   } catch {
     throw new RecurringInputError;
   } finally {
-    closeSync21(fd);
+    closeSync23(fd);
   }
 }
 async function acceptAtTerminal(draft) {
@@ -114325,22 +114698,22 @@ var init_portable_snapshot_filter = __esm(() => {
 });
 
 // src/lib/station-snapshot.ts
-import { createHash as createHash36 } from "crypto";
+import { createHash as createHash37 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync27,
-  readFileSync as readFileSync41,
+  readFileSync as readFileSync42,
   statSync as statSync21,
   writeFileSync as writeFileSync26
 } from "fs";
-import { dirname as dirname34, isAbsolute as isAbsolute28, relative as relative11, resolve as resolve27, sep as sep14 } from "path";
+import { dirname as dirname34, isAbsolute as isAbsolute29, relative as relative11, resolve as resolve27, sep as sep14 } from "path";
 function validateStationId(stationId) {
   if (!/^[a-z0-9-]+$/.test(stationId)) {
     throw new StationSnapshotError("INVALID_STATION", `station id must be a slug, got: ${stationId}`);
   }
 }
 function sha256File(filePath) {
-  return createHash36("sha256").update(readFileSync41(filePath)).digest("hex");
+  return createHash37("sha256").update(readFileSync42(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -114439,7 +114812,7 @@ function writeStationSnapshot(options) {
   for (const plan of plans) {
     const destination = resolve27(repoRoot, plan.destination);
     const destinationRelative = relative11(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep14) || isAbsolute28(destinationRelative)) {
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep14) || isAbsolute29(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -114959,11 +115332,37 @@ var init_codex_native_config = () => {};
 
 // src/lib/codex-hook-trust-identity.ts
 import { realpathSync as realpathSync19 } from "fs";
-import { dirname as dirname35, isAbsolute as isAbsolute29, join as join64 } from "path";
+import { dirname as dirname35, isAbsolute as isAbsolute30, join as join64 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual15 } from "util";
+function skillsCommandTarget(command) {
+  const physical = realpathSync19(command);
+  let resolved;
+  try {
+    resolved = resolveLauncherCommand(physical);
+  } catch {
+    need5(false, "SKILLS_LAUNCHER_UNVERIFIED");
+  }
+  if (!resolved.pinned)
+    return { entry: resolved.physical };
+  const launcher = snapshot(resolved.physical, false);
+  need5(launcher.sha256 === resolved.pinned.sha256, "SKILLS_LAUNCHER_UNVERIFIED");
+  try {
+    assertPinnedLauncherRuntimeSafe(resolved.pinned.runtime);
+  } catch {
+    need5(false, "SKILLS_LAUNCHER_UNVERIFIED");
+  }
+  return { entry: resolved.entry, launcher };
+}
+function skillsCommandEntry(command) {
+  try {
+    return resolveLauncherCommand(command).entry;
+  } catch {
+    need5(false, "SKILLS_COMMAND_CHANGED");
+  }
+}
 function inspectRecordedSkillsCli(command, expected) {
-  need5(isAbsolute29(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
-  const resolved = realpathSync19(command);
+  need5(isAbsolute30(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
+  const target = skillsCommandTarget(command), resolved = target.entry;
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
   const manifest = snapshot(join64(dirname35(dirname35(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
@@ -114972,7 +115371,9 @@ function inspectRecordedSkillsCli(command, expected) {
   const receipt = { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 };
   need5(isDeepStrictEqual15(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
   return { receipt, recheck() {
-    need5(realpathSync19(command) === resolved, "SKILLS_COMMAND_CHANGED");
+    need5(skillsCommandEntry(command) === resolved, "SKILLS_COMMAND_CHANGED");
+    if (target.launcher)
+      unchanged2(target.launcher);
     unchanged2(cli);
     unchanged2(manifest);
   } };
@@ -114980,9 +115381,11 @@ function inspectRecordedSkillsCli(command, expected) {
 function bindSkillsCli(command, reviewed) {
   const normal = Bun.which("skills", { PATH: process.env.PATH });
   need5(normal, "SKILLS_COMMAND_UNAVAILABLE");
-  const resolved = realpathSync19(normal);
-  const bound = isAbsolute29(command) ? command : command === "skills" ? normal : undefined;
-  need5(bound && realpathSync19(bound) === resolved, "SKILLS_COMMAND_MISMATCH");
+  const normalTarget = skillsCommandTarget(normal), resolved = normalTarget.entry;
+  const bound = isAbsolute30(command) ? command : command === "skills" ? normal : undefined;
+  need5(bound, "SKILLS_COMMAND_MISMATCH");
+  const boundTarget = skillsCommandTarget(bound);
+  need5(boundTarget.entry === resolved, "SKILLS_COMMAND_MISMATCH");
   const entrypoint = reviewed?.path ?? process.argv[1];
   need5(entrypoint && realpathSync19(entrypoint) === resolved, "SKILLS_ENTRYPOINT_MISMATCH");
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
@@ -114995,7 +115398,10 @@ function bindSkillsCli(command, reviewed) {
   return {
     receipt: { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 },
     recheck() {
-      need5(Bun.which("skills", { PATH: process.env.PATH }) === normal && realpathSync19(normal) === resolved && realpathSync19(bound) === resolved && realpathSync19(entrypoint) === resolved, "SKILLS_COMMAND_CHANGED");
+      need5(Bun.which("skills", { PATH: process.env.PATH }) === normal && skillsCommandEntry(normal) === resolved && skillsCommandEntry(bound) === resolved && realpathSync19(entrypoint) === resolved, "SKILLS_COMMAND_CHANGED");
+      for (const launcher of [normalTarget.launcher, boundTarget.launcher])
+        if (launcher)
+          unchanged2(launcher);
       unchanged2(cli);
       unchanged2(manifest);
     }
@@ -115003,6 +115409,7 @@ function bindSkillsCli(command, reviewed) {
 }
 var init_codex_hook_trust_identity = __esm(() => {
   init_codex_hook_trust_files();
+  init_runtime_launcher();
 });
 
 // src/lib/codex-hook-policy-recovery.ts
@@ -115029,23 +115436,23 @@ var init_codex_hook_policy_recovery = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync34, mkdirSync as mkdirSync28, readdirSync as readdirSync23, readFileSync as readFileSync42, realpathSync as realpathSync20, statSync as statSync22 } from "fs";
-import { createHash as createHash37, randomUUID as randomUUID12 } from "crypto";
+import { lstatSync as lstatSync35, mkdirSync as mkdirSync28, readdirSync as readdirSync23, readFileSync as readFileSync43, realpathSync as realpathSync20, statSync as statSync22 } from "fs";
+import { createHash as createHash38, randomUUID as randomUUID12 } from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
-import { dirname as dirname36, isAbsolute as isAbsolute30, join as join65, resolve as resolve28 } from "path";
+import { dirname as dirname36, isAbsolute as isAbsolute31, join as join65, resolve as resolve28 } from "path";
 import { homedir as homedir12 } from "os";
 import { isDeepStrictEqual as isDeepStrictEqual17 } from "util";
 function verifyReleaseArtifact(proof, skillsCli) {
-  need5(isAbsolute30(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
+  need5(isAbsolute31(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarPath = realpathSync20(proof.packageTarPath);
   need5(statSync22(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
-  const tarBytes = readFileSync42(tarPath);
-  need5(tarBytes.byteLength === proof.packageTarBytes && createHash37("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
+  const tarBytes = readFileSync43(tarPath);
+  need5(tarBytes.byteLength === proof.packageTarBytes && createHash38("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
   const packageRoot = dirname36(dirname36(realpathSync20(skillsCli.receipt.path)));
-  const manifest = readFileSync42(join65(packageRoot, "package.json"));
-  need5(createHash37("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
-  need5(createHash37("sha256").update(readFileSync42(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
-  const members2 = [["package/package.json", manifest], ["package/bin/index.js", readFileSync42(skillsCli.receipt.path)]];
+  const manifest = readFileSync43(join65(packageRoot, "package.json"));
+  need5(createHash38("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
+  need5(createHash38("sha256").update(readFileSync43(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
+  const members2 = [["package/package.json", manifest], ["package/bin/index.js", readFileSync43(skillsCli.receipt.path)]];
   for (const [member, expected] of members2) {
     let actual;
     try {
@@ -115062,10 +115469,10 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const home = resolve28(options.home ?? homedir12()), dataDir3 = resolve28(options.dataDir ?? getDataDirReadOnly());
     const parent = resolve28(join65(dataDir3, "native-hook-trust")), journal = resolve28(options.journal);
     need5(journal.startsWith(parent + "/") && /^[a-f0-9-]{36}$/.test(journal.slice(parent.length + 1)), "RECONCILE_JOURNAL_PATH");
-    const dir = lstatSync34(journal, { throwIfNoEntry: false });
+    const dir = lstatSync35(journal, { throwIfNoEntry: false });
     need5(!!dir && dir.isDirectory() && !dir.isSymbolicLink() && dir.uid === process.getuid() && (dir.mode & 511) === 448, "UNSAFE_JOURNAL");
-    need5(!lstatSync34(join65(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
-    need5(lstatSync34(join65(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
+    need5(!lstatSync35(join65(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
+    need5(lstatSync35(join65(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
     const stoppedFile = snapshot(join65(journal, "stopped.json"), true);
     const intentFile = snapshot(join65(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
     const configBefore = snapshot(join65(journal, "config.before.toml"), true), hooksBefore = snapshot(join65(journal, "hooks.before.json"), true), policyBefore = snapshot(join65(journal, "policy.before.json"), true);
@@ -115095,7 +115502,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     if (supersededBinding || recovery) {
       need5(Array.isArray(intent.nativeHooks) && intent.nativeHooks.length > 0, "RECONCILE_NATIVE_INVENTORY_REQUIRED");
       const proof = options.releaseProof;
-      need5(!!proof && isAbsolute30(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
+      need5(!!proof && isAbsolute31(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
     }
     const currentConfig = snapshot(intent.configPath, true);
     const policy = parseManagedSkillPolicy(policyCurrent.text), binding = policy.bridge;
@@ -115240,7 +115647,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     const binding = policy.bridge, alias = binding.rootAliases?.find((item) => item.agent === "codex");
     const skillsCli = bindSkillsCli(binding.commands.codex, options.reviewedSkillsCli);
     const physicalRoot = alias?.target ?? join65(home, ".codex"), hooksPath = join65(physicalRoot, "hooks.json"), configPath = join65(physicalRoot, "config.toml");
-    need5(options.codexHome === undefined || isAbsolute30(options.codexHome) && [join65(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
+    need5(options.codexHome === undefined || isAbsolute31(options.codexHome) && [join65(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
     const codexHome = options.codexHome === undefined ? undefined : physicalRoot;
     const nativeConfigPath = join65(codexHome ?? join65(home, ".codex"), "config.toml");
     const hooksFile = snapshot(hooksPath), configFile = snapshot(configPath, true), original = structure3(configFile.text);
@@ -115296,14 +115703,14 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
     if (options.apply)
       need5(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
     const parent = join65(dataDir3, "native-hook-trust");
-    const st = lstatSync34(parent, { throwIfNoEntry: false });
+    const st = lstatSync35(parent, { throwIfNoEntry: false });
     if (st) {
       need5(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
       const priorJournals = readdirSync23(parent);
       need5(priorJournals.length < 1000, "JOURNAL_BOUND");
       for (const name of priorJournals) {
         need5(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
-        need5(lstatSync34(join65(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
+        need5(lstatSync35(join65(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
       }
     }
     if (!options.apply || !planned.length)
@@ -115362,7 +115769,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect) {
   }
 }
 var json2 = (value) => JSON.stringify(value, null, 2) + `
-`, structure3 = (text4) => JSON.parse(JSON.stringify(Bun.TOML.parse(text4))), eventNames, makePlanDigest = (value) => createHash37("sha256").update(json2(value)).digest("hex"), safeNativeHook = (hook) => ({ key: hook.key, eventName: hook.eventName, handlerType: hook.handlerType, command: hook.command, matcher: hook.matcher, timeoutSec: hook.timeoutSec, async: hook.async, statusMessage: hook.statusMessage, additionalContextLimit: hook.additionalContextLimit, sourcePath: hook.sourcePath, source: hook.source, pluginId: hook.pluginId, isManaged: hook.isManaged, currentHash: hook.currentHash, enabled: hook.enabled, trustStatus: hook.trustStatus }), withoutCodexCommand = (value) => {
+`, structure3 = (text4) => JSON.parse(JSON.stringify(Bun.TOML.parse(text4))), eventNames, makePlanDigest = (value) => createHash38("sha256").update(json2(value)).digest("hex"), safeNativeHook = (hook) => ({ key: hook.key, eventName: hook.eventName, handlerType: hook.handlerType, command: hook.command, matcher: hook.matcher, timeoutSec: hook.timeoutSec, async: hook.async, statusMessage: hook.statusMessage, additionalContextLimit: hook.additionalContextLimit, sourcePath: hook.sourcePath, source: hook.source, pluginId: hook.pluginId, isManaged: hook.isManaged, currentHash: hook.currentHash, enabled: hook.enabled, trustStatus: hook.trustStatus }), withoutCodexCommand = (value) => {
   const copy = structuredClone(value);
   if (copy?.bridge?.commands && Object.hasOwn(copy.bridge.commands, "codex"))
     copy.bridge.commands.codex = "<reviewed-codex-binding>";
@@ -115386,8 +115793,8 @@ var init_agent_codex_trust = __esm(() => {
 });
 
 // src/lib/codex-native-trust.ts
-import { createHash as createHash38 } from "crypto";
-import { readFileSync as readFileSync43 } from "fs";
+import { createHash as createHash39 } from "crypto";
+import { readFileSync as readFileSync44 } from "fs";
 import { join as join66, resolve as resolve29 } from "path";
 function refuse5(detail) {
   throw new Error(`NATIVE_SKILL_POLICY_TRUST_REFUSED: ${detail}`);
@@ -115445,7 +115852,7 @@ function applyCodexNativeTrust(plan, expectedPolicySha256) {
     const backupPath = result2.backups[0];
     if (result2.backups.length !== 1 || typeof backupPath !== "string")
       throw new Error("NATIVE_SKILL_POLICY_TRUST_WRITE_UNVERIFIED: the pre-change backup was not recorded");
-    const backupSha256 = sha6(readFileSync43(backupPath));
+    const backupSha256 = sha6(readFileSync44(backupPath));
     if (backupSha256 !== plan.policySha256Before)
       throw new Error(`NATIVE_SKILL_POLICY_TRUST_WRITE_UNVERIFIED: the backup at ${backupPath} does not read back as the pre-change policy`);
     receipt.backup = { path: backupPath, sha256: backupSha256, verified: true };
@@ -115459,7 +115866,7 @@ function applyCodexNativeTrust(plan, expectedPolicySha256) {
   receipt.readback = { policySha256: sha6(readback.text), digests, verified: true };
   return receipt;
 }
-var CODEX_NATIVE_TRUST_PLAN_SCHEMA = "skills.codex-native-trust-plan/v1", CODEX_NATIVE_TRUST_RECEIPT_SCHEMA = "skills.codex-native-trust-receipt/v1", PLATFORM_KEY2, HEX_DIGEST2, MAX_DIGESTS = 16, sha6 = (data) => createHash38("sha256").update(data).digest("hex");
+var CODEX_NATIVE_TRUST_PLAN_SCHEMA = "skills.codex-native-trust-plan/v1", CODEX_NATIVE_TRUST_RECEIPT_SCHEMA = "skills.codex-native-trust-receipt/v1", PLATFORM_KEY2, HEX_DIGEST2, MAX_DIGESTS = 16, sha6 = (data) => createHash39("sha256").update(data).digest("hex");
 var init_codex_native_trust = __esm(() => {
   init_config();
   init_managed_policy();
@@ -115583,15 +115990,43 @@ var init_hook_diagnostics = __esm(() => {
   ]);
 });
 
+// src/lib/self-spawn.ts
+import { realpathSync as realpathSync21 } from "fs";
+import { dirname as dirname37, isAbsolute as isAbsolute32, sep as sep15 } from "path";
+function selfSpawnRoot(entry) {
+  const index = entry.indexOf(INSTALLED_PACKAGE);
+  const root2 = index > 0 ? entry.slice(0, index) : dirname37(entry);
+  try {
+    return realpathSync21(root2);
+  } catch {
+    return root2;
+  }
+}
+function selfSpawnCommand(args2, options = {}) {
+  const runtime = options.runtime ?? process.execPath;
+  const entry = options.entry ?? process.argv[1];
+  if (!runtime || !isAbsolute32(runtime) || !entry || !isAbsolute32(entry))
+    throw new Error("SKILLS_SELF_SPAWN_ENTRY_UNRESOLVED");
+  const root2 = selfSpawnRoot(entry);
+  const env3 = pinnedLauncherEnvironment(options.env ?? process.env);
+  env3[LAUNCH_CWD_VARIABLE] = options.callerCwd ?? process.cwd();
+  return { command: [runtime, ...PINNED_LAUNCHER_BUN_FLAGS, `--cwd=${root2}`, entry, ...args2], cwd: root2, env: env3 };
+}
+var INSTALLED_PACKAGE;
+var init_self_spawn = __esm(() => {
+  init_runtime_launcher();
+  INSTALLED_PACKAGE = `${sep15}node_modules${sep15}@hasna${sep15}skills${sep15}`;
+});
+
 // src/cli/commands/agent-integration.ts
 var exports_agent_integration = {};
 __export(exports_agent_integration, {
   registerAgentIntegration: () => registerAgentIntegration
 });
-import { existsSync as existsSync36, lstatSync as lstatSync35, readFileSync as readFileSync44, readSync as readSync18, writeFileSync as writeFileSync27 } from "fs";
-import { createHash as createHash39 } from "crypto";
+import { existsSync as existsSync36, lstatSync as lstatSync36, readFileSync as readFileSync45, readSync as readSync18, writeFileSync as writeFileSync27 } from "fs";
+import { createHash as createHash40 } from "crypto";
 import { homedir as homedir13 } from "os";
-import { isAbsolute as isAbsolute31 } from "path";
+import { isAbsolute as isAbsolute33 } from "path";
 function pinnedHookProfile(input3, configuredProfile) {
   try {
     const parsed = parseSkillContextInput(JSON.stringify(input3));
@@ -115612,10 +116047,11 @@ async function contextForHook(input3, profileId, cached2, deadline) {
   const remaining = deadline - Date.now();
   if (remaining <= 0)
     throw new HookDiagnosticError("SKILLS_HOOK_TIMEOUT", "context");
-  const args2 = [process.execPath, process.argv[1], "context", "--stdin", "--json", "--selection-profile", profileId];
+  const args2 = ["context", "--stdin", "--json", "--selection-profile", profileId];
   if (cached2)
     args2.push("--cached", "--auto-reconcile-safe");
-  const child = Bun.spawn(args2, { stdin: new Blob([JSON.stringify(input3)]), stdout: "pipe", stderr: "pipe", env: { ...process.env, NO_COLOR: "1" } });
+  const self2 = selfSpawnCommand(args2);
+  const child = Bun.spawn(self2.command, { cwd: self2.cwd, stdin: new Blob([JSON.stringify(input3)]), stdout: "pipe", stderr: "pipe", env: { ...self2.env, NO_COLOR: "1" } });
   let timedOut = false;
   const timer = setTimeout(() => {
     timedOut = true;
@@ -115686,7 +116122,7 @@ function registerAgentIntegration(parent) {
   });
   hook.command("native-catalog").requiredOption("--cwd <path>", "Absolute project directory observed by native Codex skills/list").requiredOption("--output <file>", "New private file for the projected native catalog").option("--codex-command <path>", "Installed Codex executable used by the native client", "codex").option("--json", "Output bounded capture metadata as JSON", false).description("Capture a reviewed Codex native skill catalog for exact hook enrollment").action(async (options) => {
     try {
-      if (!isAbsolute31(options.cwd) || !isAbsolute31(options.output))
+      if (!isAbsolute33(options.cwd) || !isAbsolute33(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_ABSOLUTE_PATH_REQUIRED");
       if (existsSync36(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
@@ -115705,8 +116141,8 @@ function registerAgentIntegration(parent) {
           throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
         throw error61;
       }
-      const written = lstatSync35(options.output);
-      if (!written.isFile() || written.isSymbolicLink() || (written.mode & 63) !== 0 || readFileSync44(options.output, "utf8") !== bytes)
+      const written = lstatSync36(options.output);
+      if (!written.isFile() || written.isSymbolicLink() || (written.mode & 63) !== 0 || readFileSync45(options.output, "utf8") !== bytes)
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_READBACK_FAILED");
       const receipt = {
         version: catalog.version,
@@ -115714,7 +116150,7 @@ function registerAgentIntegration(parent) {
         skillCount: catalog.skills.length,
         output: options.output,
         bytes: Buffer.byteLength(bytes),
-        sha256: createHash39("sha256").update(bytes).digest("hex")
+        sha256: createHash40("sha256").update(bytes).digest("hex")
       };
       await writeCliOutput(options.json ? JSON.stringify(receipt) : `Captured ${receipt.skillCount} native Codex skill(s) in ${receipt.output}.`);
     } catch (error61) {
@@ -115762,8 +116198,8 @@ function registerAgentIntegration(parent) {
   });
   hook.command("install").option("--agent <agent>", `Agent to configure: ${INTEGRATION_AGENTS.join(", ")}, all`, "all").option("--command <path>", "Skills executable used by the hook (preserves existing binding; new agents use skills)").option("--selection-profile <id>", "Selection profile (preserves existing binding; new agents use default)").option("--include-vendor", "Retained for compatibility; vendor system skills are always inventoried and disabled", false).option("--discovery-inputs <file>", "Advanced reviewed active plugin roots and source hashes for unsupported registrations").option("--codex-skill-denials <file>", "Explicit reviewed remote skill denials: array of exact name, path and document sha256; requires fresh catalog and discovery inputs").option("--codex-native-catalog <file>", "Reviewed supported Codex skill and installed-plugin receipt for exact qualified-name disables").option("--reviewed-cache-alias <path>", "Exact skill-containing vendor cache alias reviewed for this hook plan").option("--allow-root-aliases", "Allow home .claude/.codex aliases to existing directories within this home", false).option("--apply", "Apply the plan, preserving prior configuration in private backups", false).option("--json", "Output a receipt as JSON", false).description("Plan or install one Skills CLI bridge plus native prompt hooks").action(async (options) => {
     try {
-      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync44(options.discoveryInputs, "utf8")) : undefined;
-      const plan = planAgentIntegration({ projectDir: process.cwd(), agents: agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases, reviewedCacheAlias: options.reviewedCacheAlias, codexSkillDenials: options.codexSkillDenials ? JSON.parse(readFileSync44(options.codexSkillDenials, "utf8")) : undefined, codexNativeCatalog: options.codexNativeCatalog ? JSON.parse(readFileSync44(options.codexNativeCatalog, "utf8")) : undefined });
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync45(options.discoveryInputs, "utf8")) : undefined;
+      const plan = planAgentIntegration({ projectDir: process.cwd(), agents: agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases, reviewedCacheAlias: options.reviewedCacheAlias, codexSkillDenials: options.codexSkillDenials ? JSON.parse(readFileSync45(options.codexSkillDenials, "utf8")) : undefined, codexNativeCatalog: options.codexNativeCatalog ? JSON.parse(readFileSync45(options.codexNativeCatalog, "utf8")) : undefined });
       const result2 = options.apply ? applyAgentIntegration(plan) : { changed: [], backups: [] };
       const receipt = { codexPluginSkillReview: plan.codexPluginSkillReview, codexPluginSkills: plan.changes.filter((change) => change.path.endsWith("agent-policy.json")).map((change) => JSON.parse(change.after).bridge?.codexPluginSkills ?? []).flat(), applied: options.apply, planned: plan.changes.map((change) => change.path), ...result2, rootAliases: plan.rootAliases ?? [], discovery: plan.discoveryAfter, nativeSkills: plan.nativeSkills.map((entry) => ({ agent: entry.agent, path: entry.path, managed: entry.managed, vendor: entry.vendor, system: entry.system === true, bridge: entry.bridge === true })), requiresNativeRetirement: plan.nativeSkills.some((entry) => !entry.bridge && !entry.system) };
       if (options.json)
@@ -115822,7 +116258,7 @@ function registerAgentIntegration(parent) {
     try {
       if (agents(options.agent).length !== 1)
         throw new Error("A hook invocation requires one agent");
-      const inputBytes = readFileSync44(0), inputText = inputBytes.toString("utf8");
+      const inputBytes = readFileSync45(0), inputText = inputBytes.toString("utf8");
       if (inputText.length > 1024 * 1024)
         throw new Error("Hook input is too large");
       let input3 = JSON.parse(inputText);
@@ -115835,12 +116271,12 @@ function registerAgentIntegration(parent) {
       input3.hook_event_name = event;
       const projects = [process.cwd()];
       if (input3.cwd !== undefined) {
-        if (typeof input3.cwd !== "string" || !isAbsolute31(input3.cwd) || input3.cwd.includes("\x00"))
+        if (typeof input3.cwd !== "string" || !isAbsolute33(input3.cwd) || input3.cwd.includes("\x00"))
           throw new Error("Invalid native hook working directory");
         projects.push(input3.cwd);
       }
       if (options.agent === "cursor") {
-        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute31(path) || path.includes("\x00")))
+        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute33(path) || path.includes("\x00")))
           throw new Error("Invalid Cursor workspace roots");
         projects.push(...input3.workspace_roots);
         input3.cwd ??= input3.workspace_roots[0] ?? process.cwd();
@@ -115872,7 +116308,8 @@ function registerAgentIntegration(parent) {
         const remaining = deadline - Date.now() - 2000;
         if (remaining <= 0)
           throw new HookDiagnosticError("SKILLS_HOOK_TIMEOUT", "sync");
-        const refresh = Bun.spawn([process.execPath, process.argv[1], "sync", "--selection-profile", selectionProfile, "--no-station-report", "--json"], { stdin: "ignore", stdout: "pipe", stderr: "pipe", env: { ...process.env, NO_COLOR: "1" } });
+        const self2 = selfSpawnCommand(["sync", "--selection-profile", selectionProfile, "--no-station-report", "--json"]);
+        const refresh = Bun.spawn(self2.command, { cwd: self2.cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe", env: { ...self2.env, NO_COLOR: "1" } });
         let timedOut = false;
         const timer = setTimeout(() => {
           timedOut = true;
@@ -115937,7 +116374,7 @@ function registerAgentIntegration(parent) {
     try {
       if (options.agent && !INTEGRATION_AGENTS.includes(options.agent))
         throw new Error(`Unsupported migration agent: ${options.agent}`);
-      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync44(options.discoveryInputs, "utf8")) : undefined;
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync45(options.discoveryInputs, "utf8")) : undefined;
       if (options.targetManifest && (options.includeUnmanaged || options.includeVendor))
         throw new Error("--target-manifest cannot be combined with broad native migration selectors");
       const targetManifest = options.targetManifest ? readNativeMigrationTargetManifest(options.targetManifest) : undefined;
@@ -115974,6 +116411,7 @@ var init_agent_integration2 = __esm(() => {
   init_codex_settings_witness();
   init_claude_marketplace_registry();
   init_codex_native_skill_catalog();
+  init_self_spawn();
   RECOVERABLE_CONTEXT_CACHE_ERRORS = new Set(["CACHED_PROFILE_EXPIRED", "CACHED_PROFILE_MISSING", "CACHED_BUNDLE_MISSING"]);
 });
 
@@ -116112,11 +116550,11 @@ var exports_profiles = {};
 __export(exports_profiles, {
   registerProfiles: () => registerProfiles
 });
-import { closeSync as closeSync23, constants as constants22, fstatSync as fstatSync23, openSync as openSync23, readSync as readSync19, writeFileSync as writeFileSync28 } from "fs";
+import { closeSync as closeSync25, constants as constants23, fstatSync as fstatSync25, openSync as openSync25, readSync as readSync19, writeFileSync as writeFileSync28 } from "fs";
 function readProfileInput(path) {
-  const fd = openSync23(path, constants22.O_RDONLY | constants22.O_NONBLOCK);
+  const fd = openSync25(path, constants23.O_RDONLY | constants23.O_NONBLOCK);
   try {
-    const stat3 = fstatSync23(fd);
+    const stat3 = fstatSync25(fd);
     if (!stat3.isFile() || stat3.size > MAX_PROFILE_DOCUMENT_BYTES)
       throw new Error("Profile input exceeds the size limit or is not a regular file");
     const bytes = Buffer.alloc(MAX_PROFILE_DOCUMENT_BYTES + 1);
@@ -116131,7 +116569,7 @@ function readProfileInput(path) {
       throw new Error("Profile input exceeds the size limit");
     return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size2));
   } finally {
-    closeSync23(fd);
+    closeSync25(fd);
   }
 }
 function registerProfiles(parent) {
@@ -116182,17 +116620,17 @@ __export(exports_grants, {
   registerGrants: () => registerGrants
 });
 import {
-  constants as constants23,
-  closeSync as closeSync25,
-  fstatSync as fstatSync25,
-  openSync as openSync25,
+  constants as constants24,
+  closeSync as closeSync26,
+  fstatSync as fstatSync26,
+  openSync as openSync26,
   readSync as readSync20,
   writeFileSync as writeFileSync29
 } from "fs";
 function readInput(path) {
-  const fd = openSync25(path, constants23.O_RDONLY | constants23.O_NONBLOCK);
+  const fd = openSync26(path, constants24.O_RDONLY | constants24.O_NONBLOCK);
   try {
-    const stat3 = fstatSync25(fd);
+    const stat3 = fstatSync26(fd);
     if (!stat3.isFile() || stat3.size > MAX_EXECUTION_GRANT_BYTES)
       throw new Error("Grant input must be a regular file within the policy size limit.");
     const bytes = Buffer.alloc(MAX_EXECUTION_GRANT_BYTES + 1);
@@ -116211,7 +116649,7 @@ function readInput(path) {
       throw new Error("Grant input must be a JSON document containing a grants array.");
     }
   } finally {
-    closeSync25(fd);
+    closeSync26(fd);
   }
 }
 function registerGrants(parent) {
@@ -116247,16 +116685,16 @@ var init_grants = __esm(() => {
 });
 
 // src/lib/station-hydrate.ts
-import { createHash as createHash40 } from "crypto";
+import { createHash as createHash41 } from "crypto";
 import {
   copyFileSync as copyFileSync3,
   mkdirSync as mkdirSync29,
   readdirSync as readdirSync24,
-  readFileSync as readFileSync45,
+  readFileSync as readFileSync46,
   statSync as statSync23,
   writeFileSync as writeFileSync30
 } from "fs";
-import { dirname as dirname37, join as join67, resolve as resolve30, sep as sep15 } from "path";
+import { dirname as dirname38, join as join67, resolve as resolve30, sep as sep16 } from "path";
 function fail6(code2, message, detail = []) {
   throw new StationSnapshotError(code2, message, detail);
 }
@@ -116268,7 +116706,7 @@ function readSnapshotManifest(repoRoot, stationId) {
   const manifestPath = join67(snapshotRoot, "sync-manifest.json");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync45(manifestPath, "utf8"));
+    manifest = JSON.parse(readFileSync46(manifestPath, "utf8"));
   } catch (error61) {
     fail6("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error61.message}`);
   }
@@ -116306,7 +116744,7 @@ function planStationHydration(stationId, repoRoot) {
       const identRoot = join67(agentRoot, identEntry.name);
       const entries = walkEntries(identRoot);
       for (const entry of entries) {
-        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep15)];
+        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep16)];
         if (entry.kind === "symlink") {
           symlinks.push({ ident: identEntry.name, agent, relativePath: entry.relativePath });
           continue;
@@ -116330,8 +116768,8 @@ function planStationHydration(stationId, repoRoot) {
           });
           continue;
         }
-        const withinIdent = relativeParts.slice(1).join(sep15);
-        const homeRelative = relativeParts.join(sep15);
+        const withinIdent = relativeParts.slice(1).join(sep16);
+        const homeRelative = relativeParts.join(sep16);
         if (REFUSED_SCANNER_FLAGGED.has(homeRelative)) {
           skippedByRule.push({
             ident: identEntry.name,
@@ -116404,7 +116842,7 @@ function planStationHydration(stationId, repoRoot) {
         for (const copy of copies) {
           let isStub = false;
           try {
-            isStub = isPointerSkillMd(readFileSync45(copy.fullPath, "utf8"));
+            isStub = isPointerSkillMd(readFileSync46(copy.fullPath, "utf8"));
           } catch {
             isStub = false;
           }
@@ -116450,7 +116888,7 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash40("sha256").update(joined.sort().join(`
+  return createHash41("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
@@ -116509,7 +116947,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync29(dirname37(entry.destination), { recursive: true });
+    mkdirSync29(dirname38(entry.destination), { recursive: true });
     copyFileSync3(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -116530,8 +116968,8 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join67(dirname37(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync29(dirname37(hydrationManifestPath), { recursive: true });
+  const hydrationManifestPath = join67(dirname38(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync29(dirname38(hydrationManifestPath), { recursive: true });
   writeFileSync30(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
@@ -116607,10 +117045,10 @@ var init_hydrate = __esm(() => {
 });
 
 // src/lib/prepare-skill.ts
-import { createHash as createHash41, randomUUID as randomUUID13 } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync36, mkdirSync as mkdirSync30, mkdtempSync as mkdtempSync6, readFileSync as readFileSync46, readdirSync as readdirSync25, renameSync as renameSync15, rmSync as rmSync9, writeFileSync as writeFileSync31 } from "fs";
+import { createHash as createHash42, randomUUID as randomUUID13 } from "crypto";
+import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync37, mkdirSync as mkdirSync30, mkdtempSync as mkdtempSync6, readFileSync as readFileSync47, readdirSync as readdirSync25, renameSync as renameSync15, rmSync as rmSync9, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname38, isAbsolute as isAbsolute32, join as join68, relative as relative12, resolve as resolve31, sep as sep16 } from "path";
+import { dirname as dirname39, isAbsolute as isAbsolute34, join as join68, relative as relative12, resolve as resolve31, sep as sep17 } from "path";
 function prepareSkill(name, options) {
   const normalized = normalizePortableSkillName(name);
   if (!new RegExp(SEMVER_PATTERN).test(options.version))
@@ -116656,7 +117094,7 @@ function prepareSkill(name, options) {
       mkdirSync30(join68(staging, directory2), { recursive: true });
     for (const file2 of before2.files) {
       const destination = join68(staging, file2.path);
-      mkdirSync30(dirname38(destination), { recursive: true });
+      mkdirSync30(dirname39(destination), { recursive: true });
       writeFileSync31(destination, file2.bytes, { mode: file2.mode });
     }
     const stagedManifest = join68(staging, "skill.json");
@@ -116717,7 +117155,7 @@ function validateRuntimeEntrypoint(candidate2, root2) {
   if (typeof entry !== "string")
     return;
   const target = resolve31(root2, entry), rel = relative12(root2, target);
-  if (isAbsolute32(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep16}`) || isAbsolute32(rel) || !existsSync37(target) || !lstatSync36(target).isFile()) {
+  if (isAbsolute34(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep17}`) || isAbsolute34(rel) || !existsSync37(target) || !lstatSync37(target).isFile()) {
     throw new Error("Executable runtime.entrypoint must name an existing regular file inside the skill directory.");
   }
 }
@@ -116802,11 +117240,11 @@ function compareVersions(left, right) {
   return 0;
 }
 function snapshot2(root2) {
-  const rootStat = lstatSync36(root2);
+  const rootStat = lstatSync37(root2);
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
     throw new Error("Skill root must be a real directory, not a symlink.");
   const files = [], directories = [];
-  const hash6 = createHash41("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
+  const hash6 = createHash42("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
   let count = 0, bytes = 0;
   const walk2 = (relative13) => {
     for (const name of readdirSync25(join68(root2, relative13)).sort()) {
@@ -116815,7 +117253,7 @@ function snapshot2(root2) {
       const path = relative13 ? `${relative13}/${name}` : name;
       if (++count > 20000)
         throw new Error("Skill exceeds the preparation entry limit (20000).");
-      const absolute = join68(root2, path), stat3 = lstatSync36(absolute);
+      const absolute = join68(root2, path), stat3 = lstatSync37(absolute);
       if (stat3.isSymbolicLink())
         throw new Error(`Skill contains a symlink: ${path}. No files were changed.`);
       if (stat3.isDirectory() && name === "node_modules")
@@ -116828,7 +117266,7 @@ function snapshot2(root2) {
         bytes += stat3.size;
         if (bytes > 50000000)
           throw new Error("Skill exceeds the preparation size limit (50000000 bytes).");
-        const content = readFileSync46(absolute);
+        const content = readFileSync47(absolute);
         if (content.length !== stat3.size)
           throw new Error("Skill changed during preparation.");
         files.push({ path, bytes: content, mode: stat3.mode & 511 });
@@ -117231,7 +117669,7 @@ var init_schedule = __esm(() => {
 
 // src/lib/registry-sync.ts
 import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync32 } from "fs";
-import { dirname as dirname39, relative as relative13 } from "path";
+import { dirname as dirname40, relative as relative13 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
   const includeDocs = options.includeDocs ?? true;
@@ -117288,7 +117726,7 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync31(dirname39(path), { recursive: true });
+  mkdirSync31(dirname40(path), { recursive: true });
   writeFileSync32(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
@@ -117308,8 +117746,8 @@ var init_registry_sync = __esm(() => {
 });
 
 // src/lib/review-export.ts
-import { constants as constants24, closeSync as closeSync26, existsSync as existsSync38, fstatSync as fstatSync26, fsyncSync as fsyncSync8, lstatSync as lstatSync37, openSync as openSync26, realpathSync as realpathSync21, statSync as statSync24, writeFileSync as writeFileSync33 } from "fs";
-import { basename as basename17, dirname as dirname40, isAbsolute as isAbsolute33, join as join69, parse as parse13, resolve as resolve32, sep as sep17 } from "path";
+import { constants as constants25, closeSync as closeSync27, existsSync as existsSync38, fstatSync as fstatSync27, fsyncSync as fsyncSync9, lstatSync as lstatSync38, openSync as openSync27, realpathSync as realpathSync22, statSync as statSync24, writeFileSync as writeFileSync33 } from "fs";
+import { basename as basename17, dirname as dirname41, isAbsolute as isAbsolute35, join as join69, parse as parse13, resolve as resolve32, sep as sep18 } from "path";
 function exactVersion(spec) {
   const at2 = spec.indexOf("@");
   const slug2 = spec.slice(0, at2);
@@ -117320,22 +117758,22 @@ function exactVersion(spec) {
   return { slug: slug2, version: version2 };
 }
 function assertPrivateDestination(output2) {
-  if (!isAbsolute33(output2) || resolve32(output2) !== output2 || !basename17(output2).endsWith(".tar.gz")) {
+  if (!isAbsolute35(output2) || resolve32(output2) !== output2 || !basename17(output2).endsWith(".tar.gz")) {
     throw new Error("Review output must be an absolute, normalized .tar.gz path.");
   }
-  const parent = dirname40(output2);
-  if (realpathSync21(parent) !== parent || lstatSync37(parent).isSymbolicLink()) {
+  const parent = dirname41(output2);
+  if (realpathSync22(parent) !== parent || lstatSync38(parent).isSymbolicLink()) {
     throw new Error("Review output parent must be a real directory, not a symlink.");
   }
   const parentStat = statSync24(parent);
   if (!parentStat.isDirectory() || (parentStat.mode & 63) !== 0 || process.getuid && parentStat.uid !== process.getuid()) {
     throw new Error("Review output parent must be an owner-only directory (mode 0700).");
   }
-  const segments = parent.toLowerCase().split(sep17);
+  const segments = parent.toLowerCase().split(sep18);
   if (segments.some((segment) => NATIVE_CONTAINERS.has(segment)) || segments.some((segment, index) => segment === ".config" && segments[index + 1] === "opencode") || segments.some((segment, index) => segment === ".hasna" && segments[index + 1] === "skills")) {
     throw new Error("Review output cannot be placed in agent-native discovery or Skills installation paths.");
   }
-  for (let current = parent;; current = dirname40(current)) {
+  for (let current = parent;; current = dirname41(current)) {
     if (existsSync38(join69(current, ".git"))) {
       throw new Error("Review output cannot be placed inside a Git worktree.");
     }
@@ -117372,16 +117810,16 @@ async function exportSkillVersionForReview(spec, output2, client2) {
   if (bytes.byteLength !== metadata2.bundleByteSize || sha256Hex(bytes) !== metadata2.bundleSha256.toLowerCase()) {
     throw new Error("Published bundle bytes do not match the exact version metadata.");
   }
-  const fd = openSync26(target, constants24.O_WRONLY | constants24.O_CREAT | constants24.O_EXCL | constants24.O_NOFOLLOW, 384);
+  const fd = openSync27(target, constants25.O_WRONLY | constants25.O_CREAT | constants25.O_EXCL | constants25.O_NOFOLLOW, 384);
   try {
     writeFileSync33(fd, bytes);
-    fsyncSync8(fd);
-    if (fstatSync26(fd).size !== bytes.byteLength)
+    fsyncSync9(fd);
+    if (fstatSync27(fd).size !== bytes.byteLength)
       throw new Error("Incomplete review output write.");
   } catch (error61) {
     throw new Error(`Review output write failed. A private partial file may remain at ${target}; use Trash to remove it before reusing this path.`, { cause: error61 });
   } finally {
-    closeSync26(fd);
+    closeSync27(fd);
   }
   return { slug: slug2, version: version2, bundleSha256: metadata2.bundleSha256.toLowerCase(), bundleByteSize: bytes.byteLength, output: target };
 }
@@ -117621,7 +118059,7 @@ __export(exports_publish, {
   PushSkillError: () => PushSkillError
 });
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync39, readFileSync as readFileSync47 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync48 } from "fs";
 import { hostname as hostname5 } from "os";
 import { join as join70 } from "path";
 function registerPublish(parent) {
@@ -117676,7 +118114,7 @@ async function pushSkill(name, options = {}) {
   await verifyPackedCanonicalHash(skill.name, packed);
   const versionManifest = buildVersionManifest(skill.path, packed);
   const skillMdPath = join70(skill.path, "SKILL.md");
-  const skillMd = existsSync39(skillMdPath) ? readFileSync47(skillMdPath, "utf-8") : undefined;
+  const skillMd = existsSync39(skillMdPath) ? readFileSync48(skillMdPath, "utf-8") : undefined;
   const base3 = {
     slug: skill.name,
     path: skill.path,
@@ -119405,7 +119843,7 @@ var init_storage2 = __esm(() => {
 });
 
 // src/lib/registry-reconcile.ts
-import { existsSync as existsSync40, readFileSync as readFileSync48, statSync as statSync25, writeFileSync as writeFileSync34 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync49, statSync as statSync25, writeFileSync as writeFileSync34 } from "fs";
 import { join as join71 } from "path";
 function isDirectory2(path) {
   try {
@@ -119425,7 +119863,7 @@ function readBaseline(skillDir) {
   if (!existsSync40(markerPath))
     return;
   try {
-    const marker = JSON.parse(readFileSync48(markerPath, "utf-8"));
+    const marker = JSON.parse(readFileSync49(markerPath, "utf-8"));
     if (!isSkillsOwnershipMarker(marker))
       return;
     return {
@@ -119441,7 +119879,7 @@ function readCursor(root2) {
   if (!existsSync40(path))
     return { runCount: 0 };
   try {
-    const cursor2 = JSON.parse(readFileSync48(path, "utf-8"));
+    const cursor2 = JSON.parse(readFileSync49(path, "utf-8"));
     return { runCount: typeof cursor2.runCount === "number" ? cursor2.runCount : 0 };
   } catch {
     return { runCount: 0 };
@@ -119845,6 +120283,10 @@ var init_registry_reconcile2 = __esm(() => {
   init_selection_cache();
   init_registry_reconcile();
 });
+
+// src/cli/index.tsx
+init_launch_cwd_apply();
+
 // node_modules/ink/build/render.js
 import { Stream } from "stream";
 import process12 from "process";