@hasna/skills 0.10.16 → 0.10.18

package/bin/index.js

@@ -36868,7 +36868,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.16",
+    version: "0.10.18",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -108698,13 +108698,13 @@ function comparePackageTrees(expectedRoot, installedRoot) {
     throw new Error("INSTALLED_PACKAGE_BYTES_MISMATCH");
   return expected.digest;
 }
-function replaceLink(path, target, backupPath, oldLinkTarget) {
+function replaceLink(path, target, backupPath, oldLinkTarget, oldTarget = resolve23(dirname30(path), oldLinkTarget)) {
   const stat3 = lstatSync28(path);
   if (!stat3.isSymbolicLink() || entryExists(backupPath))
     throw new Error("LAUNCHER_PREIMAGE_DRIFT");
   const temp = `${path}.skills-next-${randomUUID9()}`;
   symlinkSync(oldLinkTarget, backupPath);
-  if (readlinkSync5(backupPath) !== oldLinkTarget || realpathSync14(backupPath) !== resolve23(dirname30(path), oldLinkTarget))
+  if (readlinkSync5(backupPath) !== oldLinkTarget || realpathSync14(backupPath) !== oldTarget)
     throw new Error("LAUNCHER_BACKUP_READBACK_MISMATCH");
   symlinkSync(target, temp);
   if (realpathSync14(temp) !== target)
@@ -108745,6 +108745,324 @@ function persistReceipt(path, value) {
   }
   atomicJson(path, value);
 }
+function persistAliasReceipt(path, value) {
+  if (entryExists(path)) {
+    const priorBytes = readFileSync37(path);
+    const prior = object9(JSON.parse(priorBytes.toString("utf8")), "ALIAS_RECEIPT_INVALID");
+    if (prior.schema !== value.schema || prior.id !== value.id || typeof prior.state !== "string")
+      throw new Error("ALIAS_RECEIPT_DRIFT");
+    const nextBytes = Buffer.from(`${JSON.stringify(value, null, 2)}
+`);
+    if (priorBytes.equals(nextBytes))
+      return;
+    const history = join55(dirname30(path), "history");
+    if (!entryExists(history))
+      mkdirSync24(history, { mode: 448 });
+    const historyStat = lstatSync28(history);
+    if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
+      throw new Error("ALIAS_RECEIPT_HISTORY_UNSAFE");
+    const saved = join55(history, `${value.id}-${String(prior.state)}-${randomUUID9()}.json`);
+    writeFileSync23(saved, priorBytes, { flag: "wx", mode: 256 });
+    chmodSync4(saved, 256);
+    if (!readFileSync37(saved).equals(priorBytes))
+      throw new Error("ALIAS_RECEIPT_HISTORY_READBACK_MISMATCH");
+  }
+  atomicJson(path, value);
+}
+function assertOwnedSafePath(path, home, requireWritable = false) {
+  assertNoSymlinkAncestors(path);
+  for (let current = path;; current = dirname30(current)) {
+    const stat3 = lstatSync28(current);
+    if (!stat3.isDirectory() || ![0, process.getuid?.() ?? -1].includes(stat3.uid) || stat3.mode & 18)
+      throw new Error("ALIAS_PATH_UNSAFE");
+    if (current === path && requireWritable && (stat3.uid !== (process.getuid?.() ?? -1) || (stat3.mode & 128) === 0))
+      throw new Error("ALIAS_DIRECTORY_NOT_OWNED");
+    if (current === dirname30(current) || current === home)
+      break;
+  }
+}
+function activeAliasRuntime(home, pathValue) {
+  const layout = resolveRuntimeLayout(home, pathValue);
+  const runtimePath = dirname30(dirname30(dirname30(layout.currentPackageRoot)));
+  const receiptPath = join55(runtimePath, "rollout-receipt.json");
+  const rollout = object9(JSON.parse(readFileSync37(receiptPath, "utf8")), "ROLLOUT_RECEIPT_INVALID");
+  if (rollout.schema !== "skills.copyfile-runtime-receipt.v1" || rollout.state !== "switched" || rollout.targetPackageRoot !== layout.currentPackageRoot || rollout.targetVersion !== layout.currentVersion || rollout.runtimeRoot !== layout.runtimeRoot || rollout.package !== PACKAGE_NAME || hash5(readFileSync37(join55(runtimePath, "verified-package.tgz"))) !== rollout.tarballSha256 || readTree(join55(runtimePath, "node_modules"), true).digest !== rollout.runtimeTreeSha256) {
+    throw new Error("ACTIVE_RUNTIME_RECEIPT_DRIFT");
+  }
+  verifyPreimageManifest(runtimePath, rollout, home);
+  return { layout, rollout };
+}
+function aliasDirs(home) {
+  return [join55(home, ".local", "bin"), join55(home, ".bun", "bin"), "/opt/homebrew/bin", "/usr/local/bin"];
+}
+function aliasPackageLink(home, aliasPath) {
+  const dir = dirname30(aliasPath);
+  if (dir === join55(home, ".local", "bin"))
+    return join55(home, ".local", "lib", "node_modules", "@hasna", "skills");
+  if (dir === "/opt/homebrew/bin")
+    return "/opt/homebrew/lib/node_modules/@hasna/skills";
+  if (dir === "/usr/local/bin")
+    return "/usr/local/lib/node_modules/@hasna/skills";
+  return null;
+}
+function inspectAliasPackageChain(home, aliasPath, oldLinkTarget, oldTarget, bin, expected, verify = false) {
+  const immediate = resolve23(dirname30(aliasPath), oldLinkTarget);
+  if (immediate === oldTarget) {
+    if (expected !== undefined)
+      throw new Error("ALIAS_LINK_CHAIN_DRIFT");
+    return;
+  }
+  const packageLinkPath = aliasPackageLink(home, aliasPath);
+  const physicalPackage = dirname30(dirname30(oldTarget));
+  if (!packageLinkPath || immediate !== join55(packageLinkPath, bin) || !isWithin(join55(home, ".hasna", "skills", "runtime"), physicalPackage)) {
+    throw new Error("ALIAS_LINK_CHAIN_UNSUPPORTED");
+  }
+  assertOwnedSafePath(dirname30(packageLinkPath), home);
+  let stat3, packageLinkTarget, resolved;
+  try {
+    stat3 = lstatSync28(packageLinkPath);
+    packageLinkTarget = readlinkSync5(packageLinkPath);
+    resolved = realpathSync14(packageLinkPath);
+  } catch {
+    throw new Error("ALIAS_LINK_CHAIN_UNSUPPORTED");
+  }
+  if (expected !== undefined && (expected.packageLinkPath !== packageLinkPath || expected.packageLinkTarget !== packageLinkTarget))
+    throw new Error("ALIAS_LINK_CHAIN_DRIFT");
+  if (!stat3.isSymbolicLink() || stat3.uid !== (process.getuid?.() ?? -1) || resolve23(dirname30(packageLinkPath), packageLinkTarget) !== physicalPackage || resolved !== physicalPackage)
+    throw new Error("ALIAS_LINK_CHAIN_UNSUPPORTED");
+  const chain = { packageLinkPath, packageLinkTarget };
+  if (verify && expected === undefined)
+    throw new Error("ALIAS_LINK_CHAIN_DRIFT");
+  return chain;
+}
+function validateAliasSource(home, name, actual) {
+  const packageRoot = dirname30(dirname30(actual));
+  const roots = [join55(home, ".hasna", "skills", "runtime"), join55(home, ".bun", "install"), join55(home, ".local", "lib", "node_modules")];
+  if (basename13(packageRoot) !== "skills" || basename13(dirname30(packageRoot)) !== "@hasna" || !roots.some((root2) => isWithin(root2, packageRoot))) {
+    throw new Error("ALIAS_SOURCE_ROOT_UNSUPPORTED");
+  }
+  assertOwnedSafePath(packageRoot, home);
+  const manifestPath = join55(packageRoot, "package.json");
+  const manifestStat = lstatSync28(manifestPath), binaryStat = lstatSync28(actual);
+  if (!manifestStat.isFile() || manifestStat.isSymbolicLink() || !binaryStat.isFile() || binaryStat.isSymbolicLink() || ![0, process.getuid?.() ?? -1].includes(manifestStat.uid) || ![0, process.getuid?.() ?? -1].includes(binaryStat.uid) || manifestStat.mode & 18)
+    throw new Error("ALIAS_SOURCE_UNSAFE");
+  const pkg = readPackage(manifestPath);
+  if (!pkg.bins[name] || actual !== join55(packageRoot, pkg.bins[name]))
+    throw new Error("ALIAS_SOURCE_BIN_MISMATCH");
+  return { version: pkg.version, packageRoot, binarySha256: hash5(readFileSync37(actual)) };
+}
+function adoptCopyfileAliases(options = {}) {
+  const home = realpathSync14(resolve23(options.homeDir ?? process.env.HOME ?? ""));
+  const pathValue = options.pathValue ?? process.env.PATH ?? "";
+  const { layout, rollout } = activeAliasRuntime(home, pathValue);
+  const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
+  const id2 = randomUUID9();
+  const aliases = [];
+  const currentRuntime = dirname30(dirname30(dirname30(layout.currentPackageRoot)));
+  const receiptDir = join55(currentRuntime, "alias-adoptions");
+  const receiptPath = join55(receiptDir, `${id2}.json`);
+  let receipt;
+  try {
+    const locked2 = activeAliasRuntime(home, pathValue);
+    if (locked2.layout.currentPackageRoot !== layout.currentPackageRoot || locked2.rollout.id !== rollout.id)
+      throw new Error("ACTIVE_RUNTIME_CHANGED_BEFORE_ALIAS_ADOPTION");
+    for (const dir of aliasDirs(home)) {
+      if (!entryExists(dir))
+        continue;
+      for (const [name, target] of Object.entries(layout.bin)) {
+        const path = join55(dir, name);
+        if (!entryExists(path))
+          continue;
+        assertOwnedSafePath(dir, home, true);
+        const stat3 = lstatSync28(path);
+        if (!stat3.isSymbolicLink() || stat3.uid !== (process.getuid?.() ?? -1))
+          throw new Error("ALIAS_LINK_NOT_OWNED");
+        const oldLinkTarget = readlinkSync5(path);
+        let actual;
+        try {
+          actual = realpathSync14(path);
+        } catch {
+          throw new Error("ALIAS_LINK_CHAIN_UNSUPPORTED");
+        }
+        const newTarget = join55(layout.currentPackageRoot, target);
+        if (actual === newTarget)
+          continue;
+        const chain = inspectAliasPackageChain(home, path, oldLinkTarget, actual, target);
+        const source = validateAliasSource(home, name, actual);
+        const backupPath = `${path}.skills-alias-prev-${id2}`;
+        if (entryExists(backupPath))
+          throw new Error("ALIAS_BACKUP_COLLISION");
+        aliases.push({ path, oldTarget: actual, oldLinkTarget, oldVersion: source.version, oldBinarySha256: source.binarySha256, newTarget, backupPath, ...chain ? { chain } : {} });
+      }
+    }
+    if (!aliases.length)
+      return { adopted: true, version: layout.currentVersion, aliasCount: 0 };
+    mkdirSync24(receiptDir, { recursive: true, mode: 448 });
+    const receiptDirStat = lstatSync28(receiptDir);
+    if (!receiptDirStat.isDirectory() || receiptDirStat.isSymbolicLink() || receiptDirStat.mode & 63)
+      throw new Error("ALIAS_RECEIPT_DIRECTORY_UNSAFE");
+    receipt = {
+      schema: "skills.copyfile-alias-adoption.v1",
+      id: id2,
+      state: "prepared",
+      targetVersion: layout.currentVersion,
+      targetPackageRoot: layout.currentPackageRoot,
+      rolloutReceiptId: rollout.id,
+      aliases,
+      switchedAliases: [],
+      rollbackCompletedAliases: []
+    };
+    writeJsonPrivate(receiptPath, receipt);
+    for (const item of aliases) {
+      if (readlinkSync5(item.path) !== item.oldLinkTarget || realpathSync14(item.path) !== item.oldTarget)
+        throw new Error("ALIAS_CHANGED_BEFORE_SWITCH");
+      inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename13(item.path)], item.chain, true);
+      const source = validateAliasSource(home, basename13(item.path), item.oldTarget);
+      if (source.version !== item.oldVersion || source.binarySha256 !== item.oldBinarySha256)
+        throw new Error("ALIAS_SOURCE_DRIFT");
+      receipt.state = "switching";
+      receipt.switchedAliases = [...receipt.switchedAliases, item.path];
+      persistAliasReceipt(receiptPath, receipt);
+      replaceLink(item.path, item.newTarget, item.backupPath, item.oldLinkTarget, item.oldTarget);
+      if (realpathSync14(item.path) !== item.newTarget || realpathSync14(item.backupPath) !== item.oldTarget)
+        throw new Error("ALIAS_SWITCH_READBACK_MISMATCH");
+      inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename13(item.path)], item.chain, true);
+      options.onAliasSwitched?.(item.path);
+    }
+    for (const item of aliases) {
+      inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename13(item.path)], item.chain, true);
+      if (readlinkSync5(item.backupPath) !== item.oldLinkTarget || realpathSync14(item.backupPath) !== item.oldTarget)
+        throw new Error("ALIAS_BACKUP_DRIFT");
+    }
+    receipt.state = "switched";
+    persistAliasReceipt(receiptPath, receipt);
+    return { adopted: true, version: layout.currentVersion, receiptId: id2, aliasCount: aliases.length };
+  } catch (error61) {
+    if (receipt) {
+      let failed = false;
+      for (const item of [...aliases].reverse()) {
+        try {
+          if (!entryExists(item.backupPath)) {
+            inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename13(item.path)], item.chain, true);
+            const source2 = validateAliasSource(home, basename13(item.path), item.oldTarget);
+            if (!entryExists(item.path) || readlinkSync5(item.path) !== item.oldLinkTarget || realpathSync14(item.path) !== item.oldTarget || source2.version !== item.oldVersion || source2.binarySha256 !== item.oldBinarySha256)
+              failed = true;
+            continue;
+          }
+          if (readlinkSync5(item.backupPath) !== item.oldLinkTarget || realpathSync14(item.backupPath) !== item.oldTarget)
+            throw new Error("ALIAS_BACKUP_DRIFT");
+          inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename13(item.path)], item.chain, true);
+          const source = validateAliasSource(home, basename13(item.path), item.oldTarget);
+          if (source.version !== item.oldVersion || source.binarySha256 !== item.oldBinarySha256)
+            throw new Error("ALIAS_SOURCE_DRIFT");
+          if (realpathSync14(item.path) === item.oldTarget && readlinkSync5(item.path) === item.oldLinkTarget)
+            continue;
+          if (realpathSync14(item.path) !== item.newTarget)
+            throw new Error("ALIAS_CHANGED_DURING_ROLLBACK");
+          const after2 = `${item.path}.skills-alias-after-${id2}`;
+          if (entryExists(after2))
+            throw new Error("ALIAS_AFTER_COLLISION");
+          symlinkSync(item.newTarget, after2);
+          const temp = `${item.path}.skills-alias-rollback-${randomUUID9()}`;
+          symlinkSync(item.oldLinkTarget, temp);
+          renameSync13(temp, item.path);
+          if (readlinkSync5(item.path) !== item.oldLinkTarget)
+            throw new Error("ALIAS_ROLLBACK_READBACK_MISMATCH");
+          receipt.rollbackCompletedAliases = [...receipt.rollbackCompletedAliases, item.path];
+          persistAliasReceipt(receiptPath, receipt);
+        } catch {
+          failed = true;
+        }
+      }
+      receipt.state = failed ? "rollback-required" : "rolled-back";
+      try {
+        persistAliasReceipt(receiptPath, receipt);
+      } catch {
+        failed = true;
+      }
+      throw new Error(failed ? "ALIAS_ADOPTION_ROLLBACK_REQUIRED" : "ALIAS_ADOPTION_ROLLED_BACK");
+    }
+    throw error61 instanceof Error ? error61 : new Error("ALIAS_ADOPTION_FAILED");
+  } finally {
+    releaseLock();
+  }
+}
+function rollbackCopyfileAliases(receiptId, options = {}) {
+  if (!/^[0-9a-f-]{36}$/.test(receiptId))
+    throw new Error("ALIAS_RECEIPT_ID_INVALID");
+  const home = realpathSync14(resolve23(options.homeDir ?? process.env.HOME ?? ""));
+  const pathValue = options.pathValue ?? process.env.PATH ?? "";
+  const { layout, rollout } = activeAliasRuntime(home, pathValue);
+  const runtimePath = dirname30(dirname30(dirname30(layout.currentPackageRoot)));
+  const receiptPath = join55(runtimePath, "alias-adoptions", `${receiptId}.json`);
+  const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
+  try {
+    const locked2 = activeAliasRuntime(home, pathValue);
+    if (locked2.layout.currentPackageRoot !== layout.currentPackageRoot || locked2.rollout.id !== rollout.id)
+      throw new Error("ACTIVE_RUNTIME_CHANGED_BEFORE_ALIAS_ROLLBACK");
+    const receipt = object9(JSON.parse(readFileSync37(receiptPath, "utf8")), "ALIAS_RECEIPT_INVALID");
+    if (receipt.schema !== "skills.copyfile-alias-adoption.v1" || receipt.id !== receiptId || !["switched", "switching", "rollback-required"].includes(receipt.state) || receipt.targetPackageRoot !== layout.currentPackageRoot || receipt.targetVersion !== layout.currentVersion || receipt.rolloutReceiptId !== rollout.id || !Array.isArray(receipt.aliases))
+      throw new Error("ALIAS_RECEIPT_BINDING_INVALID");
+    const seen = new Set;
+    for (const item of receipt.aliases) {
+      const name = basename13(item.path), target = layout.bin[name];
+      if (!target || seen.has(item.path) || !aliasDirs(home).includes(dirname30(item.path)) || item.newTarget !== join55(layout.currentPackageRoot, target) || item.backupPath !== `${item.path}.skills-alias-prev-${receiptId}` || item.chain !== undefined && (!item.chain || typeof item.chain !== "object" || typeof item.chain.packageLinkPath !== "string" || typeof item.chain.packageLinkTarget !== "string")) {
+        throw new Error("ALIAS_RECEIPT_LAUNCHER_INVALID");
+      }
+      inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, target, item.chain, true);
+      seen.add(item.path);
+      assertOwnedSafePath(dirname30(item.path), home, true);
+      const source = validateAliasSource(home, name, item.oldTarget);
+      if (source.version !== item.oldVersion || source.binarySha256 !== item.oldBinarySha256)
+        throw new Error("ALIAS_PREIMAGE_DRIFT");
+      const stat3 = lstatSync28(item.path);
+      if (!stat3.isSymbolicLink() || stat3.uid !== (process.getuid?.() ?? -1))
+        throw new Error("ALIAS_LINK_DRIFT");
+      const current = realpathSync14(item.path);
+      if (current !== item.newTarget && (current !== item.oldTarget || readlinkSync5(item.path) !== item.oldLinkTarget))
+        throw new Error("ALIAS_TARGET_DRIFT");
+      if (entryExists(item.backupPath)) {
+        const backup = lstatSync28(item.backupPath);
+        if (!backup.isSymbolicLink() || readlinkSync5(item.backupPath) !== item.oldLinkTarget || realpathSync14(item.backupPath) !== item.oldTarget)
+          throw new Error("ALIAS_PREIMAGE_DRIFT");
+      } else if (current !== item.oldTarget) {
+        throw new Error("ALIAS_BACKUP_MISSING_FOR_SWITCH");
+      }
+    }
+    let restored = 0;
+    for (const item of [...receipt.aliases].reverse()) {
+      if (realpathSync14(item.path) === item.oldTarget && readlinkSync5(item.path) === item.oldLinkTarget)
+        continue;
+      receipt.state = "rollback-required";
+      persistAliasReceipt(receiptPath, receipt);
+      const after2 = `${item.path}.skills-alias-after-${receiptId}`;
+      if (!entryExists(after2)) {
+        symlinkSync(item.newTarget, after2);
+        if (realpathSync14(after2) !== item.newTarget)
+          throw new Error("ALIAS_AFTER_READBACK_MISMATCH");
+      } else if (realpathSync14(after2) !== item.newTarget)
+        throw new Error("ALIAS_AFTER_DRIFT");
+      if (realpathSync14(item.path) !== item.newTarget)
+        throw new Error("ALIAS_TARGET_DRIFT");
+      const temp = `${item.path}.skills-alias-rollback-${randomUUID9()}`;
+      symlinkSync(item.oldLinkTarget, temp);
+      renameSync13(temp, item.path);
+      if (readlinkSync5(item.path) !== item.oldLinkTarget || realpathSync14(item.path) !== item.oldTarget)
+        throw new Error("ALIAS_ROLLBACK_READBACK_MISMATCH");
+      receipt.rollbackCompletedAliases = [...new Set([...receipt.rollbackCompletedAliases, item.path])];
+      persistAliasReceipt(receiptPath, receipt);
+      restored++;
+    }
+    for (const item of receipt.aliases) {
+      inspectAliasPackageChain(home, item.path, item.oldLinkTarget, item.oldTarget, layout.bin[basename13(item.path)], item.chain, true);
+    }
+    receipt.state = "rolled-back";
+    persistAliasReceipt(receiptPath, receipt);
+    return { rolledBack: true, receiptId, restoredAliasCount: restored };
+  } finally {
+    releaseLock();
+  }
+}
 async function updateCopyfileRuntime(version2, options = {}) {
   if (!new RegExp(SEMVER_PATTERN).test(version2))
     throw new Error("EXACT_VERSION_REQUIRED");
@@ -109091,12 +109409,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).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" }));
+  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").option("--adopt-aliases", "Switch verified legacy @hasna/skills aliases to the active copyfile runtime").option("--rollback-aliases <receipt-id>", "Restore aliases from an exact adoption receipt").action(async (options) => {
+    if ([options.version, options.rollback, options.adoptAliases, options.rollbackAliases].filter(Boolean).length > 1) {
+      console.error(JSON.stringify({ error: "SELF_UPDATE_OPERATIONS_ARE_MUTUALLY_EXCLUSIVE" }));
       process.exitCode = 1;
       return;
     }
+    if (options.adoptAliases) {
+      try {
+        const result2 = adoptCopyfileAliases();
+        if (options.json)
+          console.log(JSON.stringify(result2));
+        else
+          console.log(source_default.green(`Adopted ${String(result2.aliasCount)} verified Skills aliases into the active copyfile runtime.`));
+      } catch (error61) {
+        const message = error61 instanceof Error && /^[A-Z0-9_]+$/.test(error61.message) ? error61.message : "ALIAS_ADOPTION_FAILED";
+        console.error(JSON.stringify({ adopted: false, error: message }));
+        process.exitCode = 1;
+      }
+      return;
+    }
+    if (options.rollbackAliases) {
+      try {
+        const result2 = rollbackCopyfileAliases(options.rollbackAliases);
+        if (options.json)
+          console.log(JSON.stringify(result2));
+        else
+          console.log(source_default.green(`Restored ${String(result2.restoredAliasCount)} Skills aliases from the adoption receipt.`));
+      } catch (error61) {
+        const message = error61 instanceof Error && /^[A-Z0-9_]+$/.test(error61.message) ? error61.message : "ALIAS_ROLLBACK_FAILED";
+        console.error(JSON.stringify({ rolledBack: false, error: message }));
+        process.exitCode = 1;
+      }
+      return;
+    }
     if (options.version) {
       try {
         const result2 = await updateCopyfileRuntime(options.version);

package/bin/mcp.js

@@ -20019,7 +20019,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.16",
+    version: "0.10.18",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {

package/bin/migrate.js

@@ -7,7 +7,7 @@ import { join as join5 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.16",
+  version: "0.10.18",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/bin/server.js

@@ -24122,7 +24122,7 @@ var init_dist_es9 = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.16",
+  version: "0.10.18",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/bin/worker.js

@@ -24125,7 +24125,7 @@ import { randomUUID as randomUUID6 } from "crypto";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.16",
+  version: "0.10.18",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/dist/cli/commands/runtime-copyfile.d.ts

@@ -12,6 +12,15 @@ export declare function preflightTarball(bytes: Uint8Array, limits?: {
     expandedBytes: number;
 }>;
 export declare function readBodyCapped(response: Response, limit: number, errorCode: string): Promise<Uint8Array>;
+export declare function adoptCopyfileAliases(options?: {
+    homeDir?: string;
+    pathValue?: string;
+    onAliasSwitched?: (path: string) => void;
+}): JsonObject;
+export declare function rollbackCopyfileAliases(receiptId: string, options?: {
+    homeDir?: string;
+    pathValue?: string;
+}): JsonObject;
 export declare function updateCopyfileRuntime(version: string, options?: {
     homeDir?: string;
     pathValue?: string;

package/dist/index.js

@@ -10877,7 +10877,7 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.16",
+  version: "0.10.18",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/dist/sdk/index.js

@@ -32373,7 +32373,7 @@ var init_event_sink = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.16",
+  version: "0.10.18",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/skills",
-  "version": "0.10.16",
+  "version": "0.10.18",
   "description": "Skills library for AI coding agents",
   "type": "module",
   "bin": {