@hasna/skills 0.10.8 → 0.10.9

package/bin/index.js

@@ -36868,7 +36868,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.8",
+    version: "0.10.9",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -36990,12 +36990,12 @@ var init_package = __esm(() => {
     },
     repository: {
       type: "git",
-      url: "https://github.com/hasna/apps.git",
+      url: "https://github.com/hasna/skills.git",
       directory: "apps/skills"
     },
-    homepage: "https://github.com/hasna/apps/tree/main/apps/skills",
+    homepage: "https://github.com/hasna/skills/tree/main/apps/skills",
     bugs: {
-      url: "https://github.com/hasna/apps/issues"
+      url: "https://github.com/hasna/skills/issues"
     }
   };
 });
@@ -107308,14 +107308,860 @@ var init_remote_account2 = __esm(() => {
   init_remote_client();
 });
 
+// src/cli/commands/runtime-copyfile.ts
+import { createHash as createHash26, randomUUID as randomUUID9 } from "crypto";
+import { Readable } from "stream";
+import { createGunzip as createGunzip2 } from "zlib";
+import {
+  chmodSync as chmodSync4,
+  copyFileSync,
+  existsSync as existsSync33,
+  lstatSync as lstatSync27,
+  mkdirSync as mkdirSync24,
+  readFileSync as readFileSync37,
+  readdirSync as readdirSync20,
+  readlinkSync as readlinkSync4,
+  realpathSync as realpathSync11,
+  renameSync as renameSync13,
+  symlinkSync,
+  writeFileSync as writeFileSync23
+} from "fs";
+import { basename as basename13, delimiter, dirname as dirname29, isAbsolute as isAbsolute22, join as join54, relative as relative8, resolve as resolve22, sep as sep9 } from "path";
+function object8(value, code2) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(code2);
+  return value;
+}
+function hash5(bytes) {
+  return createHash26("sha256").update(bytes).digest("hex");
+}
+function isWithin(parent, child) {
+  const rel = relative8(parent, child);
+  return rel === "" || !rel.startsWith(`..${sep9}`) && rel !== ".." && !isAbsolute22(rel);
+}
+function entryExists(path) {
+  try {
+    lstatSync27(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertNoSymlinkAncestors(path) {
+  const absolute = resolve22(path);
+  const parts = absolute.split(sep9).filter(Boolean);
+  let current = sep9;
+  for (const part of parts) {
+    current = join54(current, part);
+    const stat3 = lstatSync27(current);
+    if (stat3.isSymbolicLink())
+      throw new Error("PATH_ANCESTOR_SYMLINK_UNSUPPORTED");
+    if (!stat3.isDirectory())
+      throw new Error("PATH_ANCESTOR_NOT_DIRECTORY");
+  }
+}
+function acquireRuntimeLock(runtimeRoot) {
+  const lockPath = join54(runtimeRoot, ".copyfile-update-lock");
+  try {
+    mkdirSync24(lockPath, { mode: 448 });
+  } catch {
+    throw new Error("RUNTIME_UPDATE_LOCKED");
+  }
+  try {
+    writeJsonPrivate(join54(lockPath, "lock.json"), { operationId: randomUUID9(), pid: process.pid, startedAt: new Date().toISOString() });
+  } catch {
+    try {
+      renameSync13(lockPath, join54(runtimeRoot, `.copyfile-update-lock-incomplete-${randomUUID9()}`));
+    } catch {}
+    throw new Error("RUNTIME_LOCK_INITIALIZATION_FAILED");
+  }
+  return () => {
+    const released = join54(runtimeRoot, `.copyfile-update-lock-released-${randomUUID9()}`);
+    writeJsonPrivate(join54(lockPath, "released.json"), { completedAt: new Date().toISOString() });
+    renameSync13(lockPath, released);
+  };
+}
+function packageBins(pkg) {
+  const raw = pkg.bin;
+  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 || isAbsolute22(value)) {
+      throw new Error("PACKAGE_BIN_INVALID");
+    }
+    const normalized = value.replaceAll("\\", "/");
+    if (normalized.split("/").some((part) => part === ".." || part === "."))
+      throw new Error("PACKAGE_BIN_INVALID");
+    output2[name] = normalized;
+  }
+  if (!output2.skills)
+    throw new Error("PACKAGE_BIN_INVALID");
+  return output2;
+}
+function readPackage(path) {
+  let data;
+  try {
+    data = object8(JSON.parse(readFileSync37(path, "utf8")), "PACKAGE_JSON_INVALID");
+  } catch {
+    throw new Error("PACKAGE_JSON_INVALID");
+  }
+  if (data.name !== PACKAGE_NAME || typeof data.version !== "string" || !new RegExp(SEMVER_PATTERN).test(data.version)) {
+    throw new Error("PACKAGE_IDENTITY_INVALID");
+  }
+  return { data, version: data.version, bins: packageBins(data) };
+}
+function resolveRuntimeLayout(homeInput, pathInput) {
+  const home = realpathSync11(homeInput);
+  const runtimeRoot = join54(home, ".hasna", "skills", "runtime");
+  assertNoSymlinkAncestors(runtimeRoot);
+  const runtimeRootStat = lstatSync27(runtimeRoot);
+  if (!runtimeRootStat.isDirectory() || runtimeRootStat.isSymbolicLink() || (runtimeRootStat.mode & 63) !== 0) {
+    throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
+  }
+  const selectedLauncher = Bun.which("skills", { PATH: pathInput });
+  if (!selectedLauncher)
+    throw new Error("ACTIVE_SKILLS_LAUNCHER_NOT_FOUND");
+  const launcherPath = resolve22(selectedLauncher);
+  assertNoSymlinkAncestors(dirname29(launcherPath));
+  const launcherStat = lstatSync27(launcherPath);
+  if (!launcherStat.isSymbolicLink())
+    throw new Error("ACTIVE_SKILLS_LAUNCHER_NOT_MANAGED_LINK");
+  const activeBinary = realpathSync11(launcherPath);
+  const currentPackageRoot = dirname29(dirname29(activeBinary));
+  assertNoSymlinkAncestors(currentPackageRoot);
+  if (!isWithin(runtimeRoot, currentPackageRoot))
+    throw new Error("ACTIVE_RUNTIME_OUTSIDE_COPYFILE_ROOT");
+  const relativePackage = relative8(runtimeRoot, currentPackageRoot).split(sep9);
+  if (relativePackage.length !== 4 || relativePackage[1] !== "node_modules" || relativePackage[2] !== "@hasna" || relativePackage[3] !== "skills") {
+    throw new Error("ACTIVE_RUNTIME_LAYOUT_UNSUPPORTED");
+  }
+  const current = readPackage(join54(currentPackageRoot, "package.json"));
+  if (!activeBinary.startsWith(`${currentPackageRoot}${sep9}`) || activeBinary !== join54(currentPackageRoot, current.bins.skills)) {
+    throw new Error("ACTIVE_RUNTIME_ENTRYPOINT_MISMATCH");
+  }
+  const launchers = [];
+  for (const rawDir of pathInput.split(delimiter).filter(Boolean)) {
+    const dir = resolve22(rawDir);
+    for (const [name, target] of Object.entries(current.bins)) {
+      const path = join54(dir, name);
+      if (!existsSync33(path))
+        continue;
+      assertNoSymlinkAncestors(dir);
+      let stat3;
+      try {
+        stat3 = lstatSync27(path);
+      } catch {
+        continue;
+      }
+      if (!stat3.isSymbolicLink())
+        continue;
+      let actual;
+      try {
+        actual = realpathSync11(path);
+      } catch {
+        throw new Error("LAUNCHER_TARGET_UNREADABLE");
+      }
+      if (actual !== join54(currentPackageRoot, target))
+        continue;
+      const oldLinkTarget = readlinkSync4(path);
+      if (resolve22(dirname29(path), oldLinkTarget) !== actual)
+        throw new Error("LAUNCHER_SYMLINK_CHAIN_UNSUPPORTED");
+      const newTarget = join54(runtimeRoot, "__target__", "node_modules", "@hasna", "skills", target);
+      launchers.push({ path, oldTarget: actual, oldLinkTarget, newTarget, backupPath: `${path}.skills-prev-${randomUUID9()}` });
+    }
+  }
+  if (!launchers.some((item) => item.path === launcherPath))
+    throw new Error("ACTIVE_LAUNCHER_NOT_IN_PATH_INVENTORY");
+  if (new Set(launchers.map((item) => item.path)).size !== launchers.length)
+    throw new Error("LAUNCHER_PATH_DUPLICATE");
+  return { home, runtimeRoot, currentPackageRoot, currentVersion: current.version, bin: current.bins, launchers };
+}
+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 = createHash26("sha512").update(bytes).digest("base64");
+  if (actual !== match[1])
+    throw new Error("TARBALL_INTEGRITY_MISMATCH");
+}
+function expectedTarballUrl(input2, origin, version2) {
+  if (typeof input2 !== "string")
+    throw new Error("REGISTRY_TARBALL_URL_INVALID");
+  let url2;
+  try {
+    url2 = new URL(input2);
+  } catch {
+    throw new Error("REGISTRY_TARBALL_URL_INVALID");
+  }
+  const base3 = new URL(origin);
+  if (url2.protocol !== "https:" && base3.protocol === "https:")
+    throw new Error("REGISTRY_TARBALL_URL_INVALID");
+  if (url2.origin !== base3.origin || url2.username || url2.password || url2.search || url2.hash)
+    throw new Error("REGISTRY_TARBALL_URL_INVALID");
+  if (!url2.pathname.endsWith(`/skills-${version2}.tgz`))
+    throw new Error("REGISTRY_TARBALL_URL_INVALID");
+  return url2.toString();
+}
+function tarField(block, start, length) {
+  const field2 = block.subarray(start, start + length);
+  const end = field2.indexOf(0);
+  return new TextDecoder("utf-8", { fatal: true }).decode(end < 0 ? field2 : field2.subarray(0, end));
+}
+function tarOctal2(block, start, length) {
+  const raw = new TextDecoder().decode(block.subarray(start, start + length)).replace(/[\0 ]+$/g, "").trim();
+  if (!raw)
+    return 0;
+  if (!/^[0-7]+$/.test(raw))
+    throw new Error("TARBALL_TAR_NUMERIC_FIELD_INVALID");
+  const value = Number.parseInt(raw, 8);
+  if (!Number.isSafeInteger(value))
+    throw new Error("TARBALL_TAR_NUMERIC_FIELD_INVALID");
+  return value;
+}
+async function gunzipCapped(bytes, limit) {
+  if (bytes[0] !== 31 || bytes[1] !== 139)
+    throw new Error("TARBALL_GZIP_REQUIRED");
+  const stream = Readable.from([Buffer.from(bytes)]).pipe(createGunzip2());
+  const chunks = [];
+  let size2 = 0;
+  try {
+    for await (const chunk2 of stream) {
+      const part = Buffer.from(chunk2);
+      size2 += part.byteLength;
+      if (size2 > limit) {
+        stream.destroy();
+        throw new Error("TARBALL_EXPANDED_SIZE_INVALID");
+      }
+      chunks.push(part);
+    }
+  } finally {
+    stream.destroy();
+  }
+  return Buffer.concat(chunks, size2);
+}
+async function preflightTarball(bytes, limits = {}) {
+  const expanded = await gunzipCapped(bytes, limits.maxExpandedBytes ?? MAX_TARBALL_EXPANDED_BYTES);
+  const entries = [];
+  const paths = new Set;
+  let offset = 0, ended = false, fileBytes = 0;
+  while (offset + 512 <= expanded.byteLength) {
+    const block = expanded.subarray(offset, offset + 512);
+    if (block.every((byte) => byte === 0)) {
+      ended = true;
+      break;
+    }
+    if (entries.length >= (limits.maxEntries ?? MAX_TARBALL_ENTRIES))
+      throw new Error("TARBALL_ENTRY_COUNT_INVALID");
+    const expectedChecksum = tarOctal2(block, 148, 8);
+    let checksum = 0;
+    for (let i = 0;i < 512; i++)
+      checksum += i >= 148 && i < 156 ? 32 : block[i];
+    if (checksum !== expectedChecksum)
+      throw new Error("TARBALL_TAR_CHECKSUM_INVALID");
+    const name = tarField(block, 0, 100), prefix = tarField(block, 345, 155);
+    const rawPath = `${prefix ? `${prefix}/` : ""}${name}`.replace(/\/$/, "");
+    const pathParts2 = rawPath.split("/");
+    if (rawPath !== "package" && !rawPath.startsWith("package/") || rawPath.startsWith("/") || rawPath.includes("\\") || pathParts2.some((part) => !part || part === "." || part === ".."))
+      throw new Error("TARBALL_PATH_INVALID");
+    if (paths.has(rawPath))
+      throw new Error("TARBALL_DUPLICATE_PATH");
+    paths.add(rawPath);
+    const flag = block[156] === 0 ? "0" : String.fromCharCode(block[156]);
+    const size2 = tarOctal2(block, 124, 12);
+    const kind = flag === "0" ? "file" : flag === "5" ? "directory" : null;
+    if (!kind || kind === "directory" && size2 !== 0 || rawPath === "package" && kind !== "directory")
+      throw new Error("TARBALL_ENTRY_TYPE_UNSUPPORTED");
+    fileBytes += size2;
+    if (fileBytes > (limits.maxExpandedBytes ?? MAX_TARBALL_EXPANDED_BYTES))
+      throw new Error("TARBALL_EXPANDED_SIZE_INVALID");
+    entries.push({ path: rawPath, kind, size: size2 });
+    const padded = Math.ceil(size2 / 512) * 512;
+    offset += 512 + padded;
+    if (offset > expanded.byteLength)
+      throw new Error("TARBALL_TAR_TRUNCATED");
+  }
+  if (!ended || !expanded.subarray(offset).every((byte) => byte === 0))
+    throw new Error("TARBALL_TAR_TERMINATOR_INVALID");
+  return { entries, expandedBytes: expanded.byteLength };
+}
+async function downloadPackage(version2, stagingRoot, registryOrigin, fetcher) {
+  const metadataUrl = `${registryOrigin}/@hasna%2fskills/${encodeURIComponent(version2)}`;
+  const timeout = AbortSignal.timeout(30000);
+  const metadataResponse = await fetcher(metadataUrl, { redirect: "error", signal: timeout });
+  if (!metadataResponse.ok || new URL(metadataResponse.url || metadataUrl).origin !== new URL(registryOrigin).origin)
+    throw new Error("REGISTRY_METADATA_FETCH_FAILED");
+  const metadata = object8(JSON.parse(new TextDecoder().decode(await readBodyCapped(metadataResponse, 5 * 1024 * 1024, "REGISTRY_METADATA_SIZE_INVALID"))), "REGISTRY_METADATA_INVALID");
+  if (metadata.name !== PACKAGE_NAME || metadata.version !== version2 || metadata._id !== `${PACKAGE_NAME}@${version2}`)
+    throw new Error("REGISTRY_PACKAGE_IDENTITY_MISMATCH");
+  const dist = object8(metadata.dist, "REGISTRY_DIST_INVALID");
+  const integrity = typeof dist.integrity === "string" ? dist.integrity : "";
+  const tarballUrl = expectedTarballUrl(dist.tarball, registryOrigin, version2);
+  const response = await fetcher(tarballUrl, { redirect: "error", signal: AbortSignal.timeout(30000) });
+  if (!response.ok || new URL(response.url || tarballUrl).origin !== new URL(registryOrigin).origin)
+    throw new Error("REGISTRY_TARBALL_FETCH_FAILED");
+  const bytes = await readBodyCapped(response, MAX_TARBALL_BYTES, "TARBALL_SIZE_INVALID");
+  if (!bytes.byteLength)
+    throw new Error("TARBALL_SIZE_INVALID");
+  verifyIntegrity(bytes, integrity);
+  const preflight = await preflightTarball(bytes);
+  const archive = new Bun.Archive(bytes);
+  const files = await archive.files();
+  const regularFiles = preflight.entries.filter((entry) => entry.kind === "file");
+  if (files.size !== regularFiles.length || regularFiles.some((entry) => files.get(entry.path)?.size !== entry.size))
+    throw new Error("TARBALL_ARCHIVE_INTERPRETATION_MISMATCH");
+  const packageJson = files.get("package/package.json");
+  if (!packageJson)
+    throw new Error("TARBALL_PACKAGE_JSON_MISSING");
+  const unpacked = object8(JSON.parse(await packageJson.text()), "TARBALL_PACKAGE_JSON_INVALID");
+  if (unpacked.name !== PACKAGE_NAME || unpacked.version !== version2)
+    throw new Error("TARBALL_PACKAGE_IDENTITY_MISMATCH");
+  const bins = packageBins(unpacked);
+  const archiveRoot = join54(stagingRoot, "verified-archive");
+  mkdirSync24(archiveRoot, { mode: 448 });
+  await archive.extract(archiveRoot);
+  const extractedPackage = join54(archiveRoot, "package");
+  const extracted = readTree(extractedPackage, false);
+  const tarballPath = join54(stagingRoot, "verified-package.tgz");
+  writeFileSync23(tarballPath, bytes, { flag: "wx", mode: 384 });
+  if (!readFileSync37(tarballPath).equals(Buffer.from(bytes)))
+    throw new Error("TARBALL_READBACK_MISMATCH");
+  return {
+    tarballPath,
+    tarballUrl,
+    integrity,
+    sha256: hash5(bytes),
+    byteSize: bytes.byteLength,
+    packageTreeSha256: extracted.digest,
+    packageBins: bins
+  };
+}
+async function readBodyCapped(response, limit, errorCode) {
+  if (!response.body)
+    throw new Error("HTTP_RESPONSE_BODY_MISSING");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size2 = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      size2 += value.byteLength;
+      if (size2 > limit) {
+        await reader.cancel();
+        throw new Error(errorCode);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size2);
+  let offset = 0;
+  for (const chunk2 of chunks) {
+    bytes.set(chunk2, offset);
+    offset += chunk2.byteLength;
+  }
+  return bytes;
+}
+function readTree(root2, includeModes) {
+  const base3 = realpathSync11(root2);
+  const entries = [];
+  const walk2 = (dir, prefix = "") => {
+    for (const item of readdirSync20(dir).sort()) {
+      const path = join54(dir, item);
+      const rel = prefix ? `${prefix}/${item}` : item;
+      const stat3 = lstatSync27(path);
+      if (stat3.isSymbolicLink()) {
+        const link2 = readlinkSync4(path);
+        const resolved = resolve22(dirname29(path), link2);
+        if (!isWithin(base3, resolved))
+          throw new Error("TREE_SYMLINK_ESCAPES_ROOT");
+        let physicalTarget;
+        try {
+          physicalTarget = realpathSync11(path);
+        } catch {
+          throw new Error("TREE_SYMLINK_TARGET_MISSING");
+        }
+        if (!isWithin(base3, physicalTarget))
+          throw new Error("TREE_SYMLINK_ESCAPES_ROOT");
+        entries.push({ path: rel, kind: "symlink", target: link2, ...includeModes ? { mode: stat3.mode & 511 } : {} });
+      } else if (stat3.isDirectory()) {
+        entries.push({ path: rel, kind: "directory", ...includeModes ? { mode: stat3.mode & 511 } : {} });
+        walk2(path, rel);
+      } else if (stat3.isFile()) {
+        if (stat3.nlink !== 1)
+          throw new Error("TREE_HARDLINK_UNSUPPORTED");
+        const bytes = readFileSync37(path);
+        entries.push({ path: rel, kind: "file", sha256: hash5(bytes), ...includeModes ? { mode: stat3.mode & 511 } : {} });
+      } else
+        throw new Error("TREE_ENTRY_TYPE_UNSUPPORTED");
+    }
+  };
+  walk2(base3);
+  return { entries, digest: hash5(new TextEncoder().encode(JSON.stringify(entries))) };
+}
+function normalizeModes(root2) {
+  const walk2 = (dir) => {
+    for (const item of readdirSync20(dir)) {
+      const path = join54(dir, item);
+      const stat3 = lstatSync27(path);
+      if (stat3.isSymbolicLink())
+        continue;
+      if (stat3.isDirectory()) {
+        chmodSync4(path, stat3.mode & 493);
+        walk2(path);
+      } else if (stat3.isFile()) {
+        chmodSync4(path, stat3.mode & 493);
+      } else
+        throw new Error("RUNTIME_ENTRY_TYPE_UNSUPPORTED");
+    }
+  };
+  walk2(root2);
+}
+function writeJsonPrivate(path, value) {
+  const bytes = Buffer.from(`${JSON.stringify(value, null, 2)}
+`);
+  writeFileSync23(path, bytes, { flag: "wx", mode: 384 });
+  chmodSync4(path, 384);
+  if (!readFileSync37(path).equals(bytes))
+    throw new Error("PRIVATE_JSON_READBACK_MISMATCH");
+}
+function writePreimageManifest(stage, configs, launchers) {
+  const path = join54(stage, "preimage", "manifest.json");
+  const value = { schema: "skills.copyfile-preimage.v1", configs, launchers };
+  const bytes = Buffer.from(`${JSON.stringify(value, null, 2)}
+`);
+  writeFileSync23(path, bytes, { flag: "wx", mode: 256 });
+  chmodSync4(path, 256);
+  if (!readFileSync37(path).equals(bytes))
+    throw new Error("PREIMAGE_MANIFEST_READBACK_MISMATCH");
+  return hash5(bytes);
+}
+function verifyPreimageManifest(runtimePath, receipt, home) {
+  const path = join54(runtimePath, "preimage", "manifest.json");
+  const bytes = readFileSync37(path);
+  if (hash5(bytes) !== receipt.preimageSha256)
+    throw new Error("PREIMAGE_MANIFEST_DRIFT");
+  const manifest = object8(JSON.parse(bytes.toString("utf8")), "PREIMAGE_MANIFEST_INVALID");
+  const expected = { schema: "skills.copyfile-preimage.v1", configs: receipt.configs, launchers: receipt.launchers };
+  if (JSON.stringify(manifest) !== JSON.stringify(expected))
+    throw new Error("PREIMAGE_RECEIPT_MISMATCH");
+  if (receipt.configs.length !== CONFIG_PREIMAGE_PATHS.length)
+    throw new Error("PREIMAGE_CONFIG_SET_INVALID");
+  for (const [index, relativePath] of CONFIG_PREIMAGE_PATHS.entries()) {
+    const config2 = receipt.configs[index];
+    if (config2.relativePath !== relativePath || config2.sourcePath !== join54(home, relativePath))
+      throw new Error("PREIMAGE_CONFIG_BINDING_INVALID");
+    if (config2.present) {
+      const backup = join54(runtimePath, "preimage", "configs", relativePath);
+      const stat3 = lstatSync27(backup);
+      const saved = readFileSync37(backup);
+      if (!stat3.isFile() || stat3.isSymbolicLink() || hash5(saved) !== config2.sha256 || saved.byteLength !== config2.byteSize)
+        throw new Error("PREIMAGE_CONFIG_DRIFT");
+    }
+  }
+}
+function captureConfigPreimages(home, stage) {
+  const root2 = join54(stage, "preimage", "configs");
+  mkdirSync24(root2, { recursive: true, mode: 448 });
+  return CONFIG_PREIMAGE_PATHS.map((relativePath) => {
+    const sourcePath = join54(home, relativePath);
+    if (!entryExists(sourcePath))
+      return { sourcePath, relativePath, present: false };
+    const stat3 = lstatSync27(sourcePath);
+    if (!stat3.isFile() || stat3.isSymbolicLink())
+      throw new Error("CONFIG_PREIMAGE_NOT_REGULAR_FILE");
+    const bytes = readFileSync37(sourcePath);
+    const backupPath = join54(root2, relativePath);
+    mkdirSync24(dirname29(backupPath), { recursive: true, mode: 448 });
+    writeFileSync23(backupPath, bytes, { flag: "wx", mode: 384 });
+    chmodSync4(backupPath, 384);
+    const readback = readFileSync37(backupPath);
+    if (!readback.equals(bytes))
+      throw new Error("CONFIG_PREIMAGE_READBACK_MISMATCH");
+    return { sourcePath, relativePath, present: true, sha256: hash5(bytes), byteSize: bytes.byteLength };
+  });
+}
+function assertConfigUnchanged(configs) {
+  for (const config2 of configs) {
+    const present = entryExists(config2.sourcePath);
+    if (present !== config2.present)
+      throw new Error("CONFIG_DRIFT_DURING_UPDATE");
+    if (present) {
+      const stat3 = lstatSync27(config2.sourcePath);
+      if (!stat3.isFile() || stat3.isSymbolicLink() || hash5(readFileSync37(config2.sourcePath)) !== config2.sha256) {
+        throw new Error("CONFIG_DRIFT_DURING_UPDATE");
+      }
+    }
+  }
+}
+async function runNpm(args2, cwd2, home, staging) {
+  const userNpmrc = join54(staging, "npm-user.npmrc"), globalNpmrc = join54(staging, "npm-global.npmrc");
+  if (!existsSync33(userNpmrc))
+    writeFileSync23(userNpmrc, `registry=${REGISTRY_ORIGIN}/
+ignore-scripts=true
+`, { mode: 384, flag: "wx" });
+  if (!existsSync33(globalNpmrc))
+    writeFileSync23(globalNpmrc, `registry=${REGISTRY_ORIGIN}/
+ignore-scripts=true
+`, { mode: 384, flag: "wx" });
+  const env3 = {
+    PATH: process.env.PATH ?? "",
+    HOME: home,
+    TMPDIR: staging,
+    TMP: staging,
+    TEMP: staging,
+    CI: "1",
+    NPM_CONFIG_USERCONFIG: userNpmrc,
+    NPM_CONFIG_GLOBALCONFIG: globalNpmrc,
+    NPM_CONFIG_CACHE: join54(staging, "npm-cache"),
+    NPM_CONFIG_REGISTRY: `${REGISTRY_ORIGIN}/`,
+    NPM_CONFIG_IGNORE_SCRIPTS: "true"
+  };
+  const proc = Bun.spawn(["npm", ...args2, "--registry", `${REGISTRY_ORIGIN}/`, "--ignore-scripts", "--no-audit", "--no-fund"], {
+    cwd: cwd2,
+    env: env3,
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0)
+    throw new Error("DEPENDENCY_GRAPH_INSTALL_FAILED");
+}
+function comparePackageTrees(expectedRoot, installedRoot) {
+  const expected = readTree(expectedRoot, false);
+  const installed = readTree(installedRoot, false);
+  if (JSON.stringify(expected.entries) !== JSON.stringify(installed.entries))
+    throw new Error("INSTALLED_PACKAGE_BYTES_MISMATCH");
+  return expected.digest;
+}
+function replaceLink(path, target, backupPath, oldLinkTarget) {
+  const stat3 = lstatSync27(path);
+  if (!stat3.isSymbolicLink() || entryExists(backupPath))
+    throw new Error("LAUNCHER_PREIMAGE_DRIFT");
+  const temp = `${path}.skills-next-${randomUUID9()}`;
+  symlinkSync(oldLinkTarget, backupPath);
+  if (readlinkSync4(backupPath) !== oldLinkTarget || realpathSync11(backupPath) !== resolve22(dirname29(path), oldLinkTarget))
+    throw new Error("LAUNCHER_BACKUP_READBACK_MISMATCH");
+  symlinkSync(target, temp);
+  if (realpathSync11(temp) !== target)
+    throw new Error("LAUNCHER_NEW_LINK_READBACK_MISMATCH");
+  renameSync13(temp, path);
+}
+function atomicJson(path, value) {
+  const temp = `${path}.next-${randomUUID9()}`;
+  const bytes = Buffer.from(`${JSON.stringify(value, null, 2)}
+`);
+  writeFileSync23(temp, bytes, { flag: "wx", mode: 384 });
+  chmodSync4(temp, 384);
+  renameSync13(temp, path);
+  if (!readFileSync37(path).equals(bytes))
+    throw new Error("RECEIPT_READBACK_MISMATCH");
+}
+function persistReceipt(path, value) {
+  if (entryExists(path)) {
+    const priorBytes = readFileSync37(path);
+    const prior = object8(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");
+    const nextBytes = Buffer.from(`${JSON.stringify(value, null, 2)}
+`);
+    if (priorBytes.equals(nextBytes))
+      return;
+    const historyRoot = join54(dirname29(path), "receipt-history");
+    if (!entryExists(historyRoot))
+      mkdirSync24(historyRoot, { mode: 448 });
+    const historyStat = lstatSync27(historyRoot);
+    if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
+      throw new Error("RECEIPT_HISTORY_NOT_PRIVATE");
+    const historyPath = join54(historyRoot, `${value.id}-${String(prior.state)}-${randomUUID9()}.json`);
+    writeFileSync23(historyPath, priorBytes, { flag: "wx", mode: 256 });
+    chmodSync4(historyPath, 256);
+    if (!readFileSync37(historyPath).equals(priorBytes))
+      throw new Error("RECEIPT_HISTORY_READBACK_MISMATCH");
+  }
+  atomicJson(path, value);
+}
+async function updateCopyfileRuntime(version2, options = {}) {
+  if (!new RegExp(SEMVER_PATTERN).test(version2))
+    throw new Error("EXACT_VERSION_REQUIRED");
+  if (!STABLE_SEMVER_PATTERN.test(version2))
+    throw new Error("EXACT_STABLE_VERSION_REQUIRED");
+  const home = resolve22(options.homeDir ?? process.env.HOME ?? "");
+  if (!home || !existsSync33(home))
+    throw new Error("HOME_NOT_FOUND");
+  const layout = resolveRuntimeLayout(home, options.pathValue ?? process.env.PATH ?? "");
+  if (process.platform === "win32")
+    throw new Error("COPYFILE_RUNTIME_PLATFORM_UNSUPPORTED");
+  const registryOrigin = options.registryOrigin ?? REGISTRY_ORIGIN;
+  const origin = new URL(registryOrigin);
+  if (origin.protocol !== "https:" && options.registryOrigin === undefined)
+    throw new Error("REGISTRY_ORIGIN_INVALID");
+  if (origin.username || origin.password || origin.search || origin.hash)
+    throw new Error("REGISTRY_ORIGIN_INVALID");
+  const runtimeRootStat = lstatSync27(layout.runtimeRoot);
+  if ((runtimeRootStat.mode & 63) !== 0)
+    throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
+  const id2 = randomUUID9();
+  const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
+  const stagePath = join54(layout.runtimeRoot, `.stage-${version2}-${id2}`);
+  const finalPath = join54(layout.runtimeRoot, `${version2}-copyfile`);
+  const launchers = layout.launchers.map((item) => ({ ...item, newTarget: join54(finalPath, "node_modules", "@hasna", "skills", layout.bin[basename13(item.path)]) }));
+  let switched = [];
+  let moved = false;
+  try {
+    if (entryExists(finalPath))
+      throw new Error("TARGET_RUNTIME_ALREADY_EXISTS");
+    mkdirSync24(stagePath, { mode: 448 });
+    chmodSync4(stagePath, 448);
+    const configPreimages = captureConfigPreimages(home, stagePath);
+    const fetcher = options.fetcher ?? fetch;
+    const artifact = await downloadPackage(version2, stagePath, origin.origin, fetcher);
+    if (artifact.packageBins && JSON.stringify(Object.entries(artifact.packageBins).sort()) !== JSON.stringify(Object.entries(layout.bin).sort())) {
+      throw new Error("PACKAGE_BIN_SET_CHANGED");
+    }
+    const stagePackage = join54(stagePath, "install");
+    mkdirSync24(stagePackage, { mode: 448 });
+    copyFileSync(artifact.tarballPath, join54(stagePackage, "verified.tgz"));
+    writeFileSync23(join54(stagePackage, "package.json"), JSON.stringify({ private: true, dependencies: { [PACKAGE_NAME]: "file:./verified.tgz" } }, null, 2), { mode: 384, flag: "wx" });
+    await runNpm(["install", "--package-lock-only", "--prefix", stagePackage], stagePackage, home, stagePath);
+    await runNpm(["ci", "--prefix", stagePackage], stagePackage, home, stagePath);
+    const lockBytes = readFileSync37(join54(stagePackage, "package-lock.json"));
+    const installedPackage = join54(stagePackage, "node_modules", "@hasna", "skills");
+    const installed = readPackage(join54(installedPackage, "package.json"));
+    if (installed.version !== version2 || JSON.stringify(Object.entries(installed.bins).sort()) !== JSON.stringify(Object.entries(layout.bin).sort())) {
+      throw new Error("INSTALLED_PACKAGE_IDENTITY_MISMATCH");
+    }
+    const unpackedPackage = join54(stagePath, "verified-archive", "package");
+    const packageTreeSha256 = comparePackageTrees(unpackedPackage, installedPackage);
+    if (packageTreeSha256 !== artifact.packageTreeSha256)
+      throw new Error("PACKAGE_TREE_HASH_MISMATCH");
+    const nodeModules = join54(stagePackage, "node_modules");
+    normalizeModes(nodeModules);
+    chmodSync4(stagePath, 448);
+    const runtimeTree = readTree(nodeModules, true);
+    if (runtimeTree.entries.some((entry) => entry.kind === "file" && ((entry.mode ?? 0) & 18) !== 0)) {
+      throw new Error("RUNTIME_FILE_MODE_UNSAFE");
+    }
+    assertConfigUnchanged(configPreimages);
+    const targetPackageRoot = join54(finalPath, "node_modules", "@hasna", "skills");
+    const preimageSha256 = writePreimageManifest(stagePath, configPreimages, launchers);
+    const receipt = {
+      schema: "skills.copyfile-runtime-receipt.v1",
+      id: id2,
+      state: "prepared",
+      package: PACKAGE_NAME,
+      currentVersion: layout.currentVersion,
+      targetVersion: version2,
+      registryOrigin: origin.origin,
+      tarballUrl: artifact.tarballUrl,
+      tarballIntegrity: artifact.integrity,
+      tarballSha256: artifact.sha256,
+      tarballBytes: artifact.byteSize,
+      packageTreeSha256,
+      installLockSha256: hash5(lockBytes),
+      runtimeTreeSha256: runtimeTree.digest,
+      runtimeRoot: layout.runtimeRoot,
+      currentPackageRoot: layout.currentPackageRoot,
+      targetPackageRoot,
+      configs: configPreimages,
+      preimageSha256,
+      launchers,
+      switchedLaunchers: [],
+      rollbackCompletedLaunchers: []
+    };
+    writeJsonPrivate(join54(stagePath, "rollout-receipt.json"), receipt);
+    const finalNodeModules = join54(stagePackage, "node_modules");
+    const stagedNodeModules = join54(stagePath, "node_modules");
+    renameSync13(finalNodeModules, stagedNodeModules);
+    copyFileSync(join54(stagePackage, "package-lock.json"), join54(stagePath, "install-lock.json"));
+    chmodSync4(join54(stagePath, "install-lock.json"), 384);
+    const stagedTree = readTree(stagedNodeModules, true);
+    if (stagedTree.digest !== runtimeTree.digest)
+      throw new Error("STAGED_RUNTIME_READBACK_MISMATCH");
+    receipt.targetPackageRoot = join54(finalPath, "node_modules", "@hasna", "skills");
+    receipt.runtimeTreeSha256 = stagedTree.digest;
+    persistReceipt(join54(stagePath, "rollout-receipt.json"), receipt);
+    renameSync13(stagePath, finalPath);
+    moved = true;
+    const finalReceiptBytes = Buffer.from(`${JSON.stringify(receipt, null, 2)}
+`);
+    if (!readFileSync37(join54(finalPath, "rollout-receipt.json")).equals(finalReceiptBytes))
+      throw new Error("RECEIPT_MOVE_READBACK_MISMATCH");
+    assertConfigUnchanged(configPreimages);
+    for (const item of launchers) {
+      if (realpathSync11(item.path) !== item.oldTarget)
+        throw new Error("LAUNCHER_DRIFT_BEFORE_SWITCH");
+      receipt.state = "switching";
+      receipt.switchedLaunchers = [...receipt.switchedLaunchers, item.path];
+      persistReceipt(join54(finalPath, "rollout-receipt.json"), receipt);
+      replaceLink(item.path, item.newTarget, item.backupPath, item.oldLinkTarget);
+      if (realpathSync11(item.path) !== item.newTarget || realpathSync11(item.backupPath) !== item.oldTarget) {
+        throw new Error("LAUNCHER_SWITCH_READBACK_MISMATCH");
+      }
+      switched.push(item.path);
+      options.onLauncherSwitched?.(item.path);
+    }
+    receipt.state = "switched";
+    persistReceipt(join54(finalPath, "rollout-receipt.json"), receipt);
+    return { updated: true, version: version2, currentVersion: layout.currentVersion, receiptId: id2, runtimeRoot: finalPath, tarballSha256: artifact.sha256, tarballIntegrity: artifact.integrity, runtimeTreeSha256: stagedTree.digest, launcherCount: launchers.length, configCount: configPreimages.length };
+  } catch (error61) {
+    if (switched.length > 0 || moved) {
+      let rollbackFailed = false;
+      for (const item of [...launchers].reverse()) {
+        try {
+          const currentTarget = realpathSync11(item.path);
+          if (currentTarget === item.oldTarget && readlinkSync4(item.path) === item.oldLinkTarget)
+            continue;
+          if (currentTarget !== 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);
+          renameSync13(temp, item.path);
+        } catch {
+          rollbackFailed = true;
+        }
+      }
+      try {
+        const receiptPath = join54(finalPath, "rollout-receipt.json");
+        const receipt = JSON.parse(readFileSync37(receiptPath, "utf8"));
+        receipt.state = rollbackFailed ? "rollback-required" : "rolled-back";
+        persistReceipt(receiptPath, receipt);
+      } catch {
+        rollbackFailed = true;
+      }
+      throw new Error(rollbackFailed ? "UPDATE_FAILED_ROLLBACK_REQUIRED" : "UPDATE_FAILED_ROLLED_BACK");
+    }
+    throw error61 instanceof Error ? error61 : new Error("COPYFILE_UPDATE_FAILED");
+  } finally {
+    releaseLock();
+  }
+}
+function rollbackCopyfileRuntime(receiptId, options = {}) {
+  if (!/^[0-9a-f-]{36}$/.test(receiptId))
+    throw new Error("RECEIPT_ID_INVALID");
+  const home = resolve22(options.homeDir ?? process.env.HOME ?? "");
+  if (!home || !existsSync33(home))
+    throw new Error("HOME_NOT_FOUND");
+  const runtimeRoot = join54(realpathSync11(home), ".hasna", "skills", "runtime");
+  assertNoSymlinkAncestors(runtimeRoot);
+  const rootStat = lstatSync27(runtimeRoot);
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || (rootStat.mode & 63) !== 0)
+    throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
+  const releaseLock = acquireRuntimeLock(runtimeRoot);
+  try {
+    const matches2 = readdirSync20(runtimeRoot).filter((name) => {
+      if (!/^\d+\.\d+\.\d+-copyfile$/.test(name))
+        return false;
+      const receipt2 = join54(runtimeRoot, name, "rollout-receipt.json");
+      if (!existsSync33(receipt2))
+        return false;
+      try {
+        return JSON.parse(readFileSync37(receipt2, "utf8")).id === receiptId;
+      } catch {
+        return false;
+      }
+    });
+    if (matches2.length !== 1)
+      throw new Error("RECEIPT_NOT_FOUND_OR_AMBIGUOUS");
+    const receiptPath = join54(runtimeRoot, matches2[0], "rollout-receipt.json");
+    const receipt = object8(JSON.parse(readFileSync37(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");
+    }
+    if (receipt.package !== PACKAGE_NAME || matches2[0] !== `${receipt.targetVersion}-copyfile` || !new RegExp(SEMVER_PATTERN).test(receipt.currentVersion) || !new RegExp(SEMVER_PATTERN).test(receipt.targetVersion))
+      throw new Error("RECEIPT_BINDING_INVALID");
+    const runtimePath = join54(runtimeRoot, matches2[0]);
+    if (receipt.targetPackageRoot !== join54(runtimePath, "node_modules", "@hasna", "skills") || receipt.currentPackageRoot !== join54(runtimeRoot, `${receipt.currentVersion}-copyfile`, "node_modules", "@hasna", "skills"))
+      throw new Error("RECEIPT_RUNTIME_BINDING_INVALID");
+    if (readTree(join54(runtimePath, "node_modules"), true).digest !== receipt.runtimeTreeSha256) {
+      throw new Error("ACTIVE_RUNTIME_TREE_DRIFT");
+    }
+    verifyPreimageManifest(runtimePath, receipt, home);
+    const oldBins = readPackage(join54(receipt.currentPackageRoot, "package.json")).bins;
+    const newPackage = readPackage(join54(receipt.targetPackageRoot, "package.json"));
+    if (newPackage.version !== receipt.targetVersion || JSON.stringify(Object.entries(oldBins).sort()) !== JSON.stringify(Object.entries(newPackage.bins).sort()))
+      throw new Error("RECEIPT_BIN_BINDING_INVALID");
+    const switched = [];
+    const seen = new Set;
+    for (const item of receipt.launchers) {
+      const bin = oldBins[basename13(item.path)];
+      if (!bin || !isAbsolute22(item.path) || seen.has(item.path) || item.oldTarget !== join54(receipt.currentPackageRoot, bin) || item.newTarget !== join54(receipt.targetPackageRoot, bin) || !/^.+\.skills-prev-[0-9a-f-]{36}$/.test(item.backupPath) || !item.backupPath.startsWith(`${item.path}.skills-prev-`) || typeof item.oldLinkTarget !== "string" || resolve22(dirname29(item.path), item.oldLinkTarget) !== item.oldTarget)
+        throw new Error("RECEIPT_LAUNCHER_BINDING_INVALID");
+      assertNoSymlinkAncestors(dirname29(item.path));
+      seen.add(item.path);
+      const stat3 = lstatSync27(item.path);
+      if (!stat3.isSymbolicLink())
+        throw new Error("LAUNCHER_DRIFT_ROLLBACK_REFUSED");
+      const activeTarget = realpathSync11(item.path);
+      if (activeTarget !== item.newTarget && (activeTarget !== item.oldTarget || readlinkSync4(item.path) !== item.oldLinkTarget))
+        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 = lstatSync27(item.backupPath);
+        if (!backup.isSymbolicLink() || readlinkSync4(item.backupPath) !== item.oldLinkTarget || realpathSync11(item.backupPath) !== item.oldTarget)
+          throw new Error("LAUNCHER_PREIMAGE_DRIFT_ROLLBACK_REFUSED");
+      }
+      const afterPath = `${item.path}.skills-after-${receiptId}`;
+      if (entryExists(afterPath)) {
+        const after2 = lstatSync27(afterPath);
+        if (!after2.isSymbolicLink() || realpathSync11(afterPath) !== item.newTarget)
+          throw new Error("ROLLBACK_PRESERVATION_DRIFT");
+      }
+      switched.push(item);
+    }
+    for (const item of switched.reverse()) {
+      const activeTarget = realpathSync11(item.path);
+      if (activeTarget === item.oldTarget && readlinkSync4(item.path) === item.oldLinkTarget)
+        continue;
+      receipt.state = "rollback-required";
+      persistReceipt(receiptPath, receipt);
+      const afterPath = `${item.path}.skills-after-${receiptId}`;
+      if (!entryExists(afterPath))
+        symlinkSync(item.newTarget, afterPath);
+      const temp = `${item.path}.skills-rollback-${receiptId}-${randomUUID9()}`;
+      symlinkSync(item.oldLinkTarget, temp);
+      renameSync13(temp, item.path);
+      receipt.rollbackCompletedLaunchers = [...new Set([...receipt.rollbackCompletedLaunchers, item.path])];
+      persistReceipt(receiptPath, receipt);
+    }
+    receipt.state = "rolled-back";
+    persistReceipt(receiptPath, receipt);
+    return { rolledBack: true, receiptId, restoredVersion: receipt.currentVersion, launcherCount: switched.length };
+  } finally {
+    releaseLock();
+  }
+}
+var PACKAGE_NAME = "@hasna/skills", REGISTRY_ORIGIN = "https://registry.npmjs.org", STABLE_SEMVER_PATTERN, MAX_TARBALL_BYTES, MAX_TARBALL_EXPANDED_BYTES, MAX_TARBALL_ENTRIES = 20000, CONFIG_PREIMAGE_PATHS;
+var init_runtime_copyfile = __esm(() => {
+  init_skill_contract();
+  STABLE_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
+  MAX_TARBALL_BYTES = 100 * 1024 * 1024;
+  MAX_TARBALL_EXPANDED_BYTES = 256 * 1024 * 1024;
+  CONFIG_PREIMAGE_PATHS = [
+    ".claude/settings.json",
+    ".codex/config.toml",
+    ".codex/hooks.json",
+    ".hasna/skills/agent-policy.json"
+  ];
+});
+
 // src/cli/commands/runtime.ts
 var exports_runtime = {};
 __export(exports_runtime, {
   registerRuntime: () => registerRuntime
 });
-import { createHash as createHash26, randomUUID as randomUUID9 } from "crypto";
-import { lstatSync as lstatSync27, mkdirSync as mkdirSync24, readFileSync as readFileSync37, realpathSync as realpathSync11, writeFileSync as writeFileSync23 } from "fs";
-import { basename as basename13, isAbsolute as isAbsolute22, join as join54 } from "path";
+import { createHash as createHash27, randomUUID as randomUUID10 } from "crypto";
+import { lstatSync as lstatSync28, mkdirSync as mkdirSync25, readFileSync as readFileSync38, realpathSync as realpathSync12, writeFileSync as writeFileSync24 } from "fs";
+import { basename as basename14, isAbsolute as isAbsolute23, join as join55 } 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) => {
@@ -107354,9 +108200,9 @@ function registerRuntime(parent) {
       if (!expected)
         throw new Error("Cloud artifact not found");
       const bytes = await client2.download(id2, name);
-      if (bytes.length !== expected.byteSize || createHash26("sha256").update(bytes).digest("hex") !== expected.sha256)
+      if (bytes.length !== expected.byteSize || createHash27("sha256").update(bytes).digest("hex") !== expected.sha256)
         throw new Error("Cloud artifact integrity verification failed");
-      writeFileSync23(options.output, bytes, { flag: "wx", mode: 384 });
+      writeFileSync24(options.output, bytes, { flag: "wx", mode: 384 });
       console.log(JSON.stringify({ path: options.output, sha256: expected.sha256, byteSize: bytes.length }));
     } catch (error61) {
       console.error(JSON.stringify({ error: error61.message }));
@@ -107384,7 +108230,40 @@ function registerRuntime(parent) {
   });
   const setup = parent.command("setup").description("Point this CLI at a Skills API server, or register agent integrations").option("--api-url <url>", "Skills API origin to send remote work to").option("--global", "Accepted for compatibility; the API origin is always per-user", false).option("--json", "Output setup result as JSON", false).action(async (options) => handleSetup(options));
   setup.command("agents").option("--json", "Output registration result as JSON", false).description("Register the Skills MCP server with all supported agents").action(async (options) => handleMcp({ register: "all", json: options.json }));
-  parent.command("self-update").description("Update @hasna/skills to the latest version").option("--json", "Output result as JSON", false).action(async (options) => {
+  parent.command("self-update").description("Update @hasna/skills to the latest version").option("--json", "Output result as JSON", false).option("--version <version>", "Install this exact @hasna/skills version as a staged copyfile runtime").option("--rollback <receipt-id>", "Restore launcher links from an exact copyfile rollout receipt").action(async (options) => {
+    if (options.version && options.rollback) {
+      console.error(JSON.stringify({ error: "UPDATE_AND_ROLLBACK_ARE_MUTUALLY_EXCLUSIVE" }));
+      process.exitCode = 1;
+      return;
+    }
+    if (options.version) {
+      try {
+        const result2 = await updateCopyfileRuntime(options.version);
+        if (options.json)
+          console.log(JSON.stringify(result2));
+        else
+          console.log(source_default.green(`Updated @hasna/skills to exact version ${options.version} via copyfile runtime.`));
+      } catch (error61) {
+        const message = error61 instanceof Error && /^[A-Z0-9_]+$/.test(error61.message) ? error61.message : "COPYFILE_UPDATE_FAILED";
+        console.error(JSON.stringify({ updated: false, error: message }));
+        process.exitCode = 1;
+      }
+      return;
+    }
+    if (options.rollback) {
+      try {
+        const result2 = rollbackCopyfileRuntime(options.rollback);
+        if (options.json)
+          console.log(JSON.stringify(result2));
+        else
+          console.log(source_default.green(`Restored Skills runtime launchers to ${String(result2.restoredVersion)}.`));
+      } catch (error61) {
+        const message = error61 instanceof Error && /^[A-Z0-9_]+$/.test(error61.message) ? error61.message : "COPYFILE_ROLLBACK_FAILED";
+        console.error(JSON.stringify({ rolledBack: false, error: message }));
+        process.exitCode = 1;
+      }
+      return;
+    }
     if (process.env.SKILLS_TEST_MODE === "1") {
       if (options.json)
         console.log(JSON.stringify({ updated: false, error: "Self-update disabled in test mode" }));
@@ -107442,14 +108321,14 @@ Updating ${name}...
 async function readUpdatedVersion(bunExecutable) {
   const output2 = await readUpdateCommand([bunExecutable, "pm", "bin", "-g"]);
   const globalBin = output2.replace(/\r?\n$/, "");
-  if (!globalBin || !isAbsolute22(globalBin) || /[\r\n\0]/.test(globalBin))
+  if (!globalBin || !isAbsolute23(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 = realpathSync11(selected);
-  if (selectedPath !== realpathSync11(installed))
+  const selectedPath = realpathSync12(selected);
+  if (selectedPath !== realpathSync12(installed))
     throw new Error("Updated command is shadowed on PATH");
   const version2 = (await readUpdateCommand([selectedPath, "--version"])).trim();
   if (!new RegExp(SEMVER_PATTERN).test(version2))
@@ -107580,14 +108459,14 @@ function requireHttpUrl(value) {
 }
 function promptLine(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve22) => {
+  return new Promise((resolve23) => {
     let settled = false;
     const finish = (answer) => {
       if (settled)
         return;
       settled = true;
       rl.close();
-      resolve22(answer);
+      resolve23(answer);
     };
     rl.once("SIGINT", () => finish(null));
     rl.once("close", () => finish(null));
@@ -107707,7 +108586,7 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
       if (!Number.isFinite(timeoutMs) || timeoutMs < 1 || timeoutMs > 1200000 || !Number.isFinite(intervalMs) || intervalMs < 100 || intervalMs > 60000)
         throw new Error("Invalid cloud polling bounds");
       const client3 = await CloudExecutionClient.configured();
-      const admitted = await client3.submit(slug2, version2, input2, options.idempotencyKey ?? randomUUID9(), selected?.selection);
+      const admitted = await client3.submit(slug2, version2, input2, options.idempotencyKey ?? randomUUID10(), selected?.selection);
       if (options.wait)
         console.error(JSON.stringify({ executionId: admitted.id, status: admitted.status }));
       const result3 = options.wait ? await client3.wait(admitted.id, { timeoutMs, intervalMs }) : admitted;
@@ -107764,10 +108643,10 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
     try {
       parsePollingOptions(options);
       inputFiles = (options.file ?? []).map((path) => {
-        const info = lstatSync27(path);
+        const info = lstatSync28(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: basename13(path), bytes: new Uint8Array(readFileSync37(path)) };
+        return { name: basename14(path), bytes: new Uint8Array(readFileSync38(path)) };
       });
       describeRemoteFiles(inputFiles);
       client2 = new RemoteSkillsClient(routing.apiKey, routing.apiOrigin);
@@ -108145,7 +109024,7 @@ async function handleExportsDownload(runId2, options) {
     const canonicalSkill = typeof remoteRun.skill === "string" ? remoteRun.skill : "remote";
     const requestedSkill = typeof remoteRun.requestedSlug === "string" && remoteRun.requestedSlug.trim() ? remoteRun.requestedSlug : canonicalSkill;
     const exportDir = getRunExportDir(runId2, requestedSkill);
-    mkdirSync24(exportDir, { recursive: true });
+    mkdirSync25(exportDir, { recursive: true });
     const downloaded = [];
     for (const artifact of artifacts) {
       const artifactId = String(artifact.id || "");
@@ -108153,9 +109032,9 @@ async function handleExportsDownload(runId2, options) {
         continue;
       const verified = await client2.getVerifiedRunArtifact(runId2, artifactId);
       const relativePath = safeArtifactRelativePath(typeof artifact.relativePath === "string" ? artifact.relativePath : artifact.fileName, String(artifact.fileName || artifactId));
-      const outputPath = join54(exportDir, relativePath);
+      const outputPath = join55(exportDir, relativePath);
       ensureSafeExportParent(exportDir, relativePath);
-      writeFileSync23(outputPath, verified.bytes, { flag: "wx", mode: 384 });
+      writeFileSync24(outputPath, verified.bytes, { flag: "wx", mode: 384 });
       downloaded.push({ id: artifactId, path: outputPath, byteSize: verified.byteSize });
     }
     const payload = {
@@ -108192,14 +109071,14 @@ function ensureSafeExportParent(root2, relativePath) {
   let parent = root2;
   for (const part of ["", ...parts]) {
     if (part)
-      parent = join54(parent, part);
+      parent = join55(parent, part);
     try {
-      if (!lstatSync27(parent).isDirectory() || lstatSync27(parent).isSymbolicLink())
+      if (!lstatSync28(parent).isDirectory() || lstatSync28(parent).isSymbolicLink())
         throw new Error("Unsafe artifact directory");
     } catch (error61) {
       if (error61.code !== "ENOENT")
         throw error61;
-      mkdirSync24(parent, { mode: 448 });
+      mkdirSync25(parent, { mode: 448 });
     }
   }
 }
@@ -108232,7 +109111,7 @@ async function pollRemoteRun(client2, runId2, options) {
     const remaining = deadline - Date.now();
     if (remaining <= 0)
       break;
-    await new Promise((resolve22) => setTimeout(resolve22, Math.min(options.intervalMs, remaining)));
+    await new Promise((resolve23) => setTimeout(resolve23, Math.min(options.intervalMs, remaining)));
   }
   return {
     run: current ?? { id: runId2, status: "queued" },
@@ -108403,6 +109282,7 @@ var init_runtime = __esm(() => {
   init_remote_client();
   init_remote_account2();
   init_remote_files();
+  init_runtime_copyfile();
 });
 
 // src/cli/commands/customer-verification.ts
@@ -108424,7 +109304,7 @@ async function readCode() {
 function promptCode() {
   const { stdin, stderr: output2 } = process;
   const { isRaw: wasRaw, readableFlowing: wasFlowing } = stdin;
-  return new Promise((resolve22) => {
+  return new Promise((resolve23) => {
     let value = "", settled = false;
     const finish = (answer) => {
       if (settled)
@@ -108441,7 +109321,7 @@ function promptCode() {
 `);
       if (answer === null)
         process.exitCode = 130;
-      resolve22(answer);
+      resolve23(answer);
     };
     const cancel = () => finish(null);
     const keypress = (text4, key) => {
@@ -108486,7 +109366,7 @@ var exports_recurring = {};
 __export(exports_recurring, {
   registerRecurringCommands: () => registerRecurringCommands
 });
-import { constants as constants19, closeSync as closeSync22, fstatSync as fstatSync22, lstatSync as lstatSync28, openSync as openSync22, readSync as readSync16 } from "fs";
+import { constants as constants19, closeSync as closeSync22, fstatSync as fstatSync22, lstatSync as lstatSync29, openSync as openSync22, readSync as readSync16 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 function readRequest(path) {
   const fd = openSync22(path, constants19.O_RDONLY | constants19.O_NOFOLLOW | constants19.O_NONBLOCK);
@@ -108502,7 +109382,7 @@ function readRequest(path) {
         break;
       length += n2;
     }
-    const after2 = fstatSync22(fd), current = lstatSync28(path);
+    const after2 = fstatSync22(fd), current = lstatSync29(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)));
@@ -108513,10 +109393,10 @@ function readRequest(path) {
   }
 }
 async function acceptAtTerminal(draft) {
-  await new Promise((resolve22, reject2) => process.stderr.write(`${jsonText(draft)}
+  await new Promise((resolve23, reject2) => process.stderr.write(`${jsonText(draft)}
 This grants an additional recurring budget. Each occurrence reprices within the approved ceilings. Revocation prevents new authority; an already-authorized attempt may finish, and cancellation is separate.
-`, (error61) => error61 ? reject2(error61) : resolve22()));
-  return new Promise((resolve22) => {
+`, (error61) => error61 ? reject2(error61) : resolve23()));
+  return new Promise((resolve23) => {
     const rl = createInterface2({ input: process.stdin, output: process.stderr });
     let settled = false;
     const finish = (accepted) => {
@@ -108527,7 +109407,7 @@ This grants an additional recurring budget. Each occurrence reprices within the
       rl.close();
       if (!accepted)
         process.exitCode = 130;
-      resolve22(accepted);
+      resolve23(accepted);
     };
     const timer = setTimeout(() => finish(false), 5 * 60 * 1000);
     rl.once("SIGINT", () => finish(false));
@@ -108786,9 +109666,9 @@ var init_completion = __esm(() => {
 });
 
 // src/lib/portable-snapshot-filter.ts
-import { readdirSync as readdirSync20, statSync as statSync18 } from "fs";
+import { readdirSync as readdirSync21, statSync as statSync18 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join55, sep as sep9 } from "path";
+import { join as join56, sep as sep10 } from "path";
 function isExcludedSkillFileName(fileName) {
   if (EXCLUDE_FILE_NAMES.has(fileName)) {
     return true;
@@ -108811,27 +109691,27 @@ function isPortableWithinSkill(relativeParts) {
 function homePathFor(definition, homesRoot) {
   const home = homesRoot ?? homedir11();
   if (definition.subClass === "skills" || definition.subClass === "custom") {
-    return join55(skillsDataRootForHome(home), definition.name);
+    return join56(skillsDataRootForHome(home), definition.name);
   }
   if (definition.agent === "opencode") {
-    return join55(home, ".config", "opencode", "skills");
+    return join56(home, ".config", "opencode", "skills");
   }
-  return join55(home, `.${definition.agent}`, "skills");
+  return join56(home, `.${definition.agent}`, "skills");
 }
 function destinationFor(definition, stationId, relativePath) {
-  const category = definition.subClass === "agent-homes" ? join55("agent-homes", definition.agent ?? "") : definition.name;
-  return join55("resources", stationId, "skills", category, ...relativePath.split(sep9));
+  const category = definition.subClass === "agent-homes" ? join56("agent-homes", definition.agent ?? "") : definition.name;
+  return join56("resources", stationId, "skills", category, ...relativePath.split(sep10));
 }
 function walkEntries(absoluteRoot) {
   let entries;
   try {
-    entries = readdirSync20(absoluteRoot, { withFileTypes: true });
+    entries = readdirSync21(absoluteRoot, { withFileTypes: true });
   } catch {
     return [];
   }
   const output2 = [];
   for (const entry of entries) {
-    const childFull = join55(absoluteRoot, entry.name);
+    const childFull = join56(absoluteRoot, entry.name);
     if (entry.isSymbolicLink()) {
       output2.push({ kind: "symlink", relativePath: entry.name, fullPath: childFull });
       continue;
@@ -108842,7 +109722,7 @@ function walkEntries(absoluteRoot) {
       }
       const nested = walkEntries(childFull);
       for (const item of nested) {
-        output2.push({ ...item, relativePath: join55(entry.name, item.relativePath) });
+        output2.push({ ...item, relativePath: join56(entry.name, item.relativePath) });
       }
       continue;
     }
@@ -108935,22 +109815,22 @@ var init_portable_snapshot_filter = __esm(() => {
 });
 
 // src/lib/station-snapshot.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 import {
-  copyFileSync,
-  mkdirSync as mkdirSync25,
-  readFileSync as readFileSync38,
+  copyFileSync as copyFileSync2,
+  mkdirSync as mkdirSync26,
+  readFileSync as readFileSync39,
   statSync as statSync19,
-  writeFileSync as writeFileSync24
+  writeFileSync as writeFileSync25
 } from "fs";
-import { dirname as dirname30, isAbsolute as isAbsolute23, relative as relative8, resolve as resolve22, sep as sep10 } from "path";
+import { dirname as dirname31, isAbsolute as isAbsolute24, relative as relative9, resolve as resolve23, sep as sep11 } 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 createHash27("sha256").update(readFileSync38(filePath)).digest("hex");
+  return createHash28("sha256").update(readFileSync39(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -108958,7 +109838,7 @@ function scanHome(definition, homesRoot) {
   const portable = [];
   const skipped = [];
   for (const entry of entries) {
-    const relativeParts = entry.relativePath.split(sep10);
+    const relativeParts = entry.relativePath.split(sep11);
     const fileName = relativeParts[relativeParts.length - 1];
     if (entry.kind === "symlink") {
       skipped.push({ relativePath: entry.relativePath, reason: "symlink" });
@@ -109021,7 +109901,7 @@ function humanHomes(scanned) {
   }));
 }
 function writeStationSnapshot(options) {
-  const repoRoot = resolve22(options.repoRoot ?? process.cwd());
+  const repoRoot = resolve23(options.repoRoot ?? process.cwd());
   const { scanned, plans, totalBytes } = planStationSnapshot(options);
   const manifestFiles = plans.map((plan) => ({
     relativePath: plan.source.relativePath,
@@ -109047,9 +109927,9 @@ function writeStationSnapshot(options) {
   const conflicts = [];
   const untouched = [];
   for (const plan of plans) {
-    const destination = resolve22(repoRoot, plan.destination);
-    const destinationRelative = relative8(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep10) || isAbsolute23(destinationRelative)) {
+    const destination = resolve23(repoRoot, plan.destination);
+    const destinationRelative = relative9(repoRoot, destination);
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep11) || isAbsolute24(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -109070,9 +109950,9 @@ function writeStationSnapshot(options) {
   }
   let written = 0;
   for (const plan of untouched) {
-    const destination = resolve22(repoRoot, plan.destination);
-    mkdirSync25(dirname30(destination), { recursive: true });
-    copyFileSync(plan.source.fullPath, destination);
+    const destination = resolve23(repoRoot, plan.destination);
+    mkdirSync26(dirname31(destination), { recursive: true });
+    copyFileSync2(plan.source.fullPath, destination);
     written += 1;
   }
   const unchanged3 = plans.length - untouched.length;
@@ -109089,9 +109969,9 @@ function writeStationSnapshot(options) {
     },
     files: manifestFiles
   };
-  const manifestPath = resolve22(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync25(dirname30(manifestPath), { recursive: true });
-  writeFileSync24(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = resolve23(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
+  mkdirSync26(dirname31(manifestPath), { recursive: true });
+  writeFileSync25(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
     ...base3,
@@ -109122,8 +110002,8 @@ var exports_create_sync_config = {};
 __export(exports_create_sync_config, {
   registerCreateSync: () => registerCreateSync
 });
-import { existsSync as existsSync33 } from "fs";
-import { join as join56 } from "path";
+import { existsSync as existsSync34 } from "fs";
+import { join as join57 } from "path";
 function registerCreateSync(parent) {
   const configCmd = parent.command("config").description("Manage skills configuration");
   configCmd.command("show", { isDefault: true }).option("--json", "Output as JSON", false).description("Show current merged configuration").action((options) => {
@@ -109203,13 +110083,13 @@ function registerCreateSync(parent) {
     const pp = getConfigPath("project");
     if (options.json) {
       console.log(JSON.stringify({
-        global: { path: gp, exists: existsSync33(gp) },
-        project: { path: pp, exists: existsSync33(pp) }
+        global: { path: gp, exists: existsSync34(gp) },
+        project: { path: pp, exists: existsSync34(pp) }
       }, null, 2));
       return;
     }
-    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync33(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
-    console.log(`${source_default.cyan("project")}: ${pp}${existsSync33(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync34(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("project")}: ${pp}${existsSync34(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
   });
   parent.command("create").argument("<name>", "Skill name (e.g. my-tool)").option("--category <category>", "Skill category", "Development Tools").option("--description <description>", "Short description of what the skill does").option("--kind <kind>", "Skill class: executable or instruction", "executable").option("--tags <tags>", "Comma-separated tags (e.g. api,testing,automation)").option("--global", "Deprecated; custom skills are always global", false).option("--json", "Output result as JSON", false).description("Scaffold a new custom skill directory").action((name, options) => handleCreate(name, options));
   parent.command("sync").alias("render").option("--selection-profile <id>", "Consume the exact versions selected by an API profile").option("--profile <id>", "Selection profile (alias for --selection-profile; use before sync for credential profile)").option("--project", "Record exact selected versions in this project's lockfile", false).option("--no-station-report", "Verify and activate the selected profile without reporting station state").argument("[names...]", "Skills to sync (default: every skill in this machine's corpus)").option("--for <agent>", `Target one agent (${SYNC_AGENTS.join(", ")}, or all)`, "all").option("--all", "Sync every corpus skill (the default)", false).option("--source <path>", "Canonical corpus source: a directory of skill folders, or a package root with skills/ (overrides $SKILLS_SOURCE)").option("--dry-run", "Show what would be written without touching any agent folder", false).option("--force", "Adopt an unmanaged skill that already has SKILL.md; other unmarked directories are never overwritten", false).option("--check", "Home drift census (missing-from-home / stray-in-home / diverged); exits non-zero on drift, writes nothing", false).option("--adopt", "Unmarked-home adoption mode: hash unmarked home skills against the corpus; exact matches are marked (dry-run by default)", false).option("--prune", "Prune mode: list (or with --apply, remove) marked home skill dirs that have no canonical corpus entry", false).option("--apply", "Write adoption markers / conflicts ledger, or perform prune removals", false).option("--json", "Output as JSON", false).option("--station <id>", "Per-station snapshot mode: snapshot the installed skill homes into resources/<station>/skills with a v3 sync-manifest (dry-run by default; --populate writes)").option("--populate", "Write the per-station snapshot (station mode; the default is dry-run)", false).option("--repo-root <path>", "Station snapshot destination repo root (default: cwd)").option("--homes-root <dir>", "Build the station snapshot from a staged mirror of the skill homes instead of this machine's $HOME").description("Sync an API selection profile into the Skills cache; native migration flags remain available for older installations").action((names, options) => handleSync(names, options));
@@ -109233,7 +110113,7 @@ function handleCreate(name, options) {
       console.log(source_default.green(`\u2713 Created custom skill '${result2.name}' at ${result2.path}`));
       console.log(source_default.dim(`  Category: ${result2.manifest.category}`));
       console.log(source_default.dim(`  Tags: ${result2.manifest.tags?.join(", ")}`));
-      console.log(`  ${source_default.cyan("Edit:")} ${join56(result2.path, options.kind === "instruction" ? "SKILL.md" : "src/index.ts")}`);
+      console.log(`  ${source_default.cyan("Edit:")} ${join57(result2.path, options.kind === "instruction" ? "SKILL.md" : "src/index.ts")}`);
       console.log(`  ${source_default.cyan("Prepare:")} skills prepare ${result2.name} --version <new-semver>`);
     }
   } catch (error61) {
@@ -109569,14 +110449,14 @@ var init_codex_native_config = () => {};
 
 // src/lib/codex-hook-rpc.ts
 import { execFile, spawn as spawn3 } from "child_process";
-import { realpathSync as realpathSync12, statSync as statSync20 } from "fs";
-import { isAbsolute as isAbsolute24 } from "path";
+import { realpathSync as realpathSync13, statSync as statSync20 } from "fs";
+import { isAbsolute as isAbsolute25 } from "path";
 import { promisify } from "util";
 async function connectCodexHookRpc(options) {
-  const found = isAbsolute24(options.command) ? options.command : Bun.which(options.command, { PATH: process.env.PATH });
+  const found = isAbsolute25(options.command) ? options.command : Bun.which(options.command, { PATH: process.env.PATH });
   if (!found)
     throw new Error("CODEX_HOOK_TRUST_NATIVE_UNAVAILABLE: install Codex or pass --codex-command");
-  const binary = realpathSync12(found), stat3 = statSync20(binary);
+  const binary = realpathSync13(found), stat3 = statSync20(binary);
   if (!stat3.isFile() || (stat3.mode & 18) !== 0)
     throw new Error("CODEX_HOOK_TRUST_UNSAFE_EXECUTABLE");
   let version2;
@@ -109589,7 +110469,7 @@ async function connectCodexHookRpc(options) {
   if (!SUPPORTED_CODEX_HOOK_VERSIONS.includes(version2))
     throw new Error("CODEX_HOOK_TRUST_NATIVE_UNSUPPORTED_VERSION");
   const current = statSync20(binary);
-  if (realpathSync12(found) !== binary || ["dev", "ino", "size", "mtimeMs", "ctimeMs"].some((k) => stat3[k] !== current[k]))
+  if (realpathSync13(found) !== binary || ["dev", "ino", "size", "mtimeMs", "ctimeMs"].some((k) => stat3[k] !== current[k]))
     throw new Error("CODEX_HOOK_TRUST_NATIVE_EXECUTABLE_CHANGED");
   const env3 = { ...process.env, HOME: options.home, NO_COLOR: "1" };
   if (options.codexHome === undefined)
@@ -109664,13 +110544,13 @@ async function connectCodexHookRpc(options) {
     request(method2, params) {
       if (stopped)
         return Promise.reject(new Error("CODEX_HOOK_TRUST_NATIVE_RPC_CLOSED"));
-      return new Promise((resolve23, reject2) => {
+      return new Promise((resolve24, reject2) => {
         const id2 = nextId++;
         const timer = setTimeout(() => {
           fail5();
           child.kill();
         }, 20000);
-        pending.set(id2, { resolve: resolve23, reject: reject2, timer });
+        pending.set(id2, { resolve: resolve24, reject: reject2, timer });
         child.stdin.write(JSON.stringify({ id: id2, method: method2, params }) + `
 `);
       });
@@ -109680,14 +110560,14 @@ async function connectCodexHookRpc(options) {
       child.stdin.end();
       if (child.exitCode !== null || child.signalCode !== null)
         return;
-      await new Promise((resolve23) => {
+      await new Promise((resolve24) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve23();
+          resolve24();
         }, 1000);
         child.once("exit", () => {
           clearTimeout(timer);
-          resolve23();
+          resolve24();
         });
       });
     }
@@ -109708,21 +110588,21 @@ var init_codex_hook_rpc = __esm(() => {
 });
 
 // src/lib/codex-hook-trust-identity.ts
-import { realpathSync as realpathSync13 } from "fs";
-import { dirname as dirname31, isAbsolute as isAbsolute25, join as join57 } from "path";
+import { realpathSync as realpathSync14 } from "fs";
+import { dirname as dirname32, isAbsolute as isAbsolute26, join as join58 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual11 } from "util";
 function inspectRecordedSkillsCli(command, expected) {
-  need4(isAbsolute25(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
-  const resolved = realpathSync13(command);
+  need4(isAbsolute26(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
+  const resolved = realpathSync14(command);
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
-  const manifest = snapshot(join57(dirname31(dirname31(resolved)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join58(dirname32(dirname32(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
-  need4(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join57(dirname31(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
+  need4(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join58(dirname32(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   need4((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
   const receipt = { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 };
   need4(isDeepStrictEqual11(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
   return { receipt, recheck() {
-    need4(realpathSync13(command) === resolved, "SKILLS_COMMAND_CHANGED");
+    need4(realpathSync14(command) === resolved, "SKILLS_COMMAND_CHANGED");
     unchanged2(cli);
     unchanged2(manifest);
   } };
@@ -109730,22 +110610,22 @@ function inspectRecordedSkillsCli(command, expected) {
 function bindSkillsCli(command, reviewed) {
   const normal = Bun.which("skills", { PATH: process.env.PATH });
   need4(normal, "SKILLS_COMMAND_UNAVAILABLE");
-  const resolved = realpathSync13(normal);
-  const bound = isAbsolute25(command) ? command : command === "skills" ? normal : undefined;
-  need4(bound && realpathSync13(bound) === resolved, "SKILLS_COMMAND_MISMATCH");
+  const resolved = realpathSync14(normal);
+  const bound = isAbsolute26(command) ? command : command === "skills" ? normal : undefined;
+  need4(bound && realpathSync14(bound) === resolved, "SKILLS_COMMAND_MISMATCH");
   const entrypoint = reviewed?.path ?? process.argv[1];
-  need4(entrypoint && realpathSync13(entrypoint) === resolved, "SKILLS_ENTRYPOINT_MISMATCH");
+  need4(entrypoint && realpathSync14(entrypoint) === resolved, "SKILLS_ENTRYPOINT_MISMATCH");
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
-  const manifest = snapshot(join57(dirname31(dirname31(resolved)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join58(dirname32(dirname32(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
-  need4(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join57(dirname31(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
+  need4(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join58(dirname32(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   if (reviewed)
     need4(/^[a-f0-9]{64}$/.test(reviewed.sha256) && reviewed.sha256 === cli.sha256 && reviewed.version === pkg.version, "SKILLS_RELEASE_MISMATCH");
   need4((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
   return {
     receipt: { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 },
     recheck() {
-      need4(Bun.which("skills", { PATH: process.env.PATH }) === normal && realpathSync13(normal) === resolved && realpathSync13(bound) === resolved && realpathSync13(entrypoint) === resolved, "SKILLS_COMMAND_CHANGED");
+      need4(Bun.which("skills", { PATH: process.env.PATH }) === normal && realpathSync14(normal) === resolved && realpathSync14(bound) === resolved && realpathSync14(entrypoint) === resolved, "SKILLS_COMMAND_CHANGED");
       unchanged2(cli);
       unchanged2(manifest);
     }
@@ -109779,23 +110659,23 @@ var init_codex_hook_policy_recovery = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync29, mkdirSync as mkdirSync26, readdirSync as readdirSync21, readFileSync as readFileSync39, realpathSync as realpathSync14, statSync as statSync21 } from "fs";
-import { createHash as createHash28, randomUUID as randomUUID10 } from "crypto";
+import { lstatSync as lstatSync30, mkdirSync as mkdirSync27, readdirSync as readdirSync22, readFileSync as readFileSync40, realpathSync as realpathSync15, statSync as statSync21 } from "fs";
+import { createHash as createHash29, randomUUID as randomUUID11 } from "crypto";
 import { execFileSync } from "child_process";
-import { dirname as dirname32, isAbsolute as isAbsolute26, join as join58, resolve as resolve23 } from "path";
+import { dirname as dirname33, isAbsolute as isAbsolute27, join as join59, resolve as resolve24 } from "path";
 import { homedir as homedir12 } from "os";
 import { isDeepStrictEqual as isDeepStrictEqual13 } from "util";
 function verifyReleaseArtifact(proof, skillsCli) {
-  need4(isAbsolute26(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
-  const tarPath = realpathSync14(proof.packageTarPath);
+  need4(isAbsolute27(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
+  const tarPath = realpathSync15(proof.packageTarPath);
   need4(statSync21(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
-  const tarBytes = readFileSync39(tarPath);
-  need4(tarBytes.byteLength === proof.packageTarBytes && createHash28("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
-  const packageRoot = dirname32(dirname32(realpathSync14(skillsCli.receipt.path)));
-  const manifest = readFileSync39(join58(packageRoot, "package.json"));
-  need4(createHash28("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
-  need4(createHash28("sha256").update(readFileSync39(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", readFileSync39(skillsCli.receipt.path)]];
+  const tarBytes = readFileSync40(tarPath);
+  need4(tarBytes.byteLength === proof.packageTarBytes && createHash29("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
+  const packageRoot = dirname33(dirname33(realpathSync15(skillsCli.receipt.path)));
+  const manifest = readFileSync40(join59(packageRoot, "package.json"));
+  need4(createHash29("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
+  need4(createHash29("sha256").update(readFileSync40(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", readFileSync40(skillsCli.receipt.path)]];
   for (const [member, expected] of members2) {
     let actual;
     try {
@@ -109809,26 +110689,26 @@ function verifyReleaseArtifact(proof, skillsCli) {
 async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc) {
   let rpc;
   try {
-    const home = resolve23(options.home ?? homedir12()), dataDir3 = resolve23(options.dataDir ?? getDataDirReadOnly());
-    const parent = resolve23(join58(dataDir3, "native-hook-trust")), journal = resolve23(options.journal);
+    const home = resolve24(options.home ?? homedir12()), dataDir3 = resolve24(options.dataDir ?? getDataDirReadOnly());
+    const parent = resolve24(join59(dataDir3, "native-hook-trust")), journal = resolve24(options.journal);
     need4(journal.startsWith(parent + "/") && /^[a-f0-9-]{36}$/.test(journal.slice(parent.length + 1)), "RECONCILE_JOURNAL_PATH");
-    const dir = lstatSync29(journal, { throwIfNoEntry: false });
+    const dir = lstatSync30(journal, { throwIfNoEntry: false });
     need4(!!dir && dir.isDirectory() && !dir.isSymbolicLink() && dir.uid === process.getuid() && (dir.mode & 511) === 448, "UNSAFE_JOURNAL");
-    need4(!lstatSync29(join58(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
-    need4(lstatSync29(join58(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
-    const stoppedFile = snapshot(join58(journal, "stopped.json"), true);
-    const intentFile = snapshot(join58(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
-    const configBefore = snapshot(join58(journal, "config.before.toml"), true), hooksBefore = snapshot(join58(journal, "hooks.before.json"), true), policyBefore = snapshot(join58(journal, "policy.before.json"), true);
+    need4(!lstatSync30(join59(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
+    need4(lstatSync30(join59(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
+    const stoppedFile = snapshot(join59(journal, "stopped.json"), true);
+    const intentFile = snapshot(join59(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
+    const configBefore = snapshot(join59(journal, "config.before.toml"), true), hooksBefore = snapshot(join59(journal, "hooks.before.json"), true), policyBefore = snapshot(join59(journal, "policy.before.json"), true);
     const legacyIntent = intent.home === undefined && intent.configSha256 === undefined && intent.configVersion === undefined && intent.declarations === undefined && intent.admitted === undefined && intent.nativeHooks === undefined;
     need4(intent.version === 1 && /^[a-f0-9]{64}$/.test(intent.planDigest) && typeof intent.configPath === "string" && /^[a-f0-9]{64}$/.test(intent.policySha256) && /^[a-f0-9]{64}$/.test(intent.hooksSha256) && Array.isArray(intent.hooks) && intent.hooks.length > 0 && intent.hooks.length <= 100 && (legacyIntent || typeof intent.home === "string" && intent.home === home && /^[a-f0-9]{64}$/.test(intent.configSha256) && typeof intent.configVersion === "string" && Array.isArray(intent.declarations) && Array.isArray(intent.admitted) && Array.isArray(intent.nativeHooks)), "RECONCILE_INTENT_INVALID");
-    const declarations = intent.declarations ?? intent.hooks.map((hook) => ({ event: hook.event, key: `${join58(home, ".codex/hooks.json")}${hook.key.slice(hook.key.indexOf(".codex/hooks.json") + ".codex/hooks.json".length)}`, command: hook.command }));
+    const declarations = intent.declarations ?? intent.hooks.map((hook) => ({ event: hook.event, key: `${join59(home, ".codex/hooks.json")}${hook.key.slice(hook.key.indexOf(".codex/hooks.json") + ".codex/hooks.json".length)}`, command: hook.command }));
     const admitted = intent.admitted ?? intent.hooks;
     const configSha256 = intent.configSha256 ?? configBefore.sha256, configVersion = intent.configVersion ?? intent.expectedVersion;
     const digestInput = { version: 1, home: intent.home ?? home, configPath: intent.configPath, ...intent.nativeConfigPath !== undefined ? { nativeConfigPath: intent.nativeConfigPath } : {}, configSha256, configVersion, policySha256: intent.policySha256, hooksSha256: intent.hooksSha256, skillsCli: intent.skillsCli, nativeVersion: intent.nativeVersion, declarations, admitted };
     need4(makePlanDigest(digestInput) === intent.planDigest, "RECONCILE_PLAN_CHANGED");
     need4(isDeepStrictEqual13(intent.hooks, admitted.filter((hook) => !hook.enabled || hook.trustStatus !== "trusted")), "RECONCILE_INTENT_HOOKS_CHANGED");
     need4(configBefore.sha256 === (intent.beforeSha256 ?? intent.configSha256) && hooksBefore.sha256 === intent.hooksSha256 && policyBefore.sha256 === intent.policySha256, "RECONCILE_JOURNAL_CHANGED");
-    const policyCurrent = snapshot(join58(dataDir3, "agent-policy.json"), true);
+    const policyCurrent = snapshot(join59(dataDir3, "agent-policy.json"), true);
     const { claudeDiscoveryRecovery: claudeRecovery, nativeHookAdditionsRecovery: additionsRecovery } = options;
     const recovery = claudeRecovery ?? additionsRecovery;
     need4(!recovery || !options.supersedeBinding, "RECONCILE_RECOVERY_MODE_CONFLICT");
@@ -109845,17 +110725,17 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     if (supersededBinding || recovery) {
       need4(Array.isArray(intent.nativeHooks) && intent.nativeHooks.length > 0, "RECONCILE_NATIVE_INVENTORY_REQUIRED");
       const proof = options.releaseProof;
-      need4(!!proof && isAbsolute26(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");
+      need4(!!proof && isAbsolute27(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;
-    const alias = binding.rootAliases?.find((item) => item.agent === "codex"), physicalRoot = alias?.target ?? join58(home, ".codex"), hooksPath = join58(physicalRoot, "hooks.json");
-    need4(resolve23(intent.configPath) === resolve23(join58(physicalRoot, "config.toml")), "RECONCILE_CONFIG_PATH_CHANGED");
+    const alias = binding.rootAliases?.find((item) => item.agent === "codex"), physicalRoot = alias?.target ?? join59(home, ".codex"), hooksPath = join59(physicalRoot, "hooks.json");
+    need4(resolve24(intent.configPath) === resolve24(join59(physicalRoot, "config.toml")), "RECONCILE_CONFIG_PATH_CHANGED");
     const nativeConfigPath = intent.nativeConfigPath ?? intent.configPath;
-    need4([join58(home, ".codex/config.toml"), join58(physicalRoot, "config.toml")].includes(nativeConfigPath), "RECONCILE_NATIVE_CONFIG_PATH_CHANGED");
-    const codexHome = nativeConfigPath !== intent.configPath ? undefined : dirname32(nativeConfigPath);
+    need4([join59(home, ".codex/config.toml"), join59(physicalRoot, "config.toml")].includes(nativeConfigPath), "RECONCILE_NATIVE_CONFIG_PATH_CHANGED");
+    const codexHome = nativeConfigPath !== intent.configPath ? undefined : dirname33(nativeConfigPath);
     const hooksCurrent = snapshot(hooksPath);
-    const additions = additionsRecovery ? reviewNativeHookAdditions({ path: additionsRecovery.path, intent: intentFile, policy: policyCurrent, configBefore, configCurrent: currentConfig, hooksBefore, hooksCurrent, nativeHooksPath: join58(dirname32(nativeConfigPath), "hooks.json"), journalHooks: intent.hooks, recordedNativeHooks: intent.nativeHooks }) : undefined;
+    const additions = additionsRecovery ? reviewNativeHookAdditions({ path: additionsRecovery.path, intent: intentFile, policy: policyCurrent, configBefore, configCurrent: currentConfig, hooksBefore, hooksCurrent, nativeHooksPath: join59(dirname33(nativeConfigPath), "hooks.json"), journalHooks: intent.hooks, recordedNativeHooks: intent.nativeHooks }) : undefined;
     const managedHooks = [...intent.hooks, ...additions?.hooks ?? []];
     const managedKeys = managedHooks.map((h) => h.key);
     const witnessSame = codexTrustReconcileWitness(configBefore.text, managedKeys) === codexTrustReconcileWitness(currentConfig.text, managedKeys);
@@ -109919,7 +110799,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
         need4(isDeepStrictEqual13(actual, expected), "RECONCILE_UNRELATED_HOOK_CHANGED");
     }
     for (const wanted of intent.hooks) {
-      const matches2 = nativeHooks.filter((h2) => h2.key === wanted.key || h2.key === wanted.key.replace(join58(home, ".codex/hooks.json"), hooksPath));
+      const matches2 = nativeHooks.filter((h2) => h2.key === wanted.key || h2.key === wanted.key.replace(join59(home, ".codex/hooks.json"), hooksPath));
       need4(matches2.length === 1, "RECONCILE_NATIVE_IDENTITY_CHANGED");
       const h = matches2[0];
       const trusted = h.trustStatus === "trusted";
@@ -109968,7 +110848,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const receipt = { version: 1, status: preview2 ? "recovery-review-required" : supersededBinding ? "superseded" : "reconciled", reconciled: !preview2, supersededBinding, automaticRollback: false, journal, planDigest: intent.planDigest, nativeVersion: rpc.version, nativeStateVerified: !nativeTrustPending, nativeTrustPending, bindingRefreshRequired: !!configDiscoveryRecovery, nativeExecutionVerified: false, configSha256: currentConfig.sha256, hooksSha256: hooksCurrent.sha256, policySha256: policyBefore.sha256, policyBeforeSha256: policyBefore.sha256, policyCurrentSha256: policyCurrent.sha256, previousSkillsCli: intent.skillsCli, skillsCli: skillsCli.receipt, releaseProof: options.releaseProof, nativeInventoryScope: recordedNativeHooks ? "complete" : "declared-managed-hooks-only", unrelatedNativeHooksPreserved: !!recordedNativeHooks, unrelatedSettingsAndCommentsPreserved: true, ...recoveryPlan ? { recoveryPlan, recoveryPlanDigest } : {} };
     if (preview2)
       return receipt;
-    save(join58(journal, "receipt.json"), json2(receipt));
+    save(join59(journal, "receipt.json"), json2(receipt));
     return receipt;
   } catch (error61) {
     const message = error61 instanceof Error && error61.message.startsWith("CODEX_HOOK_TRUST_") ? error61.message : "CODEX_HOOK_TRUST_RECONCILE_REFUSED";
@@ -109980,15 +110860,15 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
 async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRpc) {
   let rpc, journal;
   try {
-    const home = resolve23(options.home ?? homedir12()), dataDir3 = resolve23(options.dataDir ?? getDataDirReadOnly());
+    const home = resolve24(options.home ?? homedir12()), dataDir3 = resolve24(options.dataDir ?? getDataDirReadOnly());
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
-    const policyFile = snapshot(join58(dataDir3, "agent-policy.json"), true), policy = parseManagedSkillPolicy(policyFile.text);
+    const policyFile = snapshot(join59(dataDir3, "agent-policy.json"), true), policy = parseManagedSkillPolicy(policyFile.text);
     const binding = policy.bridge, alias = binding.rootAliases?.find((item) => item.agent === "codex");
     const skillsCli = bindSkillsCli(binding.commands.codex, options.reviewedSkillsCli);
-    const physicalRoot = alias?.target ?? join58(home, ".codex"), hooksPath = join58(physicalRoot, "hooks.json"), configPath = join58(physicalRoot, "config.toml");
-    need4(options.codexHome === undefined || isAbsolute26(options.codexHome) && [join58(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
+    const physicalRoot = alias?.target ?? join59(home, ".codex"), hooksPath = join59(physicalRoot, "hooks.json"), configPath = join59(physicalRoot, "config.toml");
+    need4(options.codexHome === undefined || isAbsolute27(options.codexHome) && [join59(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
     const codexHome = options.codexHome === undefined ? undefined : physicalRoot;
-    const nativeConfigPath = join58(codexHome ?? join58(home, ".codex"), "config.toml");
+    const nativeConfigPath = join59(codexHome ?? join59(home, ".codex"), "config.toml");
     const hooksFile = snapshot(hooksPath), configFile = snapshot(configPath, true), original = structure3(configFile.text);
     const declarations = JSON.parse(hooksFile.text).hooks, expected = [];
     for (const [event, [nativeEvent, label]] of Object.entries(eventNames)) {
@@ -109997,25 +110877,25 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
       need4(Array.isArray(groups), "DECLARATION_CHANGED");
       const matches2 = groups.flatMap((group, gi) => (group.hooks ?? []).flatMap((entry, hi) => entry.command === command ? [{ group, entry, gi, hi }] : []));
       need4(matches2.length === 1 && isDeepStrictEqual13(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
-      expected.push({ event: nativeEvent, key: `${join58(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
+      expected.push({ event: nativeEvent, key: `${join59(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
     }
     codexTrustTextWitness(configFile.text, expected.map((h) => h.key));
     rpc = await connect({ command: options.codexCommand ?? "codex", home, codexHome });
     need4(SUPPORTED_CODEX_HOOK_VERSIONS.includes(rpc.version), "NATIVE_UNSUPPORTED_VERSION");
     const list2 = async () => {
       const response = await rpc.request("hooks/list", { cwds: [home] });
-      const nativeRoots = [...new Set([physicalRoot, join58(home, ".codex")])];
-      const coexistenceWarnings = nativeRoots.flatMap((hooksRoot) => nativeRoots.map((configRoot) => `loading hooks from both ${join58(hooksRoot, "hooks.json")} and ${join58(configRoot, "config.toml")}; prefer a single representation for this layer`));
+      const nativeRoots = [...new Set([physicalRoot, join59(home, ".codex")])];
+      const coexistenceWarnings = nativeRoots.flatMap((hooksRoot) => nativeRoots.map((configRoot) => `loading hooks from both ${join59(hooksRoot, "hooks.json")} and ${join59(configRoot, "config.toml")}; prefer a single representation for this layer`));
       const entry = response?.data?.[0];
       need4(Array.isArray(response?.data) && response.data.length === 1 && entry.cwd === home && Array.isArray(entry.hooks) && entry.hooks.length <= 1e4 && Array.isArray(entry.errors) && entry.errors.length === 0 && Array.isArray(entry.warnings) && entry.warnings.length <= 1 && entry.warnings.every((warning) => typeof warning === "string" && coexistenceWarnings.includes(warning)), "NATIVE_DISCOVERY_REFUSED");
       return response.data[0].hooks;
     };
     const admit = (hooks) => expected.map((wanted) => {
-      const canonicalKey = wanted.key.replace(join58(home, ".codex/hooks.json"), hooksPath);
+      const canonicalKey = wanted.key.replace(join59(home, ".codex/hooks.json"), hooksPath);
       const matches2 = hooks.filter((h2) => h2.key === wanted.key || h2.key === canonicalKey);
       need4(matches2.length === 1, "AMBIGUOUS_IDENTITY");
       const h = matches2[0];
-      need4(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join58(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
+      need4(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join59(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
       need4(hooks.filter((other) => other.command === wanted.command).length === 1, "AMBIGUOUS_IDENTITY");
       need4(["trusted", "untrusted", "modified"].includes(h.trustStatus), "UNKNOWN_TRUST_STATUS");
       return { key: h.key, event: wanted.event, command: wanted.command, handlerType: h.handlerType, timeoutSec: h.timeoutSec, sourcePath: h.sourcePath, currentHash: h.currentHash, enabled: h.enabled, trustStatus: h.trustStatus };
@@ -110041,27 +110921,27 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     const baseReceipt = { planDigest, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, nativeConfigPath, ownedNativeProcessId: rpc.processId, agent: "codex", applied: false, planned, nativeEligible: planned.length === 0, bindingRefreshRequired: false, transport: "owned-stdio-process", existingSessionsReloaded: false, nativeExecutionVerified: false };
     if (options.apply)
       need4(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
-    const parent = join58(dataDir3, "native-hook-trust");
-    const st = lstatSync29(parent, { throwIfNoEntry: false });
+    const parent = join59(dataDir3, "native-hook-trust");
+    const st = lstatSync30(parent, { throwIfNoEntry: false });
     if (st) {
       need4(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
-      const priorJournals = readdirSync21(parent);
+      const priorJournals = readdirSync22(parent);
       need4(priorJournals.length < 1000, "JOURNAL_BOUND");
       for (const name of priorJournals) {
         need4(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
-        need4(lstatSync29(join58(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
+        need4(lstatSync30(join59(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
       }
     }
     if (!options.apply || !planned.length)
       return baseReceipt;
     if (!st)
-      mkdirSync26(parent, { mode: 448 });
-    journal = join58(parent, randomUUID10());
-    mkdirSync26(journal, { mode: 448 });
-    save(join58(journal, "config.before.toml"), configFile.bytes);
-    save(join58(journal, "hooks.before.json"), hooksFile.bytes);
-    save(join58(journal, "policy.before.json"), policyFile.bytes);
-    save(join58(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook) }));
+      mkdirSync27(parent, { mode: 448 });
+    journal = join59(parent, randomUUID11());
+    mkdirSync27(journal, { mode: 448 });
+    save(join59(journal, "config.before.toml"), configFile.bytes);
+    save(join59(journal, "hooks.before.json"), hooksFile.bytes);
+    save(join59(journal, "policy.before.json"), policyFile.bytes);
+    save(join59(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook) }));
     need4(isDeepStrictEqual13(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
     checkInputs();
     let result2;
@@ -110077,7 +110957,7 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     for (const h of planned)
       expectedConfig.hooks.state[h.key] = { ...expectedConfig.hooks.state[h.key], enabled: true, trusted_hash: h.currentHash };
     need4(isDeepStrictEqual13(structure3(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys3) === preservationText, "PRESERVATION_FAILED");
-    const savedConfig = snapshot(join58(journal, "config.before.toml"), true);
+    const savedConfig = snapshot(join59(journal, "config.before.toml"), true);
     need4(savedConfig.sha256 === configFile.sha256, "JOURNAL_CHANGED");
     const discoveryTransition = binding.discovery?.codex ? createCodexHookDiscoveryRecovery(binding.discovery.codex, savedConfig, after2, planned) : undefined;
     unchanged2(policyFile);
@@ -110093,13 +110973,13 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     skillsCli.recheck();
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: discoveryTransition });
     const receipt = { ...baseReceipt, applied: true, nativeEligible: true, bindingRefreshRequired: !!discoveryTransition, ...discoveryTransition ? { discoveryTransition } : {}, nativeConfigVersion: result2.version, journal, beforeSha256: configFile.sha256, afterSha256: after2.sha256, unrelatedSettingsAndCommentsPreserved: true };
-    save(join58(journal, "receipt.json"), json2(receipt));
+    save(join59(journal, "receipt.json"), json2(receipt));
     return receipt;
   } catch (error61) {
     const message = error61 instanceof Error && error61.message.startsWith("CODEX_HOOK_TRUST_") ? error61.message : "CODEX_HOOK_TRUST_REFUSED: verify managed bridge installation and native Codex support";
     if (journal) {
       try {
-        save(join58(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true }));
+        save(join59(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true }));
       } catch {}
     }
     throw new Error(message);
@@ -110108,7 +110988,7 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
   }
 }
 var json2 = (value) => JSON.stringify(value, null, 2) + `
-`, structure3 = (text4) => JSON.parse(JSON.stringify(Bun.TOML.parse(text4))), eventNames, makePlanDigest = (value) => createHash28("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) => createHash29("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>";
@@ -110219,8 +111099,8 @@ var exports_agent_integration = {};
 __export(exports_agent_integration, {
   registerAgentIntegration: () => registerAgentIntegration
 });
-import { readFileSync as readFileSync40 } from "fs";
-import { isAbsolute as isAbsolute27 } from "path";
+import { readFileSync as readFileSync41 } from "fs";
+import { isAbsolute as isAbsolute28 } from "path";
 function pinnedHookProfile(input3, configuredProfile) {
   try {
     const parsed = parseSkillContextInput(JSON.stringify(input3));
@@ -110297,7 +111177,7 @@ 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("--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(readFileSync40(options.discoveryInputs, "utf8")) : undefined;
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync41(options.discoveryInputs, "utf8")) : undefined;
       const plan = planAgentIntegration({ agents: agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases });
       const result2 = options.apply ? applyAgentIntegration(plan) : { changed: [], backups: [] };
       const receipt = { 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) };
@@ -110355,7 +111235,7 @@ function registerAgentIntegration(parent) {
     try {
       if (agents(options.agent).length !== 1)
         throw new Error("A hook invocation requires one agent");
-      const inputText = readFileSync40(0, "utf8");
+      const inputText = readFileSync41(0, "utf8");
       if (inputText.length > 1024 * 1024)
         throw new Error("Hook input is too large");
       let input3 = JSON.parse(inputText);
@@ -110368,12 +111248,12 @@ function registerAgentIntegration(parent) {
       input3.hook_event_name = event;
       const projects = [process.cwd()];
       if (input3.cwd !== undefined) {
-        if (typeof input3.cwd !== "string" || !isAbsolute27(input3.cwd) || input3.cwd.includes("\x00"))
+        if (typeof input3.cwd !== "string" || !isAbsolute28(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" || !isAbsolute27(path) || path.includes("\x00")))
+        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute28(path) || path.includes("\x00")))
           throw new Error("Invalid Cursor workspace roots");
         projects.push(...input3.workspace_roots);
         input3.cwd ??= input3.workspace_roots[0] ?? process.cwd();
@@ -110453,7 +111333,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(readFileSync40(options.discoveryInputs, "utf8")) : undefined;
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync41(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;
@@ -110623,7 +111503,7 @@ var exports_profiles = {};
 __export(exports_profiles, {
   registerProfiles: () => registerProfiles
 });
-import { closeSync as closeSync23, constants as constants20, fstatSync as fstatSync23, openSync as openSync23, readSync as readSync17, writeFileSync as writeFileSync25 } from "fs";
+import { closeSync as closeSync23, constants as constants20, fstatSync as fstatSync23, openSync as openSync23, readSync as readSync17, writeFileSync as writeFileSync26 } from "fs";
 function readProfileInput(path) {
   const fd = openSync23(path, constants20.O_RDONLY | constants20.O_NONBLOCK);
   try {
@@ -110651,7 +111531,7 @@ function registerProfiles(parent) {
     try {
       const profile = await readSkillProfile(id3), text4 = JSON.stringify(profile, null, 2);
       if (options.save)
-        writeFileSync25(options.save, JSON.stringify(profile), { mode: 384, flag: "wx" });
+        writeFileSync26(options.save, JSON.stringify(profile), { mode: 384, flag: "wx" });
       await writeCliOutput(options.json ? text4 : `${profile.id} at ${profile.revision}: ${profile.selections.map((skill) => `${skill.slug}@${skill.version}`).join(", ")}`);
     } catch (error61) {
       console.error(error61.message);
@@ -110698,7 +111578,7 @@ import {
   fstatSync as fstatSync24,
   openSync as openSync24,
   readSync as readSync18,
-  writeFileSync as writeFileSync26
+  writeFileSync as writeFileSync27
 } from "fs";
 function readInput(path) {
   const fd = openSync24(path, constants21.O_RDONLY | constants21.O_NONBLOCK);
@@ -110731,7 +111611,7 @@ function registerGrants(parent) {
     try {
       const policy = await readExecutionGrantPolicy(profile, options.revision);
       if (options.save)
-        writeFileSync26(options.save, JSON.stringify(policy, null, 2), {
+        writeFileSync27(options.save, JSON.stringify(policy, null, 2), {
           mode: 384,
           flag: "wx"
         });
@@ -110758,28 +111638,28 @@ var init_grants = __esm(() => {
 });
 
 // src/lib/station-hydrate.ts
-import { createHash as createHash29 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 import {
-  copyFileSync as copyFileSync2,
-  mkdirSync as mkdirSync27,
-  readdirSync as readdirSync22,
-  readFileSync as readFileSync41,
+  copyFileSync as copyFileSync3,
+  mkdirSync as mkdirSync28,
+  readdirSync as readdirSync23,
+  readFileSync as readFileSync42,
   statSync as statSync22,
-  writeFileSync as writeFileSync27
+  writeFileSync as writeFileSync28
 } from "fs";
-import { dirname as dirname33, join as join59, resolve as resolve24, sep as sep11 } from "path";
+import { dirname as dirname34, join as join60, resolve as resolve25, sep as sep12 } from "path";
 function fail5(code2, message, detail = []) {
   throw new StationSnapshotError(code2, message, detail);
 }
 function snapshotRootFor(repoRoot, stationId) {
-  return join59(repoRoot, "resources", stationId, "skills");
+  return join60(repoRoot, "resources", stationId, "skills");
 }
 function readSnapshotManifest(repoRoot, stationId) {
   const snapshotRoot = snapshotRootFor(repoRoot, stationId);
-  const manifestPath = join59(snapshotRoot, "sync-manifest.json");
+  const manifestPath = join60(snapshotRoot, "sync-manifest.json");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync41(manifestPath, "utf8"));
+    manifest = JSON.parse(readFileSync42(manifestPath, "utf8"));
   } catch (error61) {
     fail5("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error61.message}`);
   }
@@ -110803,10 +111683,10 @@ function planStationHydration(stationId, repoRoot) {
   const hashMismatches = [];
   const skippedByRule = [];
   for (const agent of SYNC_AGENTS) {
-    const agentRoot = join59(snapshotRoot, "agent-homes", agent);
+    const agentRoot = join60(snapshotRoot, "agent-homes", agent);
     let identEntries;
     try {
-      identEntries = readdirSync22(agentRoot, { withFileTypes: true });
+      identEntries = readdirSync23(agentRoot, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -110814,10 +111694,10 @@ function planStationHydration(stationId, repoRoot) {
       if (!identEntry.isDirectory() || identEntry.name.startsWith(".")) {
         continue;
       }
-      const identRoot = join59(agentRoot, identEntry.name);
+      const identRoot = join60(agentRoot, identEntry.name);
       const entries = walkEntries(identRoot);
       for (const entry of entries) {
-        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep11)];
+        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep12)];
         if (entry.kind === "symlink") {
           symlinks.push({ ident: identEntry.name, agent, relativePath: entry.relativePath });
           continue;
@@ -110841,8 +111721,8 @@ function planStationHydration(stationId, repoRoot) {
           });
           continue;
         }
-        const withinIdent = relativeParts.slice(1).join(sep11);
-        const homeRelative = relativeParts.join(sep11);
+        const withinIdent = relativeParts.slice(1).join(sep12);
+        const homeRelative = relativeParts.join(sep12);
         if (REFUSED_SCANNER_FLAGGED.has(homeRelative)) {
           skippedByRule.push({
             ident: identEntry.name,
@@ -110915,7 +111795,7 @@ function planStationHydration(stationId, repoRoot) {
         for (const copy of copies) {
           let isStub = false;
           try {
-            isStub = isPointerSkillMd(readFileSync41(copy.fullPath, "utf8"));
+            isStub = isPointerSkillMd(readFileSync42(copy.fullPath, "utf8"));
           } catch {
             isStub = false;
           }
@@ -110961,12 +111841,12 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash29("sha256").update(joined.sort().join(`
+  return createHash30("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
-  const repoRoot = resolve24(options.repoRoot ?? process.cwd());
-  const cacheRoot = resolve24(options.cacheRoot ?? resolveCorpusRoot());
+  const repoRoot = resolve25(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve25(options.cacheRoot ?? resolveCorpusRoot());
   const plan = planStationHydration(options.stationId, repoRoot);
   const resultSkills = plan.winners.map((skill) => ({
     ident: skill.ident,
@@ -110999,7 +111879,7 @@ function writeStationHydration(options) {
   const toWrite = [];
   for (const skill of plan.winners) {
     for (const file2 of skill.files) {
-      const destination = join59(cacheRoot, skill.ident, file2.withinIdent);
+      const destination = join60(cacheRoot, skill.ident, file2.withinIdent);
       const digest4 = sha256File(file2.winner.fullPath);
       let existingDigest = null;
       try {
@@ -111020,8 +111900,8 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync27(dirname33(entry.destination), { recursive: true });
-    copyFileSync2(entry.fullPath, entry.destination);
+    mkdirSync28(dirname34(entry.destination), { recursive: true });
+    copyFileSync3(entry.fullPath, entry.destination);
     written += 1;
   }
   const unchanged3 = plan.totalFiles - written;
@@ -111041,9 +111921,9 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join59(dirname33(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync27(dirname33(hydrationManifestPath), { recursive: true });
-  writeFileSync27(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
+  const hydrationManifestPath = join60(dirname34(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync28(dirname34(hydrationManifestPath), { recursive: true });
+  writeFileSync28(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
     ...base3,
@@ -111118,15 +111998,15 @@ var init_hydrate = __esm(() => {
 });
 
 // src/lib/prepare-skill.ts
-import { createHash as createHash30, randomUUID as randomUUID11 } from "crypto";
-import { chmodSync as chmodSync4, existsSync as existsSync34, lstatSync as lstatSync30, mkdirSync as mkdirSync28, mkdtempSync as mkdtempSync6, readFileSync as readFileSync42, readdirSync as readdirSync23, renameSync as renameSync13, rmSync as rmSync9, writeFileSync as writeFileSync28 } from "fs";
+import { createHash as createHash31, randomUUID as randomUUID12 } from "crypto";
+import { chmodSync as chmodSync5, existsSync as existsSync35, lstatSync as lstatSync31, mkdirSync as mkdirSync29, mkdtempSync as mkdtempSync6, readFileSync as readFileSync43, readdirSync as readdirSync24, renameSync as renameSync14, rmSync as rmSync9, writeFileSync as writeFileSync29 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname34, isAbsolute as isAbsolute28, join as join60, relative as relative9, resolve as resolve25, sep as sep12 } from "path";
+import { dirname as dirname35, isAbsolute as isAbsolute29, join as join61, relative as relative10, resolve as resolve26, sep as sep13 } from "path";
 function prepareSkill(name, options) {
   const normalized = normalizePortableSkillName(name);
   if (!new RegExp(SEMVER_PATTERN).test(options.version))
     throw new Error("--version must be a semantic version, for example 0.2.0.");
-  const path = join60(getPortableSkillsRootReadOnly(options), normalized);
+  const path = join61(getPortableSkillsRootReadOnly(options), normalized);
   assertPortableAuthoringPath(path, options);
   const before2 = snapshot2(path);
   const manifestFile = before2.files.find((file2) => file2.path === "skill.json");
@@ -111161,17 +112041,17 @@ function prepareSkill(name, options) {
     throw new Error("skill.json provenance must be an object.");
   const provenance = manifest.provenance;
   const candidate2 = { ...manifest, version: options.version, kind, provenance: { ...provenance } };
-  const staging = mkdtempSync6(join60(tmpdir2(), "skills-prepare-"));
+  const staging = mkdtempSync6(join61(tmpdir2(), "skills-prepare-"));
   try {
     for (const directory2 of before2.directories)
-      mkdirSync28(join60(staging, directory2), { recursive: true });
+      mkdirSync29(join61(staging, directory2), { recursive: true });
     for (const file2 of before2.files) {
-      const destination = join60(staging, file2.path);
-      mkdirSync28(dirname34(destination), { recursive: true });
-      writeFileSync28(destination, file2.bytes, { mode: file2.mode });
+      const destination = join61(staging, file2.path);
+      mkdirSync29(dirname35(destination), { recursive: true });
+      writeFileSync29(destination, file2.bytes, { mode: file2.mode });
     }
-    const stagedManifest = join60(staging, "skill.json");
-    writeFileSync28(stagedManifest, `${JSON.stringify(candidate2, null, 2)}
+    const stagedManifest = join61(staging, "skill.json");
+    writeFileSync29(stagedManifest, `${JSON.stringify(candidate2, null, 2)}
 `);
     const contentHash = computeContentHash(staging);
     const changed3 = options.version !== previousVersion || kind !== manifest.kind || contentHash !== provenance?.content_hash;
@@ -111181,7 +112061,7 @@ function prepareSkill(name, options) {
     candidate2.provenance.content_hash = contentHash;
     const candidateBytes = `${JSON.stringify(candidate2, null, 2)}
 `;
-    writeFileSync28(stagedManifest, candidateBytes);
+    writeFileSync29(stagedManifest, candidateBytes);
     validateRawCandidate(candidate2);
     validateRuntimeEntrypoint(candidate2, staging);
     const validation = validatePortableSkillDirectory(normalized, staging);
@@ -111193,11 +112073,11 @@ ${validation.issues.map((issue2) => `${issue2.code}: ${issue2.message}`).join(`
     if (snapshot2(path).identity !== before2.identity)
       throw new Error("Skill changed during preparation; review the draft and run prepare again.");
     if (changed3 && !options.dryRun) {
-      const temporary = join60(path, `.skill-prepare-${randomUUID11()}.tmp`);
+      const temporary = join61(path, `.skill-prepare-${randomUUID12()}.tmp`);
       try {
-        writeFileSync28(temporary, candidateBytes, { flag: "wx", mode: manifestFile.mode });
-        chmodSync4(temporary, manifestFile.mode);
-        renameSync13(temporary, join60(path, "skill.json"));
+        writeFileSync29(temporary, candidateBytes, { flag: "wx", mode: manifestFile.mode });
+        chmodSync5(temporary, manifestFile.mode);
+        renameSync14(temporary, join61(path, "skill.json"));
       } finally {
         rmSync9(temporary, { force: true });
       }
@@ -111227,8 +112107,8 @@ function validateRuntimeEntrypoint(candidate2, root2) {
   const entry = candidate2.runtime.entrypoint;
   if (typeof entry !== "string")
     return;
-  const target = resolve25(root2, entry), rel = relative9(root2, target);
-  if (isAbsolute28(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep12}`) || isAbsolute28(rel) || !existsSync34(target) || !lstatSync30(target).isFile()) {
+  const target = resolve26(root2, entry), rel = relative10(root2, target);
+  if (isAbsolute29(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep13}`) || isAbsolute29(rel) || !existsSync35(target) || !lstatSync31(target).isFile()) {
     throw new Error("Executable runtime.entrypoint must name an existing regular file inside the skill directory.");
   }
 }
@@ -111313,25 +112193,25 @@ function compareVersions(left, right) {
   return 0;
 }
 function snapshot2(root2) {
-  const rootStat = lstatSync30(root2);
+  const rootStat = lstatSync31(root2);
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
     throw new Error("Skill root must be a real directory, not a symlink.");
   const files = [], directories = [];
-  const hash5 = createHash30("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
+  const hash6 = createHash31("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
   let count = 0, bytes = 0;
-  const walk2 = (relative10) => {
-    for (const name of readdirSync23(join60(root2, relative10)).sort()) {
-      if (IGNORED.has(name.toLowerCase()) || !relative10 && ROOT_IGNORED.has(name.toLowerCase()))
+  const walk2 = (relative11) => {
+    for (const name of readdirSync24(join61(root2, relative11)).sort()) {
+      if (IGNORED.has(name.toLowerCase()) || !relative11 && ROOT_IGNORED.has(name.toLowerCase()))
         continue;
-      const path = relative10 ? `${relative10}/${name}` : name;
+      const path = relative11 ? `${relative11}/${name}` : name;
       if (++count > 20000)
         throw new Error("Skill exceeds the preparation entry limit (20000).");
-      const absolute = join60(root2, path), stat3 = lstatSync30(absolute);
+      const absolute = join61(root2, path), stat3 = lstatSync31(absolute);
       if (stat3.isSymbolicLink())
         throw new Error(`Skill contains a symlink: ${path}. No files were changed.`);
       if (stat3.isDirectory() && name === "node_modules")
         continue;
-      hash5.update(JSON.stringify([path, stat3.dev, stat3.ino, stat3.mode]));
+      hash6.update(JSON.stringify([path, stat3.dev, stat3.ino, stat3.mode]));
       if (stat3.isDirectory()) {
         directories.push(path);
         walk2(path);
@@ -111339,18 +112219,18 @@ function snapshot2(root2) {
         bytes += stat3.size;
         if (bytes > 50000000)
           throw new Error("Skill exceeds the preparation size limit (50000000 bytes).");
-        const content = readFileSync42(absolute);
+        const content = readFileSync43(absolute);
         if (content.length !== stat3.size)
           throw new Error("Skill changed during preparation.");
         files.push({ path, bytes: content, mode: stat3.mode & 511 });
-        hash5.update(`\x00${content.length}\x00`).update(content);
+        hash6.update(`\x00${content.length}\x00`).update(content);
       } else
         throw new Error(`Unsupported skill entry: ${path}.`);
-      hash5.update("\x00");
+      hash6.update("\x00");
     }
   };
   walk2("");
-  return { files, directories, identity: hash5.digest("hex") };
+  return { files, directories, identity: hash6.digest("hex") };
 }
 var MAX_PACK_PARITY_PATHS = 8, MAX_PACK_PARITY_PATH_CHARS = 120, IGNORED, ROOT_IGNORED;
 var init_prepare_skill = __esm(() => {
@@ -111741,8 +112621,8 @@ var init_schedule = __esm(() => {
 });
 
 // src/lib/registry-sync.ts
-import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync29 } from "fs";
-import { dirname as dirname35, relative as relative10 } from "path";
+import { mkdirSync as mkdirSync30, writeFileSync as writeFileSync30 } from "fs";
+import { dirname as dirname36, relative as relative11 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
   const includeDocs = options.includeDocs ?? true;
@@ -111754,7 +112634,7 @@ function createRegistrySyncArtifact(options = {}) {
   const registry2 = [...loadRegistryProfile(profile)].sort((a, b) => a.name.localeCompare(b.name));
   const skills = registry2.map((skill) => {
     const skillPath = getSkillPath(skill.name);
-    const directory2 = relative10(process.cwd(), skillPath) || skillPath;
+    const directory2 = relative11(process.cwd(), skillPath) || skillPath;
     const validation = includeValidation ? validateSkillDirectory(skill.name, skillPath, skill) : undefined;
     const docs = includeDocs ? buildDocs(skill.name) : undefined;
     return {
@@ -111799,8 +112679,8 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync29(dirname35(path), { recursive: true });
-  writeFileSync29(path, `${JSON.stringify(artifact, null, 2)}
+  mkdirSync30(dirname36(path), { recursive: true });
+  writeFileSync30(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
 function buildDocs(name) {
@@ -111819,8 +112699,8 @@ var init_registry_sync = __esm(() => {
 });
 
 // src/lib/review-export.ts
-import { constants as constants22, closeSync as closeSync25, existsSync as existsSync35, fstatSync as fstatSync25, fsyncSync as fsyncSync7, lstatSync as lstatSync31, openSync as openSync25, realpathSync as realpathSync15, statSync as statSync23, writeFileSync as writeFileSync30 } from "fs";
-import { basename as basename14, dirname as dirname36, isAbsolute as isAbsolute29, join as join61, parse as parse12, resolve as resolve26, sep as sep13 } from "path";
+import { constants as constants22, closeSync as closeSync25, existsSync as existsSync36, fstatSync as fstatSync25, fsyncSync as fsyncSync7, lstatSync as lstatSync32, openSync as openSync25, realpathSync as realpathSync16, statSync as statSync23, writeFileSync as writeFileSync31 } from "fs";
+import { basename as basename15, dirname as dirname37, isAbsolute as isAbsolute30, join as join62, parse as parse12, resolve as resolve27, sep as sep14 } from "path";
 function exactVersion(spec) {
   const at2 = spec.indexOf("@");
   const slug2 = spec.slice(0, at2);
@@ -111831,23 +112711,23 @@ function exactVersion(spec) {
   return { slug: slug2, version: version2 };
 }
 function assertPrivateDestination(output2) {
-  if (!isAbsolute29(output2) || resolve26(output2) !== output2 || !basename14(output2).endsWith(".tar.gz")) {
+  if (!isAbsolute30(output2) || resolve27(output2) !== output2 || !basename15(output2).endsWith(".tar.gz")) {
     throw new Error("Review output must be an absolute, normalized .tar.gz path.");
   }
-  const parent = dirname36(output2);
-  if (realpathSync15(parent) !== parent || lstatSync31(parent).isSymbolicLink()) {
+  const parent = dirname37(output2);
+  if (realpathSync16(parent) !== parent || lstatSync32(parent).isSymbolicLink()) {
     throw new Error("Review output parent must be a real directory, not a symlink.");
   }
   const parentStat = statSync23(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(sep13);
+  const segments = parent.toLowerCase().split(sep14);
   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 = dirname36(current)) {
-    if (existsSync35(join61(current, ".git"))) {
+  for (let current = parent;; current = dirname37(current)) {
+    if (existsSync36(join62(current, ".git"))) {
       throw new Error("Review output cannot be placed inside a Git worktree.");
     }
     if (current === parse12(current).root)
@@ -111858,7 +112738,7 @@ function assertPrivateDestination(output2) {
 async function exportSkillVersionForReview(spec, output2, client2) {
   const { slug: slug2, version: version2 } = exactVersion(spec);
   const target = assertPrivateDestination(output2);
-  if (existsSync35(target))
+  if (existsSync36(target))
     throw new Error("Review output already exists; choose a new filename.");
   const metadata = await client2.getSkillVersion(slug2, version2);
   if (!metadata)
@@ -111885,7 +112765,7 @@ async function exportSkillVersionForReview(spec, output2, client2) {
   }
   const fd = openSync25(target, constants22.O_WRONLY | constants22.O_CREAT | constants22.O_EXCL | constants22.O_NOFOLLOW, 384);
   try {
-    writeFileSync30(fd, bytes);
+    writeFileSync31(fd, bytes);
     fsyncSync7(fd);
     if (fstatSync25(fd).size !== bytes.byteLength)
       throw new Error("Incomplete review output write.");
@@ -111923,12 +112803,12 @@ function registerRegistry(parent) {
 async function writeJson2(value, space) {
   const text4 = `${JSON.stringify(value, null, space)}
 `;
-  await new Promise((resolve27, reject2) => {
+  await new Promise((resolve28, reject2) => {
     process.stdout.write(text4, (error61) => {
       if (error61)
         reject2(error61);
       else
-        resolve27();
+        resolve28();
     });
   });
 }
@@ -112132,9 +113012,9 @@ __export(exports_publish, {
   PushSkillError: () => PushSkillError
 });
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync36, readFileSync as readFileSync43 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync44 } from "fs";
 import { hostname as hostname5 } from "os";
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 function registerPublish(parent) {
   parent.command("push").argument("<name>", "Name of a skill in the local corpus (~/.hasna/skills/installed or the migrated ~/.hasna/skills/skills)").option("--version <version>", "Override the version recorded on the instance").option("--force-new-version", "If name@version already exists with different content, publish as the next patch version", false).option("--dry-run", "Pack and validate without uploading", false).option("--json", "Output result as JSON", false).description("Publish a local skill to the configured skills instance").action(async (name, options) => {
     try {
@@ -112186,8 +113066,8 @@ async function pushSkill(name, options = {}) {
   const packed = packSkillBundle(skill.path, { maxUnpackedBytes: MAX_UNPACKED_BYTES });
   await verifyPackedCanonicalHash(skill.name, packed);
   const versionManifest = buildVersionManifest(skill.path, packed);
-  const skillMdPath = join62(skill.path, "SKILL.md");
-  const skillMd = existsSync36(skillMdPath) ? readFileSync43(skillMdPath, "utf-8") : undefined;
+  const skillMdPath = join63(skill.path, "SKILL.md");
+  const skillMd = existsSync37(skillMdPath) ? readFileSync44(skillMdPath, "utf-8") : undefined;
   const base3 = {
     slug: skill.name,
     path: skill.path,
@@ -112425,7 +113305,7 @@ var exports_private_publications = {};
 __export(exports_private_publications, {
   registerPrivatePublications: () => registerPrivatePublications
 });
-import { resolve as resolve27 } from "path";
+import { resolve as resolve28 } from "path";
 function verifyOptions(options, action) {
   if (options.userId === undefined !== (options.membershipId === undefined) || options.userId !== undefined && (!publicationUuid(options.userId) || !publicationUuid(options.membershipId)))
     throw new PrivatePublicationError("PUBLICATION_CONTEXT_REQUIRED", "Provide both observed --user-id and --membership-id UUIDs.");
@@ -112470,9 +113350,9 @@ function registerPrivatePublications(parent) {
         if (code2 === null)
           return;
         const context2 = options.userId ? { userId: options.userId, membershipId: options.membershipId } : undefined;
-        const client2 = await privatePublicationSession(options.email, code2, context2), directory2 = resolve27(options.recoveryDir);
+        const client2 = await privatePublicationSession(options.email, code2, context2), directory2 = resolve28(options.recoveryDir);
         if (action === "publish")
-          await preparePrivatePublication(client2, resolve27(args2[0]), directory2, { skillId: options.skillId, expectedCurrentVersionId: options.expectedCurrentVersion ?? null, idempotencyKey: options.idempotencyKey });
+          await preparePrivatePublication(client2, resolve28(args2[0]), directory2, { skillId: options.skillId, expectedCurrentVersionId: options.expectedCurrentVersion ?? null, idempotencyKey: options.idempotencyKey });
         const result2 = action === "publish" || action === "resume" ? await continuePrivatePublication(client2, directory2, { confirm: true, waitMs: Number(options.waitSeconds) * 1000 }) : await inspectPrivatePublication(client2, directory2, action === "cancel");
         print2(result2, options.json);
       } catch (error61) {
@@ -112574,7 +113454,7 @@ __export(exports_auth, {
 import { createInterface as createInterface3 } from "readline";
 function prompt(question) {
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     let settled = false;
     const finish = (answer) => {
       if (settled)
@@ -112583,7 +113463,7 @@ function prompt(question) {
       rl.close();
       if (answer === null)
         process.exitCode = 130;
-      resolve28(answer);
+      resolve29(answer);
     };
     rl.once("SIGINT", () => finish(null));
     rl.once("close", () => finish(null));
@@ -112761,7 +113641,7 @@ Skipped. Run it any time: skills setup agents`));
 function promptHidden(question) {
   const stdin = process.stdin;
   process.stdout.write(question);
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     let value = "";
     const done = (answer) => {
       stdin.off("data", onData);
@@ -112771,7 +113651,7 @@ function promptHidden(question) {
 `);
       if (answer === null)
         process.exitCode = 130;
-      resolve28(answer);
+      resolve29(answer);
     };
     const onData = (chunk2) => {
       for (const character of chunk2.toString()) {
@@ -113317,7 +114197,7 @@ function promptInvitationProof(kind) {
   const label = kind === "token" ? "invitation token" : "recovery code";
   const character = kind === "token" ? /^[A-Za-z0-9_-]$/ : /^\d$/;
   const { stdin, stderr: output2 } = process, wasRaw = stdin.isRaw, wasFlowing = stdin.readableFlowing;
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     let value = "", settled = false, overflow = false;
     const finish = (answer) => {
       if (settled)
@@ -113334,7 +114214,7 @@ function promptInvitationProof(kind) {
 `);
       if (answer === null)
         process.exitCode = 130;
-      resolve28(answer);
+      resolve29(answer);
     };
     const cancel = () => finish(null);
     const keypress = (text4, key) => {
@@ -113906,8 +114786,8 @@ var init_storage2 = __esm(() => {
 });
 
 // src/lib/registry-reconcile.ts
-import { existsSync as existsSync37, readFileSync as readFileSync44, statSync as statSync24, writeFileSync as writeFileSync31 } from "fs";
-import { join as join63 } from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync45, statSync as statSync24, writeFileSync as writeFileSync32 } from "fs";
+import { join as join64 } from "path";
 function isDirectory2(path) {
   try {
     return statSync24(path).isDirectory();
@@ -113918,15 +114798,15 @@ function isDirectory2(path) {
 function migrationNeeded(options) {
   if (options.rootDir)
     return false;
-  const appDir = options.homeDir ? join63(options.homeDir, ".hasna", "skills") : getDataDir();
-  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join63(appDir, SKILLS_CACHE_DIRNAME)));
+  const appDir = options.homeDir ? join64(options.homeDir, ".hasna", "skills") : getDataDir();
+  return !(isOwnerLayoutMigrated(appDir) && isDirectory2(join64(appDir, SKILLS_CACHE_DIRNAME)));
 }
 function readBaseline(skillDir) {
-  const markerPath = join63(skillDir, PULL_MARKER_FILE);
-  if (!existsSync37(markerPath))
+  const markerPath = join64(skillDir, PULL_MARKER_FILE);
+  if (!existsSync38(markerPath))
     return;
   try {
-    const marker = JSON.parse(readFileSync44(markerPath, "utf-8"));
+    const marker = JSON.parse(readFileSync45(markerPath, "utf-8"));
     if (!isSkillsOwnershipMarker(marker))
       return;
     return {
@@ -113938,11 +114818,11 @@ function readBaseline(skillDir) {
   }
 }
 function readCursor(root2) {
-  const path = join63(root2, SYNC_CURSOR_FILE);
-  if (!existsSync37(path))
+  const path = join64(root2, SYNC_CURSOR_FILE);
+  if (!existsSync38(path))
     return { runCount: 0 };
   try {
-    const cursor2 = JSON.parse(readFileSync44(path, "utf-8"));
+    const cursor2 = JSON.parse(readFileSync45(path, "utf-8"));
     return { runCount: typeof cursor2.runCount === "number" ? cursor2.runCount : 0 };
   } catch {
     return { runCount: 0 };
@@ -113951,12 +114831,12 @@ function readCursor(root2) {
 function resolveCorpusRootReadOnly(options) {
   if (options.rootDir)
     return { root: options.rootDir, migrationPending: false };
-  const appDir = options.homeDir ? join63(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
-  const cache3 = join63(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join64(options.homeDir, ".hasna", "skills") : getDataDirReadOnly();
+  const cache3 = join64(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && isDirectory2(cache3)) {
     return { root: cache3, migrationPending: false };
   }
-  return { root: join63(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
+  return { root: join64(appDir, INSTALLED_SKILLS_DIRNAME), migrationPending: true };
 }
 function remoteRowToSkill(record11) {
   const slug2 = typeof record11.slug === "string" ? record11.slug : typeof record11.name === "string" ? record11.name : undefined;
@@ -113970,7 +114850,7 @@ function remoteRowToSkill(record11) {
 }
 function recheckLocalSide(plannedLocal, localDir, ops = {
   pack: (dir) => packSkillBundle(dir).sha256,
-  exists: existsSync37
+  exists: existsSync38
 }) {
   let localNow;
   try {
@@ -114090,7 +114970,7 @@ async function reconcileRegistry(options = {}) {
   for (const slug2 of allSlugs) {
     const local = locals.get(slug2);
     const remote = remotes.get(slug2);
-    const baseline = local ? readBaseline(join63(root2, slug2)) : undefined;
+    const baseline = local ? readBaseline(join64(root2, slug2)) : undefined;
     const { state, reason } = classifySkill(local, remote, baseline);
     let { action, reason: actionReason } = resolveAction(state, direction, conflict);
     if (state === "remote-only" && isDigestless(remote)) {
@@ -114149,7 +115029,7 @@ async function reconcileRegistry(options = {}) {
       try {
         await pushSkill(slug2, { rootDir: root2, client: client2 });
         const pushed = locals.get(slug2);
-        writePullMarker(join63(root2, slug2), {
+        writePullMarker(join64(root2, slug2), {
           skill: slug2,
           ...pushed?.version ? { version: pushed.version } : {},
           ...pushed?.sha256 ? { contentHash: pushed.sha256 } : {},
@@ -114221,7 +115101,7 @@ async function reconcileRegistry(options = {}) {
         runCount: readCursor(root2).runCount + 1,
         summary
       };
-      writeFileSync31(join63(root2, SYNC_CURSOR_FILE), `${JSON.stringify(cursor2, null, 2)}
+      writeFileSync32(join64(root2, SYNC_CURSOR_FILE), `${JSON.stringify(cursor2, null, 2)}
 `);
       return {
         corpusRoot: root2,