@skillsmith/cli 0.8.1 → 0.8.2

package/dist/cli.js

@@ -933,15 +933,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path23) => {
-      if (/^[a-z]+:\/\//i.test(path23)) {
-        return path23;
+    convertWslPathToWindows = async (path24) => {
+      if (/^[a-z]+:\/\//i.test(path24)) {
+        return path24;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path23], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path24], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path23;
+        return path24;
       }
     };
   }
@@ -1127,7 +1127,7 @@ __export(open_exports, {
   openApp: () => openApp
 });
 import process10 from "node:process";
-import path13 from "node:path";
+import path14 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import childProcess3 from "node:child_process";
 import fs16, { constants as fsConstants2 } from "node:fs/promises";
@@ -1160,8 +1160,8 @@ var init_open = __esm({
     init_is_inside_container();
     init_is_in_ssh();
     fallbackAttemptSymbol = /* @__PURE__ */ Symbol("fallbackAttempt");
-    __dirname = import.meta.url ? path13.dirname(fileURLToPath2(import.meta.url)) : "";
-    localXdgOpenPath = path13.join(__dirname, "xdg-open");
+    __dirname = import.meta.url ? path14.dirname(fileURLToPath2(import.meta.url)) : "";
+    localXdgOpenPath = path14.join(__dirname, "xdg-open");
     ({ platform, arch } = process10);
     tryEachApp = async (apps2, opener) => {
       if (apps2.length === 0) {
@@ -2345,29 +2345,29 @@ function relocateUnderHome(absolutePath, homeDir) {
 import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join5 } from "node:path";
 function writeOwnedArtifactFile(opts) {
-  const { path: path23, content, executable, backupDir } = opts;
-  if (existsSync3(path23)) {
-    const existing = readFileSync2(path23, "utf-8");
-    const currentlyExecutable = isExecutable(path23);
+  const { path: path24, content, executable, backupDir } = opts;
+  if (existsSync3(path24)) {
+    const existing = readFileSync2(path24, "utf-8");
+    const currentlyExecutable = isExecutable(path24);
     if (existing === content && currentlyExecutable === executable) {
       return { changed: false, backupPath: null };
     }
-    const backupPath = writeBackup(path23, backupDir);
-    mkdirSync2(dirname2(path23), { recursive: true });
-    writeFileSync2(path23, content, "utf-8");
+    const backupPath = writeBackup(path24, backupDir);
+    mkdirSync2(dirname2(path24), { recursive: true });
+    writeFileSync2(path24, content, "utf-8");
     if (executable)
-      chmodSync2(path23, 493);
+      chmodSync2(path24, 493);
     return { changed: true, backupPath };
   }
-  mkdirSync2(dirname2(path23), { recursive: true });
-  writeFileSync2(path23, content, "utf-8");
+  mkdirSync2(dirname2(path24), { recursive: true });
+  writeFileSync2(path24, content, "utf-8");
   if (executable)
-    chmodSync2(path23, 493);
+    chmodSync2(path24, 493);
   return { changed: true, backupPath: null };
 }
-function isExecutable(path23) {
+function isExecutable(path24) {
   try {
-    return (statSync(path23).mode & 73) !== 0;
+    return (statSync(path24).mode & 73) !== 0;
   } catch {
     return false;
   }
@@ -2397,11 +2397,11 @@ function getAgentInstallBackupsDir() {
   return join6(getAgentInstallDir(), "backups");
 }
 function loadAgentManifest() {
-  const path23 = getAgentManifestPath();
-  if (!existsSync4(path23))
+  const path24 = getAgentManifestPath();
+  if (!existsSync4(path24))
     return emptyManifest();
   try {
-    const parsed = JSON.parse(readFileSync3(path23, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(path24, "utf-8"));
     if (!parsed || !Array.isArray(parsed.entries))
       return emptyManifest();
     return {
@@ -2550,11 +2550,11 @@ import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as rea
 import { dirname as dirname3, join as join8 } from "node:path";
 
 // ../core/dist/src/install/agent-config-merge.types.js
-function shouldBackup(path23, alreadyBackedUpPaths) {
-  return !alreadyBackedUpPaths?.has(path23);
+function shouldBackup(path24, alreadyBackedUpPaths) {
+  return !alreadyBackedUpPaths?.has(path24);
 }
-function markBackedUp(path23, alreadyBackedUpPaths) {
-  alreadyBackedUpPaths?.add(path23);
+function markBackedUp(path24, alreadyBackedUpPaths) {
+  alreadyBackedUpPaths?.add(path24);
 }
 function looksLikeOurMcpEntry(value) {
   if (!value || typeof value !== "object")
@@ -2629,50 +2629,50 @@ function writeBackup2(sourcePath, backupDir) {
   return backupPath;
 }
 function mergeJsonMcpEntry(opts) {
-  const { path: path23, keyPath, entryValue, backupDir, force = false, alreadyBackedUpPaths } = opts;
+  const { path: path24, keyPath, entryValue, backupDir, force = false, alreadyBackedUpPaths } = opts;
   let doc = {};
   let existed = false;
-  if (existsSync5(path23)) {
+  if (existsSync5(path24)) {
     existed = true;
     let raw;
     try {
-      raw = readFileSync4(path23, "utf-8");
+      raw = readFileSync4(path24, "utf-8");
     } catch (e) {
-      return { status: "error", path: path23, backupPath: null, errorMessage: e.message };
+      return { status: "error", path: path24, backupPath: null, errorMessage: e.message };
     }
     try {
       const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return { status: "error", path: path23, backupPath: null, errorMessage: "not a JSON object" };
+        return { status: "error", path: path24, backupPath: null, errorMessage: "not a JSON object" };
       }
       doc = parsed;
     } catch (e) {
-      return { status: "error", path: path23, backupPath: null, errorMessage: e.message };
+      return { status: "error", path: path24, backupPath: null, errorMessage: e.message };
     }
   }
   const container = getAtPath(doc, keyPath);
   const existingEntry = container && typeof container === "object" && !Array.isArray(container) ? container.skillsmith : void 0;
   if (existingEntry !== void 0) {
     if (deepEqualJson(existingEntry, entryValue)) {
-      return { status: "unchanged", path: path23, backupPath: null };
+      return { status: "unchanged", path: path24, backupPath: null };
     }
     if (!looksLikeOurMcpEntry(existingEntry) && !force) {
-      return { status: "conflict", path: path23, backupPath: null };
+      return { status: "conflict", path: path24, backupPath: null };
     }
-    const backupPath2 = existed && shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup2(path23, backupDir) : null;
-    markBackedUp(path23, alreadyBackedUpPaths);
+    const backupPath2 = existed && shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup2(path24, backupDir) : null;
+    markBackedUp(path24, alreadyBackedUpPaths);
     setAtPath(doc, keyPath, { ...container, skillsmith: entryValue });
-    mkdirSync4(dirname3(path23), { recursive: true, mode: 448 });
-    writeFileSync4(path23, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
-    return { status: "updated", path: path23, backupPath: backupPath2 };
+    mkdirSync4(dirname3(path24), { recursive: true, mode: 448 });
+    writeFileSync4(path24, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
+    return { status: "updated", path: path24, backupPath: backupPath2 };
   }
-  const backupPath = existed && shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup2(path23, backupDir) : null;
-  markBackedUp(path23, alreadyBackedUpPaths);
+  const backupPath = existed && shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup2(path24, backupDir) : null;
+  markBackedUp(path24, alreadyBackedUpPaths);
   const currentContainer = container && typeof container === "object" && !Array.isArray(container) ? container : {};
   setAtPath(doc, keyPath, { ...currentContainer, skillsmith: entryValue });
-  mkdirSync4(dirname3(path23), { recursive: true, mode: 448 });
-  writeFileSync4(path23, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
-  return { status: "created", path: path23, backupPath };
+  mkdirSync4(dirname3(path24), { recursive: true, mode: 448 });
+  writeFileSync4(path24, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
+  return { status: "created", path: path24, backupPath };
 }
 
 // ../core/dist/src/install/agent-config-merge.yaml.js
@@ -2694,15 +2694,15 @@ function toPlainValue(node) {
   return node;
 }
 function mergeYamlMcpEntry(opts) {
-  const { path: path23, entryValue, backupDir, force = false, mcpServersKey, alreadyBackedUpPaths } = opts;
+  const { path: path24, entryValue, backupDir, force = false, mcpServersKey, alreadyBackedUpPaths } = opts;
   let doc;
-  const existed = existsSync6(path23);
+  const existed = existsSync6(path24);
   if (existed) {
     let raw;
     try {
-      raw = readFileSync5(path23, "utf-8");
+      raw = readFileSync5(path24, "utf-8");
     } catch (e) {
-      return { status: "error", path: path23, backupPath: null, errorMessage: e.message };
+      return { status: "error", path: path24, backupPath: null, errorMessage: e.message };
     }
     if (raw.trim().length === 0) {
       doc = new Document({});
@@ -2711,7 +2711,7 @@ function mergeYamlMcpEntry(opts) {
       if (parsed.errors.length > 0) {
         return {
           status: "error",
-          path: path23,
+          path: path24,
           backupPath: null,
           errorMessage: parsed.errors[0]?.message ?? "YAML parse error"
         };
@@ -2719,7 +2719,7 @@ function mergeYamlMcpEntry(opts) {
       if (parsed.contents !== null && isScalar(parsed.contents) && parsed.contents.value === null) {
         doc = new Document({});
       } else if (parsed.contents !== null && !isMap(parsed.contents)) {
-        return { status: "error", path: path23, backupPath: null, errorMessage: "not a YAML mapping" };
+        return { status: "error", path: path24, backupPath: null, errorMessage: "not a YAML mapping" };
       } else {
         doc = parsed;
       }
@@ -2730,24 +2730,24 @@ function mergeYamlMcpEntry(opts) {
   const existingEntry = toPlainValue(doc.getIn([mcpServersKey, "skillsmith"]));
   if (existingEntry !== void 0) {
     if (deepEqualJson(existingEntry, entryValue)) {
-      return { status: "unchanged", path: path23, backupPath: null };
+      return { status: "unchanged", path: path24, backupPath: null };
     }
     if (!looksLikeOurMcpEntry(existingEntry) && !force) {
-      return { status: "conflict", path: path23, backupPath: null };
+      return { status: "conflict", path: path24, backupPath: null };
     }
-    const backupPath2 = existed && shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup3(path23, backupDir) : null;
-    markBackedUp(path23, alreadyBackedUpPaths);
+    const backupPath2 = existed && shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup3(path24, backupDir) : null;
+    markBackedUp(path24, alreadyBackedUpPaths);
     doc.setIn([mcpServersKey, "skillsmith"], entryValue);
-    mkdirSync5(dirname4(path23), { recursive: true, mode: 448 });
-    writeFileSync5(path23, doc.toString(), { mode: 384 });
-    return { status: "updated", path: path23, backupPath: backupPath2 };
+    mkdirSync5(dirname4(path24), { recursive: true, mode: 448 });
+    writeFileSync5(path24, doc.toString(), { mode: 384 });
+    return { status: "updated", path: path24, backupPath: backupPath2 };
   }
-  const backupPath = existed && shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup3(path23, backupDir) : null;
-  markBackedUp(path23, alreadyBackedUpPaths);
+  const backupPath = existed && shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup3(path24, backupDir) : null;
+  markBackedUp(path24, alreadyBackedUpPaths);
   doc.setIn([mcpServersKey, "skillsmith"], entryValue);
-  mkdirSync5(dirname4(path23), { recursive: true, mode: 448 });
-  writeFileSync5(path23, doc.toString(), { mode: 384 });
-  return { status: "created", path: path23, backupPath };
+  mkdirSync5(dirname4(path24), { recursive: true, mode: 448 });
+  writeFileSync5(path24, doc.toString(), { mode: 384 });
+  return { status: "created", path: path24, backupPath };
 }
 
 // ../core/dist/src/install/agent-config-merge.toml-block.js
@@ -2768,17 +2768,17 @@ function writeBackup4(sourcePath, backupDir) {
   return backupPath;
 }
 function mergeTomlBlock(opts) {
-  const { path: path23, markerId, blockContent, foreignHeaderPattern, backupDir, force = false, alreadyBackedUpPaths } = opts;
+  const { path: path24, markerId, blockContent, foreignHeaderPattern, backupDir, force = false, alreadyBackedUpPaths } = opts;
   const start = markerStart(markerId);
   const end = markerEnd(markerId);
   const trimmedBlock = blockContent.trim();
-  const existed = existsSync7(path23);
+  const existed = existsSync7(path24);
   let raw = "";
   if (existed) {
     try {
-      raw = readFileSync6(path23, "utf-8");
+      raw = readFileSync6(path24, "utf-8");
     } catch (e) {
-      return { status: "error", path: path23, backupPath: null, errorMessage: e.message };
+      return { status: "error", path: path24, backupPath: null, errorMessage: e.message };
     }
   }
   const blockRegex = new RegExp(`${escapeRegExp(start)}\\n([\\s\\S]*?)\\n${escapeRegExp(end)}`);
@@ -2786,31 +2786,31 @@ function mergeTomlBlock(opts) {
   if (match) {
     const existingBlock = (match[1] ?? "").trim();
     if (existingBlock === trimmedBlock) {
-      return { status: "unchanged", path: path23, backupPath: null };
+      return { status: "unchanged", path: path24, backupPath: null };
     }
-    const backupPath2 = shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup4(path23, backupDir) : null;
-    markBackedUp(path23, alreadyBackedUpPaths);
+    const backupPath2 = shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup4(path24, backupDir) : null;
+    markBackedUp(path24, alreadyBackedUpPaths);
     const replacement = `${start}
 ${trimmedBlock}
 ${end}`;
     const updated = raw.replace(blockRegex, replacement);
-    writeFileSync6(path23, updated, { mode: 384 });
-    return { status: "updated", path: path23, backupPath: backupPath2 };
+    writeFileSync6(path24, updated, { mode: 384 });
+    return { status: "updated", path: path24, backupPath: backupPath2 };
   }
   if (foreignHeaderPattern.test(raw)) {
     void force;
-    return { status: "conflict", path: path23, backupPath: null };
+    return { status: "conflict", path: path24, backupPath: null };
   }
-  const backupPath = existed && shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup4(path23, backupDir) : null;
-  markBackedUp(path23, alreadyBackedUpPaths);
+  const backupPath = existed && shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup4(path24, backupDir) : null;
+  markBackedUp(path24, alreadyBackedUpPaths);
   const separator = raw.length > 0 && !raw.endsWith("\n\n") ? raw.endsWith("\n") ? "\n" : "\n\n" : "";
   const appended = `${raw}${separator}${start}
 ${trimmedBlock}
 ${end}
 `;
-  mkdirSync6(dirname5(path23), { recursive: true, mode: 448 });
-  writeFileSync6(path23, appended, { mode: 384 });
-  return { status: "created", path: path23, backupPath };
+  mkdirSync6(dirname5(path24), { recursive: true, mode: 448 });
+  writeFileSync6(path24, appended, { mode: 384 });
+  return { status: "created", path: path24, backupPath };
 }
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -2850,24 +2850,24 @@ function writeBackup5(sourcePath, backupDir) {
   return backupPath;
 }
 function mergeJsonArrayEntry(opts) {
-  const { path: path23, keyPath, entry, isOurEntry, backupDir, alreadyBackedUpPaths } = opts;
+  const { path: path24, keyPath, entry, isOurEntry, backupDir, alreadyBackedUpPaths } = opts;
   let doc = {};
-  const existed = existsSync8(path23);
+  const existed = existsSync8(path24);
   if (existed) {
     let raw;
     try {
-      raw = readFileSync7(path23, "utf-8");
+      raw = readFileSync7(path24, "utf-8");
     } catch (e) {
-      return { status: "error", path: path23, backupPath: null, errorMessage: e.message };
+      return { status: "error", path: path24, backupPath: null, errorMessage: e.message };
     }
     try {
       const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return { status: "error", path: path23, backupPath: null, errorMessage: "not a JSON object" };
+        return { status: "error", path: path24, backupPath: null, errorMessage: "not a JSON object" };
       }
       doc = parsed;
     } catch (e) {
-      return { status: "error", path: path23, backupPath: null, errorMessage: e.message };
+      return { status: "error", path: path24, backupPath: null, errorMessage: e.message };
     }
   }
   const rawArray = getAtPath2(doc, keyPath);
@@ -2875,23 +2875,23 @@ function mergeJsonArrayEntry(opts) {
   const existingIndex = array2.findIndex(isOurEntry);
   if (existingIndex >= 0) {
     if (deepEqualJson(array2[existingIndex], entry)) {
-      return { status: "unchanged", path: path23, backupPath: null };
+      return { status: "unchanged", path: path24, backupPath: null };
     }
-    const backupPath2 = existed && shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup5(path23, backupDir) : null;
-    markBackedUp(path23, alreadyBackedUpPaths);
+    const backupPath2 = existed && shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup5(path24, backupDir) : null;
+    markBackedUp(path24, alreadyBackedUpPaths);
     array2[existingIndex] = entry;
     setAtPath2(doc, keyPath, array2);
-    mkdirSync7(dirname6(path23), { recursive: true, mode: 448 });
-    writeFileSync7(path23, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
-    return { status: "updated", path: path23, backupPath: backupPath2 };
+    mkdirSync7(dirname6(path24), { recursive: true, mode: 448 });
+    writeFileSync7(path24, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
+    return { status: "updated", path: path24, backupPath: backupPath2 };
   }
-  const backupPath = existed && shouldBackup(path23, alreadyBackedUpPaths) ? writeBackup5(path23, backupDir) : null;
-  markBackedUp(path23, alreadyBackedUpPaths);
+  const backupPath = existed && shouldBackup(path24, alreadyBackedUpPaths) ? writeBackup5(path24, backupDir) : null;
+  markBackedUp(path24, alreadyBackedUpPaths);
   array2.push(entry);
   setAtPath2(doc, keyPath, array2);
-  mkdirSync7(dirname6(path23), { recursive: true, mode: 448 });
-  writeFileSync7(path23, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
-  return { status: "created", path: path23, backupPath };
+  mkdirSync7(dirname6(path24), { recursive: true, mode: 448 });
+  writeFileSync7(path24, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
+  return { status: "created", path: path24, backupPath };
 }
 
 // ../core/dist/src/install/agent-pack-installer.entry.js
@@ -2945,16 +2945,16 @@ function installShim(harness, artifact, ctx, report) {
   const target = AGENT_SHIM_TARGETS[harness];
   if (!target || !artifact)
     return;
-  const path23 = relocateUnderHome(target.path, ctx.homeDir);
+  const path24 = relocateUnderHome(target.path, ctx.homeDir);
   const result = writeOwnedArtifactFile({
-    path: path23,
+    path: path24,
     content: artifact.content,
     executable: false,
     backupDir: ctx.backupDir
   });
   report.shimWritten = true;
   ctx.entries.push({
-    path: path23,
+    path: path24,
     kind: "shim",
     harness,
     backupPath: result.backupPath,
@@ -3104,9 +3104,9 @@ function installCodexAgentsShim(artifact, ctx, report) {
   const target = AGENT_MCP_TARGETS.codex;
   if (!artifact)
     return;
-  const path23 = relocateUnderHome(target.path, ctx.homeDir);
+  const path24 = relocateUnderHome(target.path, ctx.homeDir);
   const result = mergeTomlBlock({
-    path: path23,
+    path: path24,
     markerId: "agents.skillsmith-agent",
     blockContent: artifact.content,
     foreignHeaderPattern: CODEX_AGENTS_FOREIGN_HEADER,
@@ -3117,7 +3117,7 @@ function installCodexAgentsShim(artifact, ctx, report) {
   if (mergeSucceeded(result.status)) {
     report.shimWritten = true;
     ctx.entries.push({
-      path: path23,
+      path: path24,
       kind: "shim",
       harness: "codex",
       backupPath: result.backupPath,
@@ -3125,32 +3125,32 @@ function installCodexAgentsShim(artifact, ctx, report) {
     });
   }
   if (result.status === "conflict") {
-    report.notes.push(`Codex agent entry at ${path23} already has a hand-written [agents.skillsmith-agent] table \u2014 left untouched.`);
+    report.notes.push(`Codex agent entry at ${path24} already has a hand-written [agents.skillsmith-agent] table \u2014 left untouched.`);
   }
   if (result.status === "error") {
-    report.notes.push(`Codex agent entry merge failed at ${path23}: ${result.errorMessage}`);
+    report.notes.push(`Codex agent entry merge failed at ${path24}: ${result.errorMessage}`);
   }
 }
 function installMcpConfig(harness, ctx, report) {
   const target = AGENT_MCP_TARGETS[harness];
-  const path23 = relocateUnderHome(target.path, ctx.homeDir);
+  const path24 = relocateUnderHome(target.path, ctx.homeDir);
   const entryValue = harness === "opencode" ? buildOpenCodeMcpEntryValue() : buildAgentMcpEntryValue();
   const result = target.format === "json" ? mergeJsonMcpEntry({
-    path: path23,
+    path: path24,
     keyPath: target.keyPath,
     entryValue,
     backupDir: ctx.backupDir,
     force: ctx.force,
     alreadyBackedUpPaths: ctx.backedUpPaths
   }) : target.format === "yaml" ? mergeYamlMcpEntry({
-    path: path23,
+    path: path24,
     mcpServersKey: target.keyPath[0] ?? "mcp_servers",
     entryValue,
     backupDir: ctx.backupDir,
     force: ctx.force,
     alreadyBackedUpPaths: ctx.backedUpPaths
   }) : mergeTomlBlock({
-    path: path23,
+    path: path24,
     markerId: "mcp_servers.skillsmith",
     blockContent: buildCodexMcpTomlBlock(),
     foreignHeaderPattern: CODEX_MCP_FOREIGN_HEADER,
@@ -3161,7 +3161,7 @@ function installMcpConfig(harness, ctx, report) {
   report.mcpConfig = result;
   if (mergeSucceeded(result.status)) {
     ctx.entries.push({
-      path: path23,
+      path: path24,
       kind: "mcp-config",
       harness,
       backupPath: result.backupPath,
@@ -3169,10 +3169,10 @@ function installMcpConfig(harness, ctx, report) {
     });
   }
   if (result.status === "conflict") {
-    report.notes.push(`MCP config at ${path23} already has a 'skillsmith' entry that doesn't look like ours \u2014 left untouched. Re-run with --force to overwrite, or edit ${path23} manually.`);
+    report.notes.push(`MCP config at ${path24} already has a 'skillsmith' entry that doesn't look like ours \u2014 left untouched. Re-run with --force to overwrite, or edit ${path24} manually.`);
   }
   if (result.status === "error") {
-    report.notes.push(`MCP config merge failed at ${path23}: ${result.errorMessage}`);
+    report.notes.push(`MCP config merge failed at ${path24}: ${result.errorMessage}`);
   }
 }
 
@@ -3196,15 +3196,15 @@ function isCodexPresent(homeDir) {
   return existsSync9(relocateUnderHome(join13(homedir6(), ".codex"), homeDir));
 }
 function writeSkillPackFor(clientNativePath, content, ctx, harness) {
-  const path23 = join13(relocateUnderHome(clientNativePath, ctx.homeDir), AGENT_PACK_SKILL_NAME, "SKILL.md");
+  const path24 = join13(relocateUnderHome(clientNativePath, ctx.homeDir), AGENT_PACK_SKILL_NAME, "SKILL.md");
   const result = writeOwnedArtifactFile({
-    path: path23,
+    path: path24,
     content,
     executable: false,
     backupDir: ctx.backupDir
   });
   ctx.entries.push({
-    path: path23,
+    path: path24,
     kind: "skill",
     harness,
     backupPath: result.backupPath,
@@ -3358,8 +3358,8 @@ function allowedPathSuffixes() {
     cachedSuffixes = computeAllowedPathSuffixes();
   return cachedSuffixes;
 }
-function isAllowedManifestEntryPath(path23) {
-  const normalized = resolve2(path23);
+function isAllowedManifestEntryPath(path24) {
+  const normalized = resolve2(path24);
   for (const suffix of allowedPathSuffixes()) {
     if (normalized.endsWith(sep + suffix) || normalized === suffix)
       return true;
@@ -6629,10 +6629,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path23) {
-  if (!path23)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path23.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6998,11 +6998,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path23, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path23);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -7164,7 +7164,7 @@ function formatError(error46, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error46, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error47, path23 = []) => {
+  const processError = (error47, path24 = []) => {
     var _a2, _b;
     for (const issue2 of error47.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -7174,7 +7174,7 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path23, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7206,8 +7206,8 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path23 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path23) {
+  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path24) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -19007,13 +19007,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path23 = ref.slice(1).split("/").filter(Boolean);
-  if (path23.length === 0) {
+  const path24 = ref.slice(1).split("/").filter(Boolean);
+  if (path24.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path23[0] === defsKey) {
-    const key = path23[1];
+  if (path24[0] === defsKey) {
+    const key = path24[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19617,19 +19617,19 @@ function validateUrl(url2) {
 
 // ../core/dist/src/validation/path-validators.js
 import { resolve as resolve3 } from "path";
-function validatePath(path23, rootDir) {
-  if (!path23) {
+function validatePath(path24, rootDir) {
+  if (!path24) {
     throw new ValidationError("Path cannot be empty", "EMPTY_PATH");
   }
   if (!rootDir) {
     throw new ValidationError("Root directory cannot be empty", "EMPTY_ROOT_DIR");
   }
-  const normalizedPath = resolve3(rootDir, path23);
+  const normalizedPath = resolve3(rootDir, path24);
   const normalizedRoot = resolve3(rootDir);
   const isWithinRoot = normalizedPath.startsWith(normalizedRoot + "/") || normalizedPath === normalizedRoot;
   if (!isWithinRoot) {
-    throw new ValidationError(`Path traversal detected: ${path23}`, "PATH_TRAVERSAL", {
-      originalPath: path23,
+    throw new ValidationError(`Path traversal detected: ${path24}`, "PATH_TRAVERSAL", {
+      originalPath: path24,
       normalizedPath,
       rootDir,
       normalizedRoot
@@ -20403,8 +20403,8 @@ function implicitDownloadBasename(line) {
     const slash = noFrag.indexOf("/");
     if (slash < 0)
       return "";
-    const path23 = noFrag.slice(slash + 1).replace(/\/+$/, "");
-    return path23 === "" ? "" : path23.split("/").pop() ?? "";
+    const path24 = noFrag.slice(slash + 1).replace(/\/+$/, "");
+    return path24 === "" ? "" : path24.split("/").pop() ?? "";
   };
   const wget = line.match(/\bwget\b(?![^\n]{0,200}\s-[oO]\b)[^\n]{0,200}?https?:\/\/(\S{1,400})/i);
   if (wget)
@@ -22356,21 +22356,21 @@ function mapErrnoToCode(err) {
       return "io";
   }
 }
-function describe3(code, path23) {
+function describe3(code, path24) {
   switch (code) {
     case "permission":
-      return `Cannot read: ${path23}`;
+      return `Cannot read: ${path24}`;
     case "not-found":
-      return `Not found: ${path23}`;
+      return `Not found: ${path24}`;
     case "loop":
-      return `Symlink loop detected: ${path23}`;
+      return `Symlink loop detected: ${path24}`;
     case "symlink-escape":
-      return `Symlink outside root, skipped: ${path23}`;
+      return `Symlink outside root, skipped: ${path24}`;
     case "io":
-      return `Filesystem error: ${path23}`;
+      return `Filesystem error: ${path24}`;
   }
 }
-async function wrap(path23, op) {
+async function wrap(path24, op) {
   try {
     return { ok: true, value: await op() };
   } catch (error46) {
@@ -22379,25 +22379,25 @@ async function wrap(path23, op) {
       ok: false,
       error: {
         code,
-        path: path23,
-        message: describe3(code, path23),
+        path: path24,
+        message: describe3(code, path24),
         cause: error46
       }
     };
   }
 }
 var safeFs = {
-  readdir(path23) {
-    return wrap(path23, () => fs2.readdir(path23, { withFileTypes: true }));
+  readdir(path24) {
+    return wrap(path24, () => fs2.readdir(path24, { withFileTypes: true }));
   },
-  stat(path23) {
-    return wrap(path23, () => fs2.stat(path23));
+  stat(path24) {
+    return wrap(path24, () => fs2.stat(path24));
   },
-  readFile(path23, encoding = "utf-8") {
-    return wrap(path23, () => fs2.readFile(path23, encoding));
+  readFile(path24, encoding = "utf-8") {
+    return wrap(path24, () => fs2.readFile(path24, encoding));
   },
-  realpath(path23) {
-    return wrap(path23, () => fs2.realpath(path23));
+  realpath(path24) {
+    return wrap(path24, () => fs2.realpath(path24));
   }
 };
 function isRealpathContained(candidateReal, rootReal) {
@@ -22803,8 +22803,8 @@ var LocalFilesystemAdapter = class extends BaseSourceAdapter {
   /**
    * Generate a deterministic ID from a path
    */
-  generateId(path23) {
-    return createHash2("sha256").update(path23).digest("hex").slice(0, 16);
+  generateId(path24) {
+    return createHash2("sha256").update(path24).digest("hex").slice(0, 16);
   }
   /**
    * Generate SHA hash for content
@@ -23311,7 +23311,7 @@ var BetterSqlite3Database = class {
     return this.db;
   }
 };
-function createBetterSqlite3Database(path23 = ":memory:", options) {
+function createBetterSqlite3Database(path24 = ":memory:", options) {
   const Database = require2("better-sqlite3");
   const dbOptions = {
     timeout: options?.timeout ?? 5e3
@@ -23325,7 +23325,7 @@ function createBetterSqlite3Database(path23 = ":memory:", options) {
   if (options?.verbose) {
     dbOptions.verbose = console.log;
   }
-  const db = new Database(path23, dbOptions);
+  const db = new Database(path24, dbOptions);
   return new BetterSqlite3Database(db);
 }
 var betterSqlite3FailureReason;
@@ -23362,16 +23362,16 @@ function isCorruptionError(err) {
   const message = (err instanceof Error ? err.message : typeof err === "string" ? err : String(err)).toLowerCase();
   return CORRUPTION_MARKERS.some((marker) => message.includes(marker));
 }
-function backupCorruptDbFile(path23) {
-  if (path23 === ":memory:") {
+function backupCorruptDbFile(path24) {
+  if (path24 === ":memory:") {
     throw new Error("[Skillsmith] backupCorruptDbFile: cannot back up an in-memory database");
   }
-  if (!existsSync12(path23)) {
-    throw new Error(`[Skillsmith] backupCorruptDbFile: file does not exist: ${path23}`);
+  if (!existsSync12(path24)) {
+    throw new Error(`[Skillsmith] backupCorruptDbFile: file does not exist: ${path24}`);
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupPath = `${path23}.corrupt-${timestamp}`;
-  renameSync(path23, backupPath);
+  const backupPath = `${path24}.corrupt-${timestamp}`;
+  renameSync(path24, backupPath);
   return backupPath;
 }
 
@@ -23603,13 +23603,13 @@ var SqlJsDatabaseAdapter = class {
     return this.db;
   }
 };
-async function createSqlJsDatabase(path23 = ":memory:", options) {
+async function createSqlJsDatabase(path24 = ":memory:", options) {
   const SQL = await loadSqlJs();
   let data;
-  if (path23 !== ":memory:" && existsSync13(path23)) {
-    data = readFileSync10(path23);
-  } else if (path23 !== ":memory:" && options?.fileMustExist) {
-    throw new Error(`SQLITE_CANTOPEN: unable to open database file: ${path23}`);
+  if (path24 !== ":memory:" && existsSync13(path24)) {
+    data = readFileSync10(path24);
+  } else if (path24 !== ":memory:" && options?.fileMustExist) {
+    throw new Error(`SQLITE_CANTOPEN: unable to open database file: ${path24}`);
   }
   let db;
   let partialDb;
@@ -23627,15 +23627,15 @@ async function createSqlJsDatabase(path23 = ":memory:", options) {
       } catch {
       }
     }
-    if (!isCorruptionError(error46) || path23 === ":memory:" || !existsSync13(path23)) {
+    if (!isCorruptionError(error46) || path24 === ":memory:" || !existsSync13(path24)) {
       throw error46;
     }
-    const backupPath = backupCorruptDbFile(path23);
-    console.warn(`[Skillsmith] The local database at ${path23} was corrupt and could not be opened. It has been backed up to ${backupPath} and will be rebuilt on the next sync.`);
+    const backupPath = backupCorruptDbFile(path24);
+    console.warn(`[Skillsmith] The local database at ${path24} was corrupt and could not be opened. It has been backed up to ${backupPath} and will be rebuilt on the next sync.`);
     db = new SQL.Database();
     db.run("PRAGMA foreign_keys = ON");
   }
-  return new SqlJsDatabaseAdapter(db, path23, options);
+  return new SqlJsDatabaseAdapter(db, path24, options);
 }
 function isSqlJsAvailable() {
   try {
@@ -23648,21 +23648,21 @@ function isSqlJsAvailable() {
 
 // ../core/dist/src/db/createDatabase.js
 var wasmFallbackNoticeEmitted = false;
-function createDatabaseSync(path23 = ":memory:", options) {
+function createDatabaseSync(path24 = ":memory:", options) {
   if (!isBetterSqlite3Available()) {
     throw new Error("[Skillsmith] Native SQLite module (better-sqlite3) is not available. This may be due to:\n  - Binary compiled for a different platform (Linux vs macOS)\n  - Node.js version mismatch\n  - Missing native build tools\n\nSolutions:\n  - Run in Docker: docker compose --profile dev up -d\n  - Rebuild native module: npm rebuild better-sqlite3\n  - Use createDatabaseAsync() for automatic WASM fallback");
   }
-  return createBetterSqlite3Database(path23, options);
+  return createBetterSqlite3Database(path24, options);
 }
-async function createDatabaseAsync(path23 = ":memory:", options) {
+async function createDatabaseAsync(path24 = ":memory:", options) {
   if (process.env.SKILLSMITH_FORCE_WASM === "true") {
     if (isSqlJsAvailable()) {
-      return await createSqlJsDatabase(path23, options);
+      return await createSqlJsDatabase(path24, options);
     }
     throw new Error("[Skillsmith] SKILLSMITH_FORCE_WASM is set but sql.js (WASM) is not available.\n\nInstall sql.js: npm install sql.js");
   }
   if (isBetterSqlite3Available()) {
-    return createBetterSqlite3Database(path23, options);
+    return createBetterSqlite3Database(path24, options);
   }
   if (isSqlJsAvailable()) {
     if (!wasmFallbackNoticeEmitted) {
@@ -23676,7 +23676,7 @@ async function createDatabaseAsync(path23 = ":memory:", options) {
       }
       console.warn(message);
     }
-    return await createSqlJsDatabase(path23, options);
+    return await createSqlJsDatabase(path24, options);
   }
   throw new Error("[Skillsmith] No SQLite driver available.\n\nNeither better-sqlite3 (native) nor sql.js (WASM) could be loaded.\n\nSolutions:\n  - Run in Docker: docker compose --profile dev up -d\n  - Rebuild native module: npm rebuild better-sqlite3\n  - Install sql.js: npm install sql.js");
 }
@@ -25687,11 +25687,11 @@ var INVENTORY_LIMITS = {
 import { readdir as readdir3, readFile as readFile2, realpath, stat as stat2 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
 import { join as join21 } from "node:path";
-async function safeRealpath(path23) {
+async function safeRealpath(path24) {
   try {
-    return await realpath(path23);
+    return await realpath(path24);
   } catch {
-    return path23;
+    return path24;
   }
 }
 async function resolvesToDirectory(entryPath, isDirectory, isSymbolicLink) {
@@ -28204,8 +28204,8 @@ function initializeSchema(db) {
   db.prepare("INSERT OR IGNORE INTO schema_version (version) VALUES (1)").run();
   runMigrations(db);
 }
-function openDatabase(path23) {
-  const db = createDatabaseSync(path23);
+function openDatabase(path24) {
+  const db = createDatabaseSync(path24);
   db.pragma("foreign_keys = ON");
   const hasSchemaVersion = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
   if (!hasSchemaVersion) {
@@ -32103,17 +32103,17 @@ function getCliLogger() {
 // src/utils/open-database.ts
 import { existsSync as existsSync19 } from "node:fs";
 var logger8 = getCliLogger();
-async function openCliDatabase(path23, options) {
+async function openCliDatabase(path24, options) {
   if (options?.readonly) {
-    return createDatabaseAsync(path23, { readonly: true });
+    return createDatabaseAsync(path24, { readonly: true });
   }
   let db;
   try {
-    db = await createDatabaseAsync(path23);
+    db = await createDatabaseAsync(path24);
     initializeSchema(db);
     return db;
   } catch (err) {
-    if (!isCorruptionError(err) || path23 === ":memory:" || !existsSync19(path23)) {
+    if (!isCorruptionError(err) || path24 === ":memory:" || !existsSync19(path24)) {
       throw err;
     }
     if (db) {
@@ -32122,11 +32122,11 @@ async function openCliDatabase(path23, options) {
       } catch {
       }
     }
-    const backupPath = backupCorruptDbFile(path23);
+    const backupPath = backupCorruptDbFile(path24);
     logger8.warn(
-      `[Skillsmith] The local database at ${path23} was corrupt and could not be opened. It has been backed up to ${backupPath} and will be rebuilt on the next sync.`
+      `[Skillsmith] The local database at ${path24} was corrupt and could not be opened. It has been backed up to ${backupPath} and will be rebuilt on the next sync.`
     );
-    const fresh = await createDatabaseAsync(path23);
+    const fresh = await createDatabaseAsync(path24);
     initializeSchema(fresh);
     return fresh;
   }
@@ -32135,6 +32135,7 @@ async function openCliDatabase(path23, options) {
 // src/commands/install.ts
 import { Command } from "commander";
 import ora from "ora";
+import * as path13 from "node:path";
 
 // src/utils/sanitize.ts
 import { homedir as homedir18 } from "os";
@@ -32347,10 +32348,11 @@ async function installActionImpl(skillId, opts) {
         ...!result.success && result.errorCode !== void 0 && { errorCode: result.errorCode }
       });
       if (result.success && alsoLinkClients.length > 0) {
+        const linkSkillName = path13.basename(result.installPath);
         for (const target of alsoLinkClients) {
           try {
             const linked = await addLink({
-              skillId,
+              skillId: linkSkillName,
               fromClient: client,
               toClient: target,
               preferSymlink: opts.symlink ?? false,
@@ -33534,9 +33536,9 @@ Validation Result for ${filePath}:
   }
   console.log();
 }
-async function fileExists(path23) {
+async function fileExists(path24) {
   try {
-    await access3(path23);
+    await access3(path24);
     return true;
   } catch {
     return false;
@@ -34857,7 +34859,7 @@ function createPublishCommand() {
 import { Command as Command5 } from "commander";
 import ora6 from "ora";
 import { readFile as readFile9, writeFile as writeFile6, stat as stat8 } from "fs/promises";
-import { basename as basename4, dirname as dirname18, join as join41, resolve as resolve11 } from "path";
+import { basename as basename5, dirname as dirname18, join as join41, resolve as resolve11 } from "path";
 
 // src/utils/tool-analyzer.ts
 var TOOL_PATTERNS3 = {
@@ -35039,7 +35041,7 @@ async function generateSubagent2(skillPath, options) {
       return;
     }
     const agentsDir = await ensureAgentsDirectory(options.output);
-    const subagentPath = join41(agentsDir, `${basename4(metadata.name)}-specialist.md`);
+    const subagentPath = join41(agentsDir, `${basename5(metadata.name)}-specialist.md`);
     if (await fileExists(subagentPath)) {
       if (!options.force) {
         spinner.warn(`Subagent already exists: ${subagentPath}`);
@@ -36613,9 +36615,9 @@ function getAssetsPath() {
 function getTargetPath() {
   return join45(getCanonicalInstallPath(), "skillsmith");
 }
-async function directoryExists(path23) {
+async function directoryExists(path24) {
   try {
-    const stats = await stat10(path23);
+    const stats = await stat10(path24);
     return stats.isDirectory();
   } catch {
     return false;
@@ -37533,7 +37535,7 @@ import { Command as Command21 } from "commander";
 
 // src/commands/audit-collisions.ts
 import * as crypto11 from "node:crypto";
-import * as fs32 from "node:fs";
+import * as fs33 from "node:fs";
 import { homedir as homedir29 } from "node:os";
 import { join as join58 } from "node:path";
 import { Command as Command18 } from "commander";
@@ -37543,7 +37545,7 @@ import { input as input4, select as select3 } from "@inquirer/prompts";
 import * as crypto3 from "node:crypto";
 import * as fs17 from "node:fs/promises";
 import * as os7 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 
 // ../mcp-server/node_modules/ulid/dist/node/index.js
 import crypto2 from "node:crypto";
@@ -37641,15 +37643,15 @@ function ulid3(seedTime, prng) {
 }
 
 // ../mcp-server/dist/src/audit/audit-history.js
-var DEFAULT_AUDITS_DIR = path14.join(os7.homedir(), ".skillsmith", "audits");
+var DEFAULT_AUDITS_DIR = path15.join(os7.homedir(), ".skillsmith", "audits");
 function newAuditId() {
   return ulid3();
 }
 async function writeAuditHistory(result, opts = {}) {
   const auditsDir = opts.auditsDir ?? DEFAULT_AUDITS_DIR;
-  const auditDir = path14.join(auditsDir, result.auditId);
-  const resultPath = path14.join(auditDir, "result.json");
-  const reportPath = path14.join(auditDir, "report.md");
+  const auditDir = path15.join(auditsDir, result.auditId);
+  const resultPath = path15.join(auditDir, "result.json");
+  const reportPath = path15.join(auditDir, "report.md");
   const tmpPath = `${resultPath}.tmp`;
   await fs17.mkdir(auditDir, { recursive: true });
   const json2 = JSON.stringify(result, null, 2);
@@ -38149,8 +38151,8 @@ function getErrorMap2() {
 
 // ../mcp-server/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path23, errorMaps, issueData } = params;
-  const fullPath = [...path23, ...issueData.path || []];
+  const { data, path: path24, errorMaps, issueData } = params;
+  const fullPath = [...path24, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -38266,11 +38268,11 @@ var errorUtil;
 
 // ../mcp-server/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path23, key) {
+  constructor(parent, value, path24, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path23;
+    this._path = path24;
     this._key = key;
   }
   get path() {
@@ -42545,7 +42547,7 @@ function nsToMs(ns) {
 
 // ../mcp-server/dist/src/audit/audit-report-writer.js
 import * as fs19 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 function renderAuditReport(result, opts = {}) {
   const generatedAt = opts.generatedAt ?? /* @__PURE__ */ new Date();
   const sections = [];
@@ -42572,7 +42574,7 @@ function renderAuditReport(result, opts = {}) {
   return sections.join("\n").trimEnd() + "\n";
 }
 async function writeAuditReport(result, opts) {
-  const reportPath = path15.join(opts.auditDir, "report.md");
+  const reportPath = path16.join(opts.auditDir, "report.md");
   const tmpPath = `${reportPath}.tmp`;
   await fs19.mkdir(opts.auditDir, { recursive: true });
   const body = renderAuditReport(result, {
@@ -42757,28 +42759,28 @@ import * as os10 from "node:os";
 // ../mcp-server/dist/src/utils/local-inventory.js
 import * as fs20 from "node:fs";
 import * as os8 from "node:os";
-import * as path16 from "node:path";
-var DEFAULT_HOME_CLAUDE_DIR = path16.join(os8.homedir(), ".claude");
-var DEFAULT_MANIFEST_PATH3 = path16.join(os8.homedir(), ".skillsmith", "manifest.json");
+import * as path17 from "node:path";
+var DEFAULT_HOME_CLAUDE_DIR = path17.join(os8.homedir(), ".claude");
+var DEFAULT_MANIFEST_PATH3 = path17.join(os8.homedir(), ".skillsmith", "manifest.json");
 async function scanLocalInventory(opts = {}) {
   const startedAt = process.hrtime.bigint();
   const homeDir = opts.homeDir ?? os8.homedir();
-  const claudeDir = opts.homeDir ? path16.join(opts.homeDir, ".claude") : DEFAULT_HOME_CLAUDE_DIR;
+  const claudeDir = opts.homeDir ? path17.join(opts.homeDir, ".claude") : DEFAULT_HOME_CLAUDE_DIR;
   const manifestPath = opts.manifestPath ?? DEFAULT_MANIFEST_PATH3;
   const warnings = [];
   const entries = [];
   const manifest = loadManifest3(manifestPath);
-  entries.push(...scanSkills(path16.join(claudeDir, "skills"), manifest, warnings));
-  const agentsSkillsDir = opts.homeDir ? path16.join(opts.homeDir, ".agents", "skills") : path16.join(os8.homedir(), ".agents", "skills");
+  entries.push(...scanSkills(path17.join(claudeDir, "skills"), manifest, warnings));
+  const agentsSkillsDir = opts.homeDir ? path17.join(opts.homeDir, ".agents", "skills") : path17.join(os8.homedir(), ".agents", "skills");
   entries.push(...scanSkills(agentsSkillsDir, manifest, warnings));
-  entries.push(...scanCommands(path16.join(claudeDir, "commands"), warnings));
-  entries.push(...scanAgents(path16.join(claudeDir, "agents"), warnings));
-  const userClaudeMd = path16.join(claudeDir, "CLAUDE.md");
+  entries.push(...scanCommands(path17.join(claudeDir, "commands"), warnings));
+  entries.push(...scanAgents(path17.join(claudeDir, "agents"), warnings));
+  const userClaudeMd = path17.join(claudeDir, "CLAUDE.md");
   if (fs20.existsSync(userClaudeMd)) {
     entries.push(...extractClaudeMdTriggers(userClaudeMd, warnings));
   }
   if (opts.projectDir) {
-    const projectClaudeMd = path16.join(opts.projectDir, "CLAUDE.md");
+    const projectClaudeMd = path17.join(opts.projectDir, "CLAUDE.md");
     if (fs20.existsSync(projectClaudeMd)) {
       entries.push(...extractClaudeMdTriggers(projectClaudeMd, warnings));
     }
@@ -42806,8 +42808,8 @@ function scanSkills(skillsDir, manifest, warnings) {
   for (const dirent of dirEntries) {
     if (!dirent.isDirectory() || dirent.name.startsWith("."))
       continue;
-    const skillDir = path16.join(skillsDir, dirent.name);
-    const skillMd = path16.join(skillDir, "SKILL.md");
+    const skillDir = path17.join(skillsDir, dirent.name);
+    const skillMd = path17.join(skillDir, "SKILL.md");
     let identifier = dirent.name;
     let description;
     let mtime;
@@ -42869,7 +42871,7 @@ function scanMdDir(dir, kind, warnings) {
       continue;
     if (dirent.name.startsWith("."))
       continue;
-    const filePath = path16.join(dir, dirent.name);
+    const filePath = path17.join(dir, dirent.name);
     const identifier = dirent.name.slice(0, -3);
     const fm = readFrontmatter2(filePath);
     const description = coerceDescription2(fm.description);
@@ -42904,10 +42906,10 @@ function coerceDescription2(value) {
 // ../mcp-server/dist/src/audit/security-baseline.js
 import * as fs21 from "node:fs";
 import * as os9 from "node:os";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 var SECURITY_BASELINE_VERSION = 1;
 function defaultBaselinePath(homeDir = os9.homedir()) {
-  return path17.join(homeDir, ".skillsmith", "audits", "security-baseline.json");
+  return path18.join(homeDir, ".skillsmith", "audits", "security-baseline.json");
 }
 function emptyBaseline() {
   return { version: SECURITY_BASELINE_VERSION, skills: {} };
@@ -42930,7 +42932,7 @@ function loadSecurityBaseline(baselinePath) {
   }
 }
 function saveSecurityBaseline(baselinePath, baseline) {
-  const dir = path17.dirname(baselinePath);
+  const dir = path18.dirname(baselinePath);
   fs21.mkdirSync(dir, { recursive: true, mode: 448 });
   const tmp = `${baselinePath}.tmp-${process.pid}-${process.hrtime.bigint()}`;
   fs21.writeFileSync(tmp, JSON.stringify(baseline, null, 2), { mode: 384 });
@@ -43174,14 +43176,14 @@ function hashDigest(payload) {
 import * as crypto7 from "node:crypto";
 import * as fs23 from "node:fs/promises";
 import * as os11 from "node:os";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 
 // ../mcp-server/dist/src/audit/namespace-overrides.types.js
 var CURRENT_VERSION = 1;
 
 // ../mcp-server/dist/src/audit/namespace-overrides.js
 function defaultLedgerPath() {
-  return path18.join(os11.homedir(), ".skillsmith", "namespace-overrides.json");
+  return path19.join(os11.homedir(), ".skillsmith", "namespace-overrides.json");
 }
 var ULID_PREFIX = "ovr_";
 function emptyLedger() {
@@ -43261,7 +43263,7 @@ async function writeLedger(ledger, opts = {}) {
   const ledgerPath2 = opts.ledgerPath ?? defaultLedgerPath();
   const tmpSuffix = crypto7.randomBytes(6).toString("hex");
   const tmpPath = `${ledgerPath2}.${tmpSuffix}.tmp`;
-  await fs23.mkdir(path18.dirname(ledgerPath2), { recursive: true });
+  await fs23.mkdir(path19.dirname(ledgerPath2), { recursive: true });
   const normalized = { version: CURRENT_VERSION, overrides: ledger.overrides };
   const json2 = JSON.stringify(normalized, null, 2);
   try {
@@ -43301,23 +43303,22 @@ function findOverride(ledger, query) {
 }
 
 // ../mcp-server/dist/src/audit/rename-engine.js
-import * as fs26 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as fs27 from "node:fs/promises";
 
 // ../mcp-server/dist/src/tools/install.conflict-helpers.js
 import * as fs24 from "fs/promises";
-import * as path19 from "path";
+import * as path20 from "path";
 function getBackupsDir() {
-  return path19.join(getCanonicalInstallPath(), ".backups");
+  return path20.join(getCanonicalInstallPath(), ".backups");
 }
 async function createSkillBackup(skillName, installPath, reason) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path19.join(getBackupsDir(), skillName, `${timestamp}_${reason}`);
+  const backupDir = path20.join(getBackupsDir(), skillName, `${timestamp}_${reason}`);
   await fs24.mkdir(backupDir, { recursive: true });
   const entries = await fs24.readdir(installPath, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path19.join(installPath, entry.name);
-    const destPath = path19.join(backupDir, entry.name);
+    const srcPath = path20.join(installPath, entry.name);
+    const destPath = path20.join(backupDir, entry.name);
     if (entry.isSymbolicLink()) {
       console.warn(`Skipping symlink in skill backup: ${entry.name}`);
       continue;
@@ -43334,8 +43335,8 @@ async function copyDirectory2(src, dest) {
   await fs24.mkdir(dest, { recursive: true });
   const entries = await fs24.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path19.join(src, entry.name);
-    const destPath = path19.join(dest, entry.name);
+    const srcPath = path20.join(src, entry.name);
+    const destPath = path20.join(dest, entry.name);
     if (entry.isSymbolicLink()) {
       console.warn(`Skipping symlink in directory copy: ${entry.name}`);
       continue;
@@ -43351,7 +43352,7 @@ async function copyDirectory2(src, dest) {
 // ../mcp-server/dist/src/audit/rename-engine.apply-paths.js
 import * as fs25 from "node:fs/promises";
 import * as os12 from "node:os";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 function actionToKind(action) {
   switch (action) {
     case "rename_command_file":
@@ -43362,12 +43363,16 @@ function actionToKind(action) {
       return "skill";
   }
 }
-function computeDestPath(suggestion, newName) {
+function resolveRenameTarget(suggestion) {
   const src = suggestion.entry.source_path;
+  return suggestion.applyAction === "rename_skill_dir_and_frontmatter" ? path21.dirname(src) : src;
+}
+function computeDestPath(suggestion, newName) {
+  const target = resolveRenameTarget(suggestion);
   if (suggestion.applyAction === "rename_skill_dir_and_frontmatter") {
-    return path20.join(path20.dirname(src), newName);
+    return path21.join(path21.dirname(target), newName);
   }
-  return path20.join(path20.dirname(src), `${newName}.md`);
+  return path21.join(path21.dirname(target), `${newName}.md`);
 }
 function deriveSkillId(suggestion) {
   const author = suggestion.entry.meta?.author;
@@ -43393,17 +43398,19 @@ async function pathExists2(target) {
   }
 }
 async function stageSingleFileForBackup(srcFile) {
-  const tmp = await fs25.mkdtemp(path20.join(os12.tmpdir(), "skillsmith-rename-stage-"));
-  await fs25.copyFile(srcFile, path20.join(tmp, path20.basename(srcFile)));
+  const tmp = await fs25.mkdtemp(path21.join(os12.tmpdir(), "skillsmith-rename-stage-"));
+  await fs25.copyFile(srcFile, path21.join(tmp, path21.basename(srcFile)));
   return tmp;
 }
 async function runBackup(suggestion) {
-  const skillName = path20.basename(suggestion.entry.source_path).replace(/\.md$/, "");
   const action = suggestion.applyAction;
+  const target = resolveRenameTarget(suggestion);
   if (action === "rename_skill_dir_and_frontmatter") {
-    return createSkillBackup(skillName, suggestion.entry.source_path, "namespace-rename");
+    const skillName2 = path21.basename(target);
+    return createSkillBackup(skillName2, target, "namespace-rename");
   }
-  const staged = await stageSingleFileForBackup(suggestion.entry.source_path);
+  const skillName = path21.basename(target).replace(/\.md$/, "");
+  const staged = await stageSingleFileForBackup(target);
   try {
     return await createSkillBackup(skillName, staged, "namespace-rename");
   } finally {
@@ -43413,11 +43420,11 @@ async function runBackup(suggestion) {
     }
   }
 }
-function buildSummary(oldIdentifier, newIdentifier, auditId, action) {
+function buildSummary(oldIdentifier, newIdentifier, auditId, collisionId, action) {
   if (action === "revert") {
     return `Reverted /${oldIdentifier} \u2192 /${newIdentifier}. Audit: ${auditId}`;
   }
-  return `Renamed /${oldIdentifier} \u2192 /${newIdentifier}. To undo: sklx audit revert ${auditId}`;
+  return `Renamed /${oldIdentifier} \u2192 /${newIdentifier}. To undo: call apply_namespace_rename with auditId: '${auditId}', collisionId: '${collisionId}', action: 'revert'.`;
 }
 
 // ../mcp-server/dist/src/audit/rename-engine.helpers.js
@@ -43563,6 +43570,150 @@ function escapeForDoubleQuoted(s) {
   return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 
+// ../mcp-server/dist/src/audit/rename-engine.revert.js
+import * as fs26 from "node:fs/promises";
+import * as path22 from "node:path";
+async function revertRename(suggestion, auditId, collisionId) {
+  const ledger = await readLedger();
+  const matches = ledger.overrides.filter((o) => o.auditId === auditId);
+  let entry = matches.find((o) => o.collisionId === collisionId);
+  if (!entry) {
+    if (matches.length >= 2) {
+      return {
+        success: false,
+        collisionId: suggestion.collisionId,
+        appliedAction: suggestion.applyAction,
+        appliedRequest: "revert",
+        fromPath: resolveRenameTarget(suggestion),
+        toPath: "",
+        backupPath: "",
+        ledgerEntryId: "",
+        summary: "",
+        error: {
+          kind: "namespace.rename.revert_ambiguous",
+          auditId,
+          collisionId,
+          candidateCount: matches.length,
+          message: `revert is ambiguous: ${matches.length} ledger entries share auditId ${auditId} and none match collisionId ${collisionId}; re-run skill_inventory_audit to obtain current collisionIds`
+        }
+      };
+    }
+    entry = matches[0];
+  }
+  if (!entry) {
+    return {
+      success: true,
+      collisionId: suggestion.collisionId,
+      appliedAction: suggestion.applyAction,
+      appliedRequest: "revert",
+      fromPath: resolveRenameTarget(suggestion),
+      toPath: resolveRenameTarget(suggestion),
+      backupPath: "",
+      ledgerEntryId: "",
+      summary: buildSummary(suggestion.currentName, suggestion.currentName, auditId, collisionId, "revert")
+    };
+  }
+  const action = suggestion.applyAction;
+  const onDisk = entry.renamedPath;
+  const target = entry.originalPath;
+  if (!await pathExists2(onDisk)) {
+    return {
+      success: false,
+      collisionId: suggestion.collisionId,
+      appliedAction: action,
+      appliedRequest: "revert",
+      fromPath: onDisk,
+      toPath: target,
+      backupPath: "",
+      ledgerEntryId: entry.id,
+      summary: "",
+      error: {
+        kind: "namespace.ledger.disk_divergence",
+        ledgerRenamedTo: entry.renamedTo,
+        onDisk,
+        message: `revert source missing on disk: ${onDisk}`,
+        remediationHint: "restore from ~/.claude/skills/.backups or remove the ledger entry manually"
+      }
+    };
+  }
+  if (target !== onDisk && await pathExists2(target)) {
+    return {
+      success: false,
+      collisionId: suggestion.collisionId,
+      appliedAction: action,
+      appliedRequest: "revert",
+      fromPath: onDisk,
+      toPath: target,
+      backupPath: "",
+      ledgerEntryId: entry.id,
+      summary: "",
+      error: {
+        kind: "namespace.rename.target_exists",
+        target,
+        message: `revert target already exists: ${target}`
+      }
+    };
+  }
+  try {
+    if (action === "rename_skill_dir_and_frontmatter") {
+      const skillMdPath = path22.join(onDisk, "SKILL.md");
+      const current = await fs26.readFile(skillMdPath, "utf-8");
+      const restored = rewriteFrontmatterName(current, entry.originalIdentifier);
+      if (!restored.ok) {
+        return {
+          success: false,
+          collisionId: suggestion.collisionId,
+          appliedAction: action,
+          appliedRequest: "revert",
+          fromPath: onDisk,
+          toPath: target,
+          backupPath: "",
+          ledgerEntryId: entry.id,
+          summary: "",
+          error: {
+            kind: "namespace.rename.frontmatter_rewrite_failed",
+            reason: restored.error.message,
+            message: `revert frontmatter rewrite failed: ${restored.error.message}`
+          }
+        };
+      }
+      await fs26.writeFile(skillMdPath, restored.content, "utf-8");
+      await fs26.rename(onDisk, target);
+    } else {
+      await fs26.rename(onDisk, target);
+    }
+  } catch (err) {
+    return {
+      success: false,
+      collisionId: suggestion.collisionId,
+      appliedAction: action,
+      appliedRequest: "revert",
+      fromPath: onDisk,
+      toPath: target,
+      backupPath: "",
+      ledgerEntryId: entry.id,
+      summary: "",
+      error: fsErr(err.message)
+    };
+  }
+  const filtered = {
+    version: ledger.version,
+    overrides: ledger.overrides.filter((o) => o.id !== entry.id)
+  };
+  await writeLedger(filtered);
+  return {
+    success: true,
+    collisionId: suggestion.collisionId,
+    appliedAction: action,
+    appliedRequest: "revert",
+    fromPath: onDisk,
+    toPath: target,
+    backupPath: "",
+    ledgerEntryId: entry.id,
+    summary: buildSummary(entry.renamedTo, entry.originalIdentifier, auditId, collisionId, "revert")
+  };
+}
+
 // ../mcp-server/dist/src/audit/suggestion-chain.js
 import * as crypto8 from "node:crypto";
 var SANITIZE_MAX_LENGTH = 256;
@@ -43615,7 +43766,7 @@ async function applyRename(input7) {
   const { suggestion, request } = input7;
   const auditId = request.auditId;
   if (request.action === "revert") {
-    return revertRename(suggestion, auditId);
+    return revertRename(suggestion, auditId, request.collisionId);
   }
   const newName = request.customName ?? suggestion.suggested;
   const skillId = deriveSkillId(suggestion);
@@ -43639,7 +43790,7 @@ async function applyRename(input7) {
         toPath: existing.renamedPath,
         backupPath: "",
         ledgerEntryId: existing.id,
-        summary: buildSummary(suggestion.currentName, existing.renamedTo, auditId, "apply")
+        summary: buildSummary(suggestion.currentName, existing.renamedTo, auditId, suggestion.collisionId, "apply")
       };
     }
     return {
@@ -43647,7 +43798,7 @@ async function applyRename(input7) {
       collisionId: suggestion.collisionId,
       appliedAction: action,
       appliedRequest: "apply",
-      fromPath: suggestion.entry.source_path,
+      fromPath: resolveRenameTarget(suggestion),
       toPath: "",
       backupPath: "",
       ledgerEntryId: "",
@@ -43655,20 +43806,21 @@ async function applyRename(input7) {
       error: {
         kind: "namespace.ledger.disk_divergence",
         ledgerRenamedTo: existing.renamedTo,
-        onDisk: suggestion.entry.source_path,
+        onDisk: resolveRenameTarget(suggestion),
         message: `ledger records rename to ${existing.renamedTo} but no file at ${existing.renamedPath}`,
         remediationHint: "re-run skill_inventory_audit and reapply, or call apply_namespace_rename with customName to overwrite the ledger entry"
       }
     };
   }
+  const renameTarget = resolveRenameTarget(suggestion);
   const destPath = computeDestPath(suggestion, newName);
-  if (destPath !== suggestion.entry.source_path && await pathExists2(destPath)) {
+  if (destPath !== renameTarget && await pathExists2(destPath)) {
     return {
       success: false,
       collisionId: suggestion.collisionId,
       appliedAction: action,
       appliedRequest: "apply",
-      fromPath: suggestion.entry.source_path,
+      fromPath: renameTarget,
       toPath: destPath,
       backupPath: "",
       ledgerEntryId: "",
@@ -43689,7 +43841,7 @@ async function applyRename(input7) {
       collisionId: suggestion.collisionId,
       appliedAction: action,
       appliedRequest: "apply",
-      fromPath: suggestion.entry.source_path,
+      fromPath: renameTarget,
       toPath: destPath,
       backupPath: "",
       ledgerEntryId: "",
@@ -43703,17 +43855,17 @@ async function applyRename(input7) {
   }
   try {
     if (action === "rename_skill_dir_and_frontmatter") {
-      const skillMdPath = path21.join(suggestion.entry.source_path, "SKILL.md");
+      const skillMdPath = suggestion.entry.source_path;
       let original;
       try {
-        original = await fs26.readFile(skillMdPath, "utf-8");
+        original = await fs27.readFile(skillMdPath, "utf-8");
       } catch (err) {
         return {
           success: false,
           collisionId: suggestion.collisionId,
           appliedAction: action,
           appliedRequest: "apply",
-          fromPath: suggestion.entry.source_path,
+          fromPath: renameTarget,
           toPath: destPath,
           backupPath,
           ledgerEntryId: "",
@@ -43728,7 +43880,7 @@ async function applyRename(input7) {
           collisionId: suggestion.collisionId,
           appliedAction: action,
           appliedRequest: "apply",
-          fromPath: suggestion.entry.source_path,
+          fromPath: renameTarget,
           toPath: destPath,
           backupPath,
           ledgerEntryId: "",
@@ -43740,10 +43892,10 @@ async function applyRename(input7) {
           }
         };
       }
-      await fs26.writeFile(skillMdPath, rewriteResult.content, "utf-8");
-      await fs26.rename(suggestion.entry.source_path, destPath);
+      await fs27.writeFile(skillMdPath, rewriteResult.content, "utf-8");
+      await fs27.rename(renameTarget, destPath);
     } else {
-      await fs26.rename(suggestion.entry.source_path, destPath);
+      await fs27.rename(renameTarget, destPath);
     }
   } catch (err) {
     return {
@@ -43751,7 +43903,7 @@ async function applyRename(input7) {
       collisionId: suggestion.collisionId,
       appliedAction: action,
       appliedRequest: "apply",
-      fromPath: suggestion.entry.source_path,
+      fromPath: renameTarget,
       toPath: destPath,
       backupPath,
       ledgerEntryId: "",
@@ -43764,9 +43916,10 @@ async function applyRename(input7) {
     kind,
     originalIdentifier: suggestion.currentName,
     renamedTo: newName,
-    originalPath: suggestion.entry.source_path,
+    originalPath: renameTarget,
     renamedPath: destPath,
     auditId,
+    collisionId: suggestion.collisionId,
     reason: suggestion.reason
   });
   if (updated !== ledger) {
@@ -43782,132 +43935,16 @@ async function applyRename(input7) {
     collisionId: suggestion.collisionId,
     appliedAction: action,
     appliedRequest: "apply",
-    fromPath: suggestion.entry.source_path,
+    fromPath: renameTarget,
     toPath: destPath,
     backupPath,
     ledgerEntryId: newEntry?.id ?? "",
-    summary: buildSummary(suggestion.currentName, newName, auditId, "apply")
-  };
-}
-async function revertRename(suggestion, auditId) {
-  const ledger = await readLedger();
-  const entry = ledger.overrides.find((o) => o.auditId === auditId);
-  if (!entry) {
-    return {
-      success: true,
-      collisionId: suggestion.collisionId,
-      appliedAction: suggestion.applyAction,
-      appliedRequest: "revert",
-      fromPath: suggestion.entry.source_path,
-      toPath: suggestion.entry.source_path,
-      backupPath: "",
-      ledgerEntryId: "",
-      summary: buildSummary(suggestion.currentName, suggestion.currentName, auditId, "revert")
-    };
-  }
-  const action = suggestion.applyAction;
-  const onDisk = entry.renamedPath;
-  const target = entry.originalPath;
-  if (!await pathExists2(onDisk)) {
-    return {
-      success: false,
-      collisionId: suggestion.collisionId,
-      appliedAction: action,
-      appliedRequest: "revert",
-      fromPath: onDisk,
-      toPath: target,
-      backupPath: "",
-      ledgerEntryId: entry.id,
-      summary: "",
-      error: {
-        kind: "namespace.ledger.disk_divergence",
-        ledgerRenamedTo: entry.renamedTo,
-        onDisk,
-        message: `revert source missing on disk: ${onDisk}`,
-        remediationHint: "restore from ~/.claude/skills/.backups or remove the ledger entry manually"
-      }
-    };
-  }
-  if (target !== onDisk && await pathExists2(target)) {
-    return {
-      success: false,
-      collisionId: suggestion.collisionId,
-      appliedAction: action,
-      appliedRequest: "revert",
-      fromPath: onDisk,
-      toPath: target,
-      backupPath: "",
-      ledgerEntryId: entry.id,
-      summary: "",
-      error: {
-        kind: "namespace.rename.target_exists",
-        target,
-        message: `revert target already exists: ${target}`
-      }
-    };
-  }
-  try {
-    if (action === "rename_skill_dir_and_frontmatter") {
-      const skillMdPath = path21.join(onDisk, "SKILL.md");
-      const current = await fs26.readFile(skillMdPath, "utf-8");
-      const restored = rewriteFrontmatterName(current, entry.originalIdentifier);
-      if (!restored.ok) {
-        return {
-          success: false,
-          collisionId: suggestion.collisionId,
-          appliedAction: action,
-          appliedRequest: "revert",
-          fromPath: onDisk,
-          toPath: target,
-          backupPath: "",
-          ledgerEntryId: entry.id,
-          summary: "",
-          error: {
-            kind: "namespace.rename.frontmatter_rewrite_failed",
-            reason: restored.error.message,
-            message: `revert frontmatter rewrite failed: ${restored.error.message}`
-          }
-        };
-      }
-      await fs26.writeFile(skillMdPath, restored.content, "utf-8");
-      await fs26.rename(onDisk, target);
-    } else {
-      await fs26.rename(onDisk, target);
-    }
-  } catch (err) {
-    return {
-      success: false,
-      collisionId: suggestion.collisionId,
-      appliedAction: action,
-      appliedRequest: "revert",
-      fromPath: onDisk,
-      toPath: target,
-      backupPath: "",
-      ledgerEntryId: entry.id,
-      summary: "",
-      error: fsErr(err.message)
-    };
-  }
-  const filtered = {
-    version: ledger.version,
-    overrides: ledger.overrides.filter((o) => o.id !== entry.id)
-  };
-  await writeLedger(filtered);
-  return {
-    success: true,
-    collisionId: suggestion.collisionId,
-    appliedAction: action,
-    appliedRequest: "revert",
-    fromPath: onDisk,
-    toPath: target,
-    backupPath: "",
-    ledgerEntryId: entry.id,
-    summary: buildSummary(entry.renamedTo, entry.originalIdentifier, auditId, "revert")
+    summary: buildSummary(suggestion.currentName, newName, auditId, suggestion.collisionId, "apply")
   };
 }
 
 // ../mcp-server/dist/src/audit/edit-suggester.js
-import * as fs27 from "node:fs/promises";
+import * as fs28 from "node:fs/promises";
 var ADD_DOMAIN_QUALIFIER = {
   category: "description_overlap",
   pattern: "add_domain_qualifier",
@@ -43977,7 +44014,7 @@ async function runEditSuggester(result, opts) {
   const fileCache = /* @__PURE__ */ new Map();
   await Promise.all(Array.from(uniquePaths).map(async (filePath) => {
     try {
-      const content = await fs27.readFile(filePath, "utf-8");
+      const content = await fs28.readFile(filePath, "utf-8");
       fileCache.set(filePath, content);
     } catch (err) {
       console.warn(`[edit-suggester] read failed for ${filePath} (${err.message}); skipping flags that target it`);
@@ -44091,7 +44128,7 @@ var MS_PER_DAY3 = 24 * 60 * 60 * 1e3;
 import * as os14 from "node:os";
 
 // ../core/dist/src/audit/exclusions.js
-import { promises as fs28 } from "node:fs";
+import { promises as fs29 } from "node:fs";
 import { join as join56 } from "node:path";
 var EXCLUSIONS_FILE = "audit-exclusions.json";
 var EMPTY_CONFIG = { version: 1, exclusions: [] };
@@ -44099,13 +44136,13 @@ function getExclusionsPath(opts) {
   return join56(opts?.configDir ?? getConfigDir(), EXCLUSIONS_FILE);
 }
 async function loadExclusions(opts = {}) {
-  const path23 = opts.configPath ?? getExclusionsPath();
+  const path24 = opts.configPath ?? getExclusionsPath();
   let raw;
   try {
-    raw = await fs28.readFile(path23, "utf-8");
+    raw = await fs29.readFile(path24, "utf-8");
   } catch (err) {
     if (err.code !== "ENOENT") {
-      console.warn(`[audit-exclusions] read failed for ${path23}: ${err.message}`);
+      console.warn(`[audit-exclusions] read failed for ${path24}: ${err.message}`);
     }
     return EMPTY_CONFIG;
   }
@@ -44113,11 +44150,11 @@ async function loadExclusions(opts = {}) {
   try {
     parsed = JSON.parse(raw);
   } catch {
-    console.warn(`[audit-exclusions] malformed JSON at ${path23} \u2014 ignoring file`);
+    console.warn(`[audit-exclusions] malformed JSON at ${path24} \u2014 ignoring file`);
     return EMPTY_CONFIG;
   }
   if (!isExclusionsConfig(parsed)) {
-    console.warn(`[audit-exclusions] unrecognized schema at ${path23} (expected version: 1) \u2014 ignoring file`);
+    console.warn(`[audit-exclusions] unrecognized schema at ${path24} (expected version: 1) \u2014 ignoring file`);
     return EMPTY_CONFIG;
   }
   return parsed;
@@ -44168,30 +44205,30 @@ function tierAllowsAuditMode(tier, mode) {
 }
 
 // ../mcp-server/dist/src/audit/audit-suggestions.js
-import * as fs29 from "node:fs/promises";
+import * as fs30 from "node:fs/promises";
 import * as os13 from "node:os";
-import * as path22 from "node:path";
-var DEFAULT_AUDITS_DIR2 = path22.join(os13.homedir(), ".skillsmith", "audits");
+import * as path23 from "node:path";
+var DEFAULT_AUDITS_DIR2 = path23.join(os13.homedir(), ".skillsmith", "audits");
 async function writeAuditSuggestions(auditId, renameSuggestions, recommendedEdits, opts = {}) {
   const auditsDir = opts.auditsDir ?? DEFAULT_AUDITS_DIR2;
-  const auditDir = path22.join(auditsDir, auditId);
-  const suggestionsPath = path22.join(auditDir, "suggestions.json");
+  const auditDir = path23.join(auditsDir, auditId);
+  const suggestionsPath = path23.join(auditDir, "suggestions.json");
   const tmpPath = `${suggestionsPath}.tmp`;
-  await fs29.mkdir(auditDir, { recursive: true });
+  await fs30.mkdir(auditDir, { recursive: true });
   const payload = {
     version: 1,
     auditId,
     renameSuggestions: [...renameSuggestions],
     recommendedEdits: [...recommendedEdits]
   };
-  await fs29.writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
-  await fs29.rename(tmpPath, suggestionsPath);
+  await fs30.writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+  await fs30.rename(tmpPath, suggestionsPath);
   return { suggestionsPath };
 }
 
 // ../mcp-server/dist/src/audit/rot-detector.js
 import * as crypto9 from "node:crypto";
-import * as fs30 from "node:fs/promises";
+import * as fs31 from "node:fs/promises";
 var SCANNABLE_KINDS2 = /* @__PURE__ */ new Set(["skill", "command", "agent"]);
 var DEAD_LINK_PATTERNS = [
   /\]\(\s*<?https?:\/\/(www\.)?example\.(com|org|net)\b[^)]*\)/i,
@@ -44242,7 +44279,7 @@ async function detectVersionDrift(inventory, opts) {
 }
 async function readEntryContent(sourcePath) {
   try {
-    return await fs30.readFile(sourcePath, "utf-8");
+    return await fs31.readFile(sourcePath, "utf-8");
   } catch {
     return null;
   }
@@ -44282,7 +44319,7 @@ function deriveRotId(auditId, entry, signal) {
 
 // ../mcp-server/dist/src/audit/run-inventory-audit.detectors.js
 import * as crypto10 from "node:crypto";
-import * as fs31 from "node:fs";
+import * as fs32 from "node:fs";
 function buildRenameSuggestions(result, fullInventory) {
   const suggestions = [];
   for (const flag of result.exactCollisions) {
@@ -44366,7 +44403,7 @@ function isAgentPackSelfCollision(flag) {
 }
 function hashFileContent(filePath) {
   try {
-    const content = fs31.readFileSync(filePath);
+    const content = fs32.readFileSync(filePath);
     return crypto10.createHash("sha256").update(content).digest("hex");
   } catch {
     return null;
@@ -44565,13 +44602,13 @@ function backupsDir() {
 }
 function backupLedgerForReset() {
   const src = ledgerPath();
-  if (!fs32.existsSync(src)) return null;
+  if (!fs33.existsSync(src)) return null;
   const dir = backupsDir();
-  fs32.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs33.mkdirSync(dir, { recursive: true, mode: 448 });
   const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const suffix = crypto11.randomBytes(4).toString("hex");
   const backupFile = join58(dir, `ledger-${ts2}-${suffix}.json`);
-  fs32.copyFileSync(src, backupFile);
+  fs33.copyFileSync(src, backupFile);
   return backupFile;
 }
 async function runResetLedger() {
@@ -45318,7 +45355,7 @@ var auditAction = withTelemetry(auditActionImpl, {
 import { Command as Command22 } from "commander";
 import { input as input6, confirm as confirm6, select as select4 } from "@inquirer/prompts";
 import ora12 from "ora";
-import { mkdir as mkdir17, writeFile as writeFile14, stat as stat12 } from "fs/promises";
+import { mkdir as mkdir17, writeFile as writeFile15, stat as stat12 } from "fs/promises";
 import { join as join59 } from "path";
 var logger29 = getCliLogger();
 var VALID_TYPES = ["basic", "intermediate", "advanced"];
@@ -45533,12 +45570,12 @@ Thumbs.db
     if (includeScripts) {
       await mkdir17(join59(skillDir, "scripts"), { recursive: true });
     }
-    await writeFile14(join59(skillDir, "SKILL.md"), skillMdContent, "utf-8");
-    await writeFile14(join59(skillDir, "README.md"), readmeContent, "utf-8");
-    await writeFile14(join59(skillDir, "CHANGELOG.md"), changelogContent, "utf-8");
-    await writeFile14(join59(skillDir, ".gitignore"), gitignoreContent, "utf-8");
+    await writeFile15(join59(skillDir, "SKILL.md"), skillMdContent, "utf-8");
+    await writeFile15(join59(skillDir, "README.md"), readmeContent, "utf-8");
+    await writeFile15(join59(skillDir, "CHANGELOG.md"), changelogContent, "utf-8");
+    await writeFile15(join59(skillDir, ".gitignore"), gitignoreContent, "utf-8");
     if (includeScripts) {
-      await writeFile14(join59(skillDir, "scripts", "example.js"), scriptContent, "utf-8");
+      await writeFile15(join59(skillDir, "scripts", "example.js"), scriptContent, "utf-8");
     }
     spinner.succeed(`Skill scaffolded at ${skillDir}`);
   } catch (error46) {
@@ -45912,12 +45949,12 @@ function createImportCommand() {
 // src/commands/import-local.ts
 import { Command as Command25 } from "commander";
 import { resolve as resolve16 } from "node:path";
-import { promises as fs34 } from "node:fs";
+import { promises as fs35 } from "node:fs";
 
 // src/commands/import-local.helpers.ts
 import { createHash as createHash17 } from "node:crypto";
-import { promises as fs33 } from "node:fs";
-import { join as join60, resolve as resolve15, dirname as dirname25, basename as basename7, sep as sep4, relative as relative6 } from "node:path";
+import { promises as fs34 } from "node:fs";
+import { join as join60, resolve as resolve15, dirname as dirname25, basename as basename8, sep as sep4, relative as relative6 } from "node:path";
 import matter from "gray-matter";
 var SKILL_FILENAME = "SKILL.md";
 var MAX_DEPTH = 8;
@@ -45925,7 +45962,7 @@ function localSkillId(canonicalPath) {
   return createHash17("sha256").update(canonicalPath).digest("hex").slice(0, 32);
 }
 async function walkSkillFiles(rootDir) {
-  const canonicalRoot = await fs33.realpath(rootDir).catch(() => resolve15(rootDir));
+  const canonicalRoot = await fs34.realpath(rootDir).catch(() => resolve15(rootDir));
   const files = [];
   const skipped = [];
   const visited = /* @__PURE__ */ new Set();
@@ -45933,7 +45970,7 @@ async function walkSkillFiles(rootDir) {
     if (depth > MAX_DEPTH) return;
     let entries;
     try {
-      entries = await fs33.readdir(dir, { withFileTypes: true });
+      entries = await fs34.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -45942,7 +45979,7 @@ async function walkSkillFiles(rootDir) {
       if (entry.isSymbolicLink()) {
         let realPath;
         try {
-          realPath = await fs33.realpath(entryPath);
+          realPath = await fs34.realpath(entryPath);
         } catch {
           continue;
         }
@@ -45953,10 +45990,10 @@ async function walkSkillFiles(rootDir) {
         }
         if (visited.has(realPath)) continue;
         visited.add(realPath);
-        const stat13 = await fs33.stat(realPath).catch(() => null);
+        const stat13 = await fs34.stat(realPath).catch(() => null);
         if (stat13?.isDirectory()) {
           await walk(realPath, depth + 1);
-        } else if (stat13?.isFile() && basename7(realPath) === SKILL_FILENAME) {
+        } else if (stat13?.isFile() && basename8(realPath) === SKILL_FILENAME) {
           files.push(realPath);
         }
         continue;
@@ -45966,7 +46003,7 @@ async function walkSkillFiles(rootDir) {
         await walk(entryPath, depth + 1);
       } else if (entry.isFile() && entry.name === SKILL_FILENAME) {
         try {
-          const real = await fs33.realpath(entryPath);
+          const real = await fs34.realpath(entryPath);
           files.push(real);
         } catch {
           files.push(entryPath);
@@ -45979,10 +46016,10 @@ async function walkSkillFiles(rootDir) {
 }
 async function parseSkillFile(filePath) {
   const id = localSkillId(filePath);
-  const fallbackName = basename7(dirname25(filePath));
+  const fallbackName = basename8(dirname25(filePath));
   let content;
   try {
-    content = await fs33.readFile(filePath, "utf8");
+    content = await fs34.readFile(filePath, "utf8");
   } catch (error46) {
     return {
       id,
@@ -46058,7 +46095,7 @@ async function runImportLocal(opts) {
     dryRun: !!opts.dryRun
   };
   try {
-    const stat13 = await fs34.stat(rootDir);
+    const stat13 = await fs35.stat(rootDir);
     if (!stat13.isDirectory()) {
       result.errors.push({ path: rootDir, message: "not-a-directory" });
       result.durationMs = Date.now() - start;
@@ -46175,14 +46212,14 @@ async function startWatchMode(opts, jsonOutput) {
   watcher.on("unlink", (p) => onEvent("unlink", p));
   console.log(`[import-local] watching ${rootDir} (Ctrl-C to stop)`);
 }
-async function importLocalActionImpl(path23, cliOptions) {
+async function importLocalActionImpl(path24, cliOptions) {
   try {
     let resolvedClient;
     if (cliOptions.client !== void 0) {
       resolvedClient = resolveClientId(cliOptions.client);
     }
     const opts = {
-      ...path23 !== void 0 && { path: path23 },
+      ...path24 !== void 0 && { path: path24 },
       ...resolvedClient !== void 0 && { client: resolvedClient },
       ...cliOptions.watch !== void 0 && { watch: cliOptions.watch },
       ...cliOptions.dryRun !== void 0 && { dryRun: cliOptions.dryRun },
@@ -46245,7 +46282,7 @@ function printHumanSummary(result) {
 
 // src/commands/config.ts
 import * as crypto12 from "node:crypto";
-import * as fs35 from "node:fs";
+import * as fs36 from "node:fs";
 import { homedir as homedir30 } from "node:os";
 import { join as join61, dirname as dirname26 } from "node:path";
 import { Command as Command26 } from "commander";
@@ -46274,10 +46311,10 @@ function configPath() {
   return join61(homedir30(), CONFIG_DIR3, CONFIG_FILE3);
 }
 function readConfigFile2() {
-  const path23 = configPath();
-  if (!fs35.existsSync(path23)) return {};
+  const path24 = configPath();
+  if (!fs36.existsSync(path24)) return {};
   try {
-    const raw = fs35.readFileSync(path23, "utf-8");
+    const raw = fs36.readFileSync(path24, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
     return parsed;
@@ -46286,16 +46323,16 @@ function readConfigFile2() {
   }
 }
 function writeConfigFileAtomic(config2) {
-  const path23 = configPath();
-  const dir = dirname26(path23);
-  fs35.mkdirSync(dir, { recursive: true, mode: 448 });
+  const path24 = configPath();
+  const dir = dirname26(path24);
+  fs36.mkdirSync(dir, { recursive: true, mode: 448 });
   const tmpSuffix = crypto12.randomBytes(6).toString("hex");
-  const tmpPath = `${path23}.${tmpSuffix}.tmp`;
+  const tmpPath = `${path24}.${tmpSuffix}.tmp`;
   const json2 = JSON.stringify(config2, null, 2);
-  fs35.writeFileSync(tmpPath, json2, { encoding: "utf-8", mode: 384 });
-  fs35.renameSync(tmpPath, path23);
+  fs36.writeFileSync(tmpPath, json2, { encoding: "utf-8", mode: 384 });
+  fs36.renameSync(tmpPath, path24);
   try {
-    fs35.chmodSync(path23, 384);
+    fs36.chmodSync(path24, 384);
   } catch {
   }
 }
@@ -46395,7 +46432,7 @@ import { readdirSync as readdirSync4, unlinkSync as unlinkSync3, statSync as sta
 
 // src/commands/telemetry.helpers.ts
 import * as crypto13 from "node:crypto";
-import * as fs36 from "node:fs";
+import * as fs37 from "node:fs";
 import { join as join62, dirname as dirname27 } from "node:path";
 import { homedir as homedir31 } from "node:os";
 var TelemetryHookError = class extends Error {
@@ -46413,10 +46450,10 @@ function resolveSettingsPath(scope) {
   return join62(process.cwd(), ".claude", "settings.json");
 }
 function loadClaudeSettings(scope) {
-  const path23 = resolveSettingsPath(scope);
-  if (!fs36.existsSync(path23)) return {};
+  const path24 = resolveSettingsPath(scope);
+  if (!fs37.existsSync(path24)) return {};
   try {
-    const raw = fs36.readFileSync(path23, "utf-8");
+    const raw = fs37.readFileSync(path24, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
     return parsed;
@@ -46482,16 +46519,16 @@ function removeSkillHookEntries(settings, hookPath) {
   return { ...settings, hooks };
 }
 function writeClaudeSettings(scope, settings) {
-  const path23 = resolveSettingsPath(scope);
-  const dir = dirname27(path23);
-  fs36.mkdirSync(dir, { recursive: true, mode: 448 });
+  const path24 = resolveSettingsPath(scope);
+  const dir = dirname27(path24);
+  fs37.mkdirSync(dir, { recursive: true, mode: 448 });
   const tmpSuffix = crypto13.randomBytes(6).toString("hex");
-  const tmpPath = `${path23}.${tmpSuffix}.tmp`;
+  const tmpPath = `${path24}.${tmpSuffix}.tmp`;
   const json2 = JSON.stringify(settings, null, 2);
-  fs36.writeFileSync(tmpPath, json2, { encoding: "utf-8", mode: 384 });
-  fs36.renameSync(tmpPath, path23);
+  fs37.writeFileSync(tmpPath, json2, { encoding: "utf-8", mode: 384 });
+  fs37.renameSync(tmpPath, path24);
   try {
-    fs36.chmodSync(path23, 384);
+    fs37.chmodSync(path24, 384);
   } catch {
   }
 }
@@ -47082,7 +47119,7 @@ function createAgentCommand() {
 
 // src/commands/diagnose.ts
 import { mkdirSync as mkdirSync14, readFileSync as readFileSync25, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename8, dirname as dirname29, resolve as resolve17 } from "node:path";
+import { basename as basename9, dirname as dirname29, resolve as resolve17 } from "node:path";
 import { Command as Command30 } from "commander";
 
 // src/commands/log-records.helpers.ts
@@ -47218,7 +47255,7 @@ function buildBundleContent(summary, files) {
   } else {
     for (const file2 of files) {
       parts.push("");
-      parts.push(`===== ${basename8(file2)} (${fileSizeBytes(file2)} bytes) =====`);
+      parts.push(`===== ${basename9(file2)} (${fileSizeBytes(file2)} bytes) =====`);
       try {
         parts.push(readFileSync25(file2, "utf8"));
       } catch (error46) {
@@ -47333,18 +47370,18 @@ async function startTail(dir, level, opts = {}) {
   const paths = todaysFilePaths(dir);
   const offsets = /* @__PURE__ */ new Map();
   let printedAny = false;
-  for (const path23 of paths) {
-    if (!existsSync29(path23)) {
-      offsets.set(path23, 0);
+  for (const path24 of paths) {
+    if (!existsSync29(path24)) {
+      offsets.set(path24, 0);
       continue;
     }
-    let records = readLogRecords(path23);
+    let records = readLogRecords(path24);
     if (level) records = filterByMinLevel(records, level);
     if (records.length > 0) {
       printRecords(sortByTsAsc(records));
       printedAny = true;
     }
-    offsets.set(path23, statSync8(path23).size);
+    offsets.set(path24, statSync8(path24).size);
   }
   if (!printedAny) {
     console.log(noLogsFoundMessage(dir));
@@ -47359,25 +47396,25 @@ async function startTail(dir, level, opts = {}) {
   await new Promise((resolve18) => {
     watcher.once("ready", resolve18);
   });
-  const handleEvent = (path23) => {
+  const handleEvent = (path24) => {
     let size;
     try {
-      size = statSync8(path23).size;
+      size = statSync8(path24).size;
     } catch {
       return;
     }
-    const previousOffset = offsets.get(path23) ?? 0;
+    const previousOffset = offsets.get(path24) ?? 0;
     if (size <= previousOffset) {
-      offsets.set(path23, size);
+      offsets.set(path24, size);
       return;
     }
     let content;
     try {
-      content = readFileSync26(path23).subarray(previousOffset).toString("utf8");
+      content = readFileSync26(path24).subarray(previousOffset).toString("utf8");
     } catch {
       return;
     }
-    offsets.set(path23, size);
+    offsets.set(path24, size);
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
@@ -47534,8 +47571,8 @@ var program = new Command32();
 var commandName = process.argv[1]?.endsWith("sklx") ? "sklx" : "skillsmith";
 program.name(commandName).description("Agent Skill Discovery and Management CLI (alias: sklx)").version(CLI_VERSION);
 program.hook("preAction", async (_thisCommand, actionCommand) => {
-  const path23 = resolveCommandPath(actionCommand.name(), actionCommand.parent?.name(), commandName);
-  if (!shouldShowStartupHeader(path23, Boolean(process.stdout.isTTY))) return;
+  const path24 = resolveCommandPath(actionCommand.name(), actionCommand.parent?.name(), commandName);
+  if (!shouldShowStartupHeader(path24, Boolean(process.stdout.isTTY))) return;
   await displayStartupHeader(CLI_VERSION);
 });
 program.addCommand(createImportCommand());