claudekit-cli 4.2.1 → 4.2.3-dev.1

package/cli-manifest.json

@@ -1,6 +1,6 @@
 {
-	"version": "4.2.1",
-	"generatedAt": "2026-05-12T16:32:49.942Z",
+	"version": "4.2.3-dev.1",
+	"generatedAt": "2026-05-12T22:38:53.023Z",
 	"commands": {
 		"agents": {
 			"name": "agents",

package/dist/index.js

@@ -45544,6 +45544,45 @@ function formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix = "
   }
   return normalizedRoot === "$CLAUDE_PROJECT_DIR" ? `${nodePrefix}"${normalizedRoot}"/${normalizedRelativePath}${suffix}` : `${nodePrefix}"${normalizedRoot}/${normalizedRelativePath}"${suffix}`;
 }
+function resolveClaudePathArg(arg, root) {
+  const normalizedArg = arg.replace(/\\/g, "/");
+  const bareRelativeMatch = normalizedArg.match(/^(?:\.\/)?(\.claude\/.+)$/);
+  if (bareRelativeMatch) {
+    return { root, relativePath: bareRelativeMatch[1] };
+  }
+  const variableMatch = normalizedArg.match(/^(?:\$HOME|\$\{HOME\}|\$CLAUDE_PROJECT_DIR|\$\{CLAUDE_PROJECT_DIR\}|%USERPROFILE%|%CLAUDE_PROJECT_DIR%)\/(\.claude\/.+)$/);
+  if (variableMatch) {
+    return { root, relativePath: variableMatch[1] };
+  }
+  const tildeMatch = normalizedArg.match(/^~\/(\.claude\/.+)$/);
+  if (tildeMatch) {
+    return { root, relativePath: tildeMatch[1] };
+  }
+  const absoluteMatch = normalizedArg.match(/^((?:[A-Za-z]:\/|\/).*?\/\.claude\/.+)$/);
+  if (absoluteMatch) {
+    const absolutePath = absoluteMatch[1];
+    const dotClaudeIdx = absolutePath.indexOf("/.claude/");
+    if (dotClaudeIdx === -1) {
+      return null;
+    }
+    const isWin2 = process.platform === "win32";
+    const cmp = (s) => isWin2 ? s.toLowerCase() : s;
+    const globalRoots = [
+      `${homedir12().replace(/\\/g, "/").replace(/\/+$/, "")}/.claude/`,
+      `${PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "")}/`
+    ];
+    const isUnderGlobal = globalRoots.some((g2) => cmp(absolutePath).startsWith(cmp(g2)));
+    const resolvedRoot = isUnderGlobal ? "$HOME" : root;
+    return {
+      root: resolvedRoot,
+      relativePath: absolutePath.slice(dotClaudeIdx + 1)
+    };
+  }
+  return null;
+}
+function formatCanonicalClaudeArg(pathArg) {
+  return formatCanonicalClaudeCommand("", pathArg.root, pathArg.relativePath);
+}
 function isNodeClaudeCommand(cmd) {
   if (!cmd)
     return false;
@@ -45611,6 +45650,39 @@ function repairClaudeNodeCommandPath(cmd, root) {
   }
   return { command: cmd, changed: false, issue: null };
 }
+function repairClaudeHookRunnerCommandPath(cmd, root) {
+  if (!cmd) {
+    return { command: cmd ?? "", changed: false, issue: null };
+  }
+  const runnerMatch = cmd.match(/^(\s*bash\s+)(?:"([^"]+)"|([^\s"]+))\s+(?:"([^"]+)"|([^\s"]+))(.*)$/);
+  if (!runnerMatch) {
+    return { command: cmd, changed: false, issue: null };
+  }
+  const [, bashPrefix, quotedRunner, unquotedRunner, quotedTarget, unquotedTarget, suffix] = runnerMatch;
+  const runnerArg = quotedRunner ?? unquotedRunner;
+  const targetArg = quotedTarget ?? unquotedTarget;
+  const runnerPath = resolveClaudePathArg(runnerArg, root);
+  if (!runnerPath || runnerPath.relativePath.replace(/\\/g, "/") !== ".claude/hooks/node-hook-runner.sh") {
+    return { command: cmd, changed: false, issue: null };
+  }
+  const targetPath = resolveClaudePathArg(targetArg, root);
+  if (!targetPath) {
+    return { command: cmd, changed: false, issue: null };
+  }
+  const command = `${bashPrefix}${formatCanonicalClaudeArg(runnerPath)} ${formatCanonicalClaudeArg(targetPath)}${suffix}`;
+  return {
+    command,
+    changed: command !== cmd,
+    issue: command !== cmd ? "invalid-format" : null
+  };
+}
+function repairClaudeHookCommandPath(cmd, root) {
+  const nodeRepair = repairClaudeNodeCommandPath(cmd, root);
+  if (nodeRepair.changed || nodeRepair.issue || isNodeClaudeCommand(cmd)) {
+    return nodeRepair;
+  }
+  return repairClaudeHookRunnerCommandPath(cmd, root);
+}
 function normalizeCommand(cmd) {
   if (!cmd)
     return "";
@@ -51591,8 +51663,27 @@ var init_migrate_provider_scopes = __esm(() => {
 
 // src/commands/migrate/skill-directory-installer.ts
 import { existsSync as existsSync22 } from "node:fs";
-import { cp, mkdir as mkdir10, rename as rename6, rm as rm5 } from "node:fs/promises";
-import { join as join40, resolve as resolve15 } from "node:path";
+import { cp, mkdir as mkdir10, realpath as realpath5, rename as rename6, rm as rm5 } from "node:fs/promises";
+import { dirname as dirname11, join as join40, resolve as resolve15 } from "node:path";
+async function canonicalize(path3) {
+  try {
+    return await realpath5(path3);
+  } catch {
+    const parent = dirname11(path3);
+    if (parent === path3) {
+      return resolve15(path3);
+    }
+    try {
+      const canonicalParent = await realpath5(parent);
+      const absPath = resolve15(path3);
+      const absParent = resolve15(parent);
+      const basename13 = absPath.slice(absParent.length + 1) || "";
+      return join40(canonicalParent, basename13);
+    } catch {
+      return resolve15(path3);
+    }
+  }
+}
 async function installSkillDirectories(skills, targetProviders, options2) {
   const results = [];
   for (const provider of targetProviders) {
@@ -51619,9 +51710,28 @@ async function installSkillDirectories(skills, targetProviders, options2) {
       });
       continue;
     }
+    const sourceRoot = skills.length > 0 ? dirname11(skills[0].path) : null;
+    const canonicalBase = existsSync22(basePath) ? await canonicalize(basePath) : null;
+    const canonicalSourceRoot = sourceRoot ? await canonicalize(sourceRoot) : null;
+    const basePathIsSymlinkedToSource = canonicalBase !== null && canonicalSourceRoot !== null && canonicalBase === canonicalSourceRoot && resolve15(basePath) !== resolve15(sourceRoot ?? "");
+    if (basePathIsSymlinkedToSource) {
+      for (const skill of skills) {
+        results.push({
+          provider,
+          providerDisplayName: config.displayName,
+          success: true,
+          path: join40(basePath, skill.name),
+          skipped: true,
+          skipReason: `Skills directory ${basePath} is symlinked to source (${canonicalBase}); already in place`
+        });
+      }
+      continue;
+    }
     for (const skill of skills) {
       const targetDir = join40(basePath, skill.name);
-      if (resolve15(skill.path) === resolve15(targetDir)) {
+      const canonicalSource = await canonicalize(skill.path);
+      const canonicalTarget = await canonicalize(targetDir);
+      if (canonicalSource === canonicalTarget) {
         results.push({
           provider,
           providerDisplayName: config.displayName,
@@ -53813,9 +53923,9 @@ var init_codex_capabilities = __esm(() => {
 
 // src/commands/portable/codex-path-safety.ts
 import { existsSync as existsSync24 } from "node:fs";
-import { mkdir as mkdir12, realpath as realpath5 } from "node:fs/promises";
+import { mkdir as mkdir12, realpath as realpath6 } from "node:fs/promises";
 import { homedir as homedir25 } from "node:os";
-import { dirname as dirname11, join as join42, resolve as resolve17, sep as sep7 } from "node:path";
+import { dirname as dirname12, join as join42, resolve as resolve17, sep as sep7 } from "node:path";
 function isPathWithinBoundary3(targetPath, boundaryPath) {
   const resolvedTarget = resolve17(targetPath);
   const resolvedBoundary = resolve17(boundaryPath);
@@ -53823,7 +53933,7 @@ function isPathWithinBoundary3(targetPath, boundaryPath) {
 }
 async function resolveRealPathSafe2(path3) {
   try {
-    return await realpath5(path3);
+    return await realpath6(path3);
   } catch {
     return resolve17(path3);
   }
@@ -53834,11 +53944,11 @@ async function isCanonicalPathWithinBoundary2(targetPath, boundaryPath) {
   return isPathWithinBoundary3(canonicalTarget, canonicalBoundary);
 }
 function getCodexLockPath2(targetFilePath) {
-  return join42(dirname11(resolve17(targetFilePath)), ".config.toml.ck-codex.lock");
+  return join42(dirname12(resolve17(targetFilePath)), ".config.toml.ck-codex.lock");
 }
 async function withCodexTargetLock2(targetFilePath, operation) {
   const resolvedTargetPath = resolve17(targetFilePath);
-  const dir = dirname11(resolvedTargetPath);
+  const dir = dirname12(resolvedTargetPath);
   if (!existsSync24(dir)) {
     await mkdir12(dir, { recursive: true });
   }
@@ -53871,10 +53981,10 @@ var init_codex_path_safety = __esm(() => {
 // src/commands/portable/codex-features-flag.ts
 import { existsSync as existsSync25 } from "node:fs";
 import { readFile as readFile20, rename as rename7, unlink as unlink6, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname12, resolve as resolve18 } from "node:path";
+import { dirname as dirname13, resolve as resolve18 } from "node:path";
 async function ensureCodexHooksFeatureFlag(configTomlPath, isGlobal = false) {
-  const boundary = isGlobal ? getCodexGlobalBoundary() : dirname12(resolve18(configTomlPath));
-  if (!await isCanonicalPathWithinBoundary2(dirname12(resolve18(configTomlPath)), boundary)) {
+  const boundary = isGlobal ? getCodexGlobalBoundary() : dirname13(resolve18(configTomlPath));
+  if (!await isCanonicalPathWithinBoundary2(dirname13(resolve18(configTomlPath)), boundary)) {
     return {
       status: "failed",
       configPath: configTomlPath,
@@ -54040,7 +54150,7 @@ ${SENTINEL_END2}`;
 // src/commands/portable/codex-hook-wrapper.ts
 import { createHash as createHash5 } from "node:crypto";
 import { mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname13, join as join43, resolve as resolve19 } from "node:path";
+import { dirname as dirname14, join as join43, resolve as resolve19 } from "node:path";
 function wrapperFilename(originalPath) {
   const abs = resolve19(originalPath);
   const hash = createHash5("sha256").update(abs).digest("hex").slice(0, 8);
@@ -54063,7 +54173,7 @@ function generateCodexHookWrappers(originalPaths, wrapperDir, capabilities, time
       continue;
     }
     try {
-      mkdirSync(dirname13(wrapperPath), { recursive: true });
+      mkdirSync(dirname14(wrapperPath), { recursive: true });
       const resolvedPath = resolve19(originalPath);
       const hookTimeoutMs = timeoutsByPath?.[resolvedPath] ?? timeoutsByPath?.[originalPath];
       const content = buildWrapperScript(originalPath, capabilities, hookTimeoutMs);
@@ -54383,7 +54493,7 @@ var init_gemini_hook_event_map = __esm(() => {
 import { existsSync as existsSync26 } from "node:fs";
 import { mkdir as mkdir13, readFile as readFile21, rename as rename8, rm as rm6, writeFile as writeFile12 } from "node:fs/promises";
 import { homedir as homedir27 } from "node:os";
-import { basename as basename14, dirname as dirname14, join as join44, resolve as resolve20 } from "node:path";
+import { basename as basename14, dirname as dirname15, join as join44, resolve as resolve20 } from "node:path";
 function validateHooksSectionShape(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return "hooks must be a non-null object";
@@ -54534,7 +54644,7 @@ async function mergeHooksIntoSettings(targetSettingsPath, newHooks) {
   const pruned = pruneStaleFileHooks(existingHooks);
   const merged = deduplicateMerge(pruned, newHooks);
   existingSettings.hooks = merged;
-  const dir = dirname14(targetSettingsPath);
+  const dir = dirname15(targetSettingsPath);
   await mkdir13(dir, { recursive: true });
   const tempPath = `${targetSettingsPath}.tmp`;
   try {
@@ -56121,7 +56231,7 @@ __export(exports_skills_discovery, {
 });
 import { readFile as readFile24, readdir as readdir13, stat as stat9 } from "node:fs/promises";
 import { homedir as homedir28 } from "node:os";
-import { dirname as dirname15, join as join45 } from "node:path";
+import { dirname as dirname16, join as join45 } from "node:path";
 function getSkillSourcePath(globalOnly = false) {
   const globalPath = join45(homedir28(), ".claude/skills");
   if (globalOnly) {
@@ -56148,7 +56258,7 @@ async function parseSkillMd(skillMdPath) {
   try {
     const content = await readFile24(skillMdPath, "utf-8");
     const { data } = import_gray_matter5.default(content, { engines: { javascript: { parse: () => ({}) } } });
-    const skillDir = dirname15(skillMdPath);
+    const skillDir = dirname16(skillMdPath);
     const dirName = skillDir.split(/[/\\]/).pop() || "";
     if (!dirName) {
       logger.verbose(`Skipping ${skillMdPath}: cannot determine skill directory`);
@@ -57952,7 +58062,7 @@ var init_plan_metadata = __esm(() => {
 
 // src/domains/plan-parser/plan-table-parser.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname16, resolve as resolve22 } from "node:path";
+import { dirname as dirname17, resolve as resolve22 } from "node:path";
 function normalizeStatus(raw) {
   const s = raw.toLowerCase().trim();
   if (s.includes("complete") || s.includes("done") || s.includes("✓") || s.includes("✅")) {
@@ -58212,7 +58322,7 @@ function parseFormat4(content, planFilePath, options2) {
       const hasCheck = /[✅✓]/.test(line);
       current = { name, status: hasCheck ? "completed" : "pending" };
     } else if (fileMatch && current) {
-      const planDir = dirname16(planFilePath);
+      const planDir = dirname17(planFilePath);
       current.file = resolve22(planDir, fileMatch[1].trim());
     } else if (statusMatch && current) {
       current.status = normalizeStatus(statusMatch[2]);
@@ -58317,7 +58427,7 @@ function parsePhasesFromBody(body, dir, options2) {
 }
 function parsePlanFile(planFilePath, options2) {
   const content = readFileSync7(planFilePath, "utf8");
-  const dir = dirname16(planFilePath);
+  const dir = dirname17(planFilePath);
   const { data: frontmatter, content: body } = import_gray_matter7.default(content, {
     engines: { javascript: { parse: () => ({}) } }
   });
@@ -58613,12 +58723,12 @@ var init_timeline_builder = __esm(() => {
 
 // src/domains/plan-parser/plan-validator.ts
 import { existsSync as existsSync32, readFileSync as readFileSync8 } from "node:fs";
-import { basename as basename16, dirname as dirname17 } from "node:path";
+import { basename as basename16, dirname as dirname18 } from "node:path";
 function validatePlanFile(filePath, strict = false) {
   const rawContent = readFileSync8(filePath, "utf8");
   const content = rawContent.replace(/\r\n/g, `
 `);
-  const dir = dirname17(filePath);
+  const dir = dirname18(filePath);
   const issues = [];
   const lines = content.split(`
 `);
@@ -58684,7 +58794,7 @@ var init_plan_validator = __esm(() => {
 import { execSync } from "node:child_process";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "node:fs";
 import { existsSync as existsSync33 } from "node:fs";
-import { basename as basename17, dirname as dirname18, join as join51 } from "node:path";
+import { basename as basename17, dirname as dirname19, join as join51 } from "node:path";
 function phaseNameToFilename(id, name) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
   const num = numMatch ? numMatch[1] : id;
@@ -58898,7 +59008,7 @@ function updatePhaseStatus(planFile, phaseId, newStatus) {
   const updatedFrontmatter = { ...frontmatter, status: planStatus };
   const updatedContent = import_gray_matter9.default.stringify(updatedBody, updatedFrontmatter);
   writeFileSync3(planFile, updatedContent, "utf8");
-  const planDir = dirname18(planFile);
+  const planDir = dirname19(planFile);
   const phaseFilename = phaseNameFilenameFromTableRow(updatedBody, phaseId, planDir);
   if (phaseFilename && existsSync33(phaseFilename)) {
     updatePhaseFileFrontmatter(phaseFilename, newStatus);
@@ -58934,7 +59044,7 @@ function addPhase(planFile, name, afterId) {
   const { data: frontmatter, content: body } = import_gray_matter9.default(raw, {
     engines: { javascript: { parse: () => ({}) } }
   });
-  const planDir = dirname18(planFile);
+  const planDir = dirname19(planFile);
   const existingIds = [];
   for (const match of body.matchAll(/^\|\s*(\d+[a-z]?)\s*\|/gim)) {
     existingIds.push(match[1].toLowerCase());
@@ -59007,7 +59117,7 @@ var init_plan_writer = __esm(() => {
 });
 
 // src/domains/plan-parser/index.ts
-import { dirname as dirname19 } from "node:path";
+import { dirname as dirname20 } from "node:path";
 function buildPlanSummary(planFile) {
   const { frontmatter, phases } = parsePlanFile(planFile);
   const completed = phases.filter((p) => p.status === "completed").length;
@@ -59015,7 +59125,7 @@ function buildPlanSummary(planFile) {
   const pending = phases.filter((p) => p.status === "pending").length;
   const metadata = readPlanMetadata(planFile, { total: phases.length, completed, inProgress });
   return {
-    planDir: dirname19(planFile),
+    planDir: dirname20(planFile),
     planFile,
     title: metadata.title ?? (typeof frontmatter.title === "string" ? frontmatter.title : undefined),
     description: metadata.description ?? (typeof frontmatter.description === "string" ? frontmatter.description : undefined),
@@ -59275,7 +59385,7 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname20, isAbsolute as isAbsolute7, join as join52, parse as parse2, relative as relative12, resolve as resolve24 } from "node:path";
+import { dirname as dirname21, isAbsolute as isAbsolute7, join as join52, parse as parse2, relative as relative12, resolve as resolve24 } from "node:path";
 function createEmptyRegistry() {
   return {
     version: 1,
@@ -59341,7 +59451,7 @@ function findProjectRoot(startDir) {
     if (existsSync34(join52(dir, ".claude")) || existsSync34(join52(dir, ".git"))) {
       return dir;
     }
-    dir = dirname20(dir);
+    dir = dirname21(dir);
   }
   return startDir;
 }
@@ -59362,7 +59472,7 @@ function writeRegistry(registry, cwd2 = process.cwd()) {
   const globalPath = PathResolver.getPlansRegistryPath(cwd2);
   const toWrite = { ...registry, projectRoot: cwd2 };
   const validated = PlansRegistrySchema.parse(toWrite);
-  mkdirSync3(dirname20(globalPath), { recursive: true });
+  mkdirSync3(dirname21(globalPath), { recursive: true });
   if (existsSync34(globalPath)) {
     try {
       writeFileSync4(`${globalPath}.bak`, readFileSync10(globalPath));
@@ -59472,7 +59582,7 @@ var init_plans_registry = __esm(() => {
 });
 
 // src/domains/plan-actions/action-executor.ts
-import { dirname as dirname21, join as join53 } from "node:path";
+import { dirname as dirname22, join as join53 } from "node:path";
 function getPlanFile(planDir) {
   return join53(planDir, "plan.md");
 }
@@ -59486,7 +59596,7 @@ function assertPhaseId(phaseId) {
 function syncDashboardTracking(planFile) {
   const summary = buildPlanSummary(planFile);
   try {
-    const planDir = dirname21(planFile);
+    const planDir = dirname22(planFile);
     const projectRoot = findProjectRoot(planDir);
     updateRegistryPhaseStatus({
       planDir,
@@ -59749,7 +59859,7 @@ var init_p_limit = __esm(() => {
 // src/domains/web-server/routes/plan-routes.ts
 import { existsSync as existsSync35, readFileSync as readFileSync11, realpathSync } from "node:fs";
 import { homedir as homedir31 } from "node:os";
-import { basename as basename18, dirname as dirname22, join as join54, relative as relative13, resolve as resolve25, sep as sep8 } from "node:path";
+import { basename as basename18, dirname as dirname23, join as join54, relative as relative13, resolve as resolve25, sep as sep8 } from "node:path";
 function sanitizeError(err) {
   if (err instanceof Error) {
     if (/^(ENOENT|EACCES|EPERM|EISDIR)/.test(err.message))
@@ -59900,8 +60010,8 @@ function createDiscoveredProjectId(projectPath) {
 function toProjectPlanListItem(summary, plansDir) {
   return {
     file: relative13(plansDir, summary.planFile),
-    name: basename18(dirname22(summary.planFile)),
-    slug: basename18(dirname22(summary.planFile)),
+    name: basename18(dirname23(summary.planFile)),
+    slug: basename18(dirname23(summary.planFile)),
     summary: {
       ...summary,
       planDir: relative13(plansDir, summary.planDir),
@@ -59983,8 +60093,8 @@ function registerPlanRoutes(app) {
       const summaries = buildPlanSummaries(entries.slice(offset, offset + limit));
       const plans = summaries.map((summary) => ({
         file: relative13(process.cwd(), summary.planFile),
-        name: basename18(dirname22(summary.planFile)),
-        slug: basename18(dirname22(summary.planFile)),
+        name: basename18(dirname23(summary.planFile)),
+        slug: basename18(dirname23(summary.planFile)),
         summary: {
           ...summary,
           planDir: relative13(process.cwd(), summary.planDir),
@@ -61070,7 +61180,7 @@ var init_settings_routes = __esm(() => {
 // src/domains/skills/skill-catalog-generator.ts
 import { mkdir as mkdir14, readFile as readFile28, readdir as readdir15, rename as rename9, stat as stat11, writeFile as writeFile13 } from "node:fs/promises";
 import { homedir as homedir35 } from "node:os";
-import { dirname as dirname23, join as join57, relative as relative14 } from "node:path";
+import { dirname as dirname24, join as join57, relative as relative14 } from "node:path";
 async function hasScripts(skillPath) {
   try {
     const entries = await readdir15(skillPath, { withFileTypes: true });
@@ -61136,7 +61246,7 @@ class SkillCatalogGenerator {
     };
   }
   async write(catalog) {
-    await mkdir14(dirname23(CATALOG_PATH), { recursive: true });
+    await mkdir14(dirname24(CATALOG_PATH), { recursive: true });
     const tmpPath = `${CATALOG_PATH}.tmp`;
     const json = JSON.stringify(catalog, null, 2);
     await writeFile13(tmpPath, json, "utf-8");
@@ -61667,16 +61777,16 @@ var init_agents = __esm(() => {
 import { existsSync as existsSync39 } from "node:fs";
 import { mkdir as mkdir15, readFile as readFile30, writeFile as writeFile14 } from "node:fs/promises";
 import { homedir as homedir38 } from "node:os";
-import { dirname as dirname24, join as join60, sep as sep10 } from "node:path";
+import { dirname as dirname25, join as join60, sep as sep10 } from "node:path";
 function getCliVersion3() {
   try {
     if (process.env.npm_package_version) {
       return process.env.npm_package_version;
     }
     const { readFileSync: readFileSync12 } = __require("node:fs");
-    const { dirname: dirname25, join: joinPath } = __require("node:path");
+    const { dirname: dirname26, join: joinPath } = __require("node:path");
     const { fileURLToPath: fileURLToPath2 } = __require("node:url");
-    const __dirname3 = dirname25(fileURLToPath2(import.meta.url));
+    const __dirname3 = dirname26(fileURLToPath2(import.meta.url));
     const pkgPath = joinPath(__dirname3, "../../../package.json");
     const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
     return pkg.version || "unknown";
@@ -61719,7 +61829,7 @@ async function readRegistry2() {
   }
 }
 async function writeRegistry2(registry) {
-  const dir = dirname24(REGISTRY_PATH2);
+  const dir = dirname25(REGISTRY_PATH2);
   if (!existsSync39(dir)) {
     await mkdir15(dir, { recursive: true });
   }
@@ -61811,7 +61921,7 @@ var init_skills_registry = __esm(() => {
 import { existsSync as existsSync40 } from "node:fs";
 import { cp as cp3, mkdir as mkdir16, rm as rm8, stat as stat12 } from "node:fs/promises";
 import { homedir as homedir39 } from "node:os";
-import { dirname as dirname25, join as join61, resolve as resolve28 } from "node:path";
+import { dirname as dirname26, join as join61, resolve as resolve28 } from "node:path";
 function isSamePath2(path1, path22) {
   try {
     return resolve28(path1) === resolve28(path22);
@@ -61880,7 +61990,7 @@ async function installSkillForAgent(skill, agent, options2) {
     try {
       await cleanupLegacySkillPath(skill.name, agent, options2.global);
     } catch {}
-    const parentDir = dirname25(targetPath);
+    const parentDir = dirname26(targetPath);
     if (!existsSync40(parentDir)) {
       await mkdir16(parentDir, { recursive: true });
     }
@@ -62890,7 +63000,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.2.1",
+    version: "4.2.3-dev.1",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -65970,7 +66080,7 @@ var init_routes = __esm(() => {
 
 // src/domains/web-server/static-server.ts
 import { existsSync as existsSync45 } from "node:fs";
-import { basename as basename21, dirname as dirname26, join as join70, resolve as resolve30 } from "node:path";
+import { basename as basename21, dirname as dirname27, join as join70, resolve as resolve30 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function addRuntimeUiCandidate(candidates, runtimePath) {
   if (!runtimePath) {
@@ -65980,7 +66090,7 @@ function addRuntimeUiCandidate(candidates, runtimePath) {
   if (!looksLikePath) {
     return;
   }
-  const entryDir = dirname26(resolve30(runtimePath));
+  const entryDir = dirname27(resolve30(runtimePath));
   if (basename21(entryDir) === "dist") {
     candidates.add(join70(entryDir, "ui"));
   }
@@ -66041,7 +66151,7 @@ var import_express, __dirname3;
 var init_static_server = __esm(() => {
   init_logger();
   import_express = __toESM(require_express2(), 1);
-  __dirname3 = dirname26(fileURLToPath2(import.meta.url));
+  __dirname3 = dirname27(fileURLToPath2(import.meta.url));
 });
 
 // node_modules/ws/lib/constants.js
@@ -71527,7 +71637,7 @@ var init_skills_installer2 = __esm(() => {
 // src/services/package-installer/gemini-mcp/config-manager.ts
 import { existsSync as existsSync59 } from "node:fs";
 import { mkdir as mkdir23, readFile as readFile46, writeFile as writeFile22 } from "node:fs/promises";
-import { dirname as dirname29, join as join92 } from "node:path";
+import { dirname as dirname30, join as join92 } from "node:path";
 async function readJsonFile(filePath) {
   try {
     const content = await readFile46(filePath, "utf-8");
@@ -71567,7 +71677,7 @@ ${geminiPattern}
   }
 }
 async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
-  const linkDir = dirname29(geminiSettingsPath);
+  const linkDir = dirname30(geminiSettingsPath);
   if (!existsSync59(linkDir)) {
     await mkdir23(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
@@ -71686,9 +71796,9 @@ var init_validation = __esm(() => {
 // src/services/package-installer/gemini-mcp/linker-core.ts
 import { existsSync as existsSync61 } from "node:fs";
 import { mkdir as mkdir24, symlink as symlink3 } from "node:fs/promises";
-import { dirname as dirname30, join as join94 } from "node:path";
+import { dirname as dirname31, join as join94 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
-  const linkDir = dirname30(linkPath);
+  const linkDir = dirname31(linkPath);
   if (!existsSync61(linkDir)) {
     await mkdir24(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
@@ -74006,76 +74116,6 @@ var init_ownership_display = __esm(() => {
   import_picocolors25 = __toESM(require_picocolors(), 1);
 });
 
-// src/ui/node_modules/picocolors/picocolors.js
-var require_picocolors2 = __commonJS((exports, module) => {
-  var p = process || {};
-  var argv = p.argv || [];
-  var env2 = p.env || {};
-  var isColorSupported = !(!!env2.NO_COLOR || argv.includes("--no-color")) && (!!env2.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env2.TERM !== "dumb" || !!env2.CI);
-  var formatter = (open6, close, replace3 = open6) => (input) => {
-    let string = "" + input, index = string.indexOf(close, open6.length);
-    return ~index ? open6 + replaceClose(string, close, replace3, index) + close : open6 + string + close;
-  };
-  var replaceClose = (string, close, replace3, index) => {
-    let result = "", cursor = 0;
-    do {
-      result += string.substring(cursor, index) + replace3;
-      cursor = index + close.length;
-      index = string.indexOf(close, cursor);
-    } while (~index);
-    return result + string.substring(cursor);
-  };
-  var createColors = (enabled = isColorSupported) => {
-    let f3 = enabled ? formatter : () => String;
-    return {
-      isColorSupported: enabled,
-      reset: f3("\x1B[0m", "\x1B[0m"),
-      bold: f3("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-      dim: f3("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-      italic: f3("\x1B[3m", "\x1B[23m"),
-      underline: f3("\x1B[4m", "\x1B[24m"),
-      inverse: f3("\x1B[7m", "\x1B[27m"),
-      hidden: f3("\x1B[8m", "\x1B[28m"),
-      strikethrough: f3("\x1B[9m", "\x1B[29m"),
-      black: f3("\x1B[30m", "\x1B[39m"),
-      red: f3("\x1B[31m", "\x1B[39m"),
-      green: f3("\x1B[32m", "\x1B[39m"),
-      yellow: f3("\x1B[33m", "\x1B[39m"),
-      blue: f3("\x1B[34m", "\x1B[39m"),
-      magenta: f3("\x1B[35m", "\x1B[39m"),
-      cyan: f3("\x1B[36m", "\x1B[39m"),
-      white: f3("\x1B[37m", "\x1B[39m"),
-      gray: f3("\x1B[90m", "\x1B[39m"),
-      bgBlack: f3("\x1B[40m", "\x1B[49m"),
-      bgRed: f3("\x1B[41m", "\x1B[49m"),
-      bgGreen: f3("\x1B[42m", "\x1B[49m"),
-      bgYellow: f3("\x1B[43m", "\x1B[49m"),
-      bgBlue: f3("\x1B[44m", "\x1B[49m"),
-      bgMagenta: f3("\x1B[45m", "\x1B[49m"),
-      bgCyan: f3("\x1B[46m", "\x1B[49m"),
-      bgWhite: f3("\x1B[47m", "\x1B[49m"),
-      blackBright: f3("\x1B[90m", "\x1B[39m"),
-      redBright: f3("\x1B[91m", "\x1B[39m"),
-      greenBright: f3("\x1B[92m", "\x1B[39m"),
-      yellowBright: f3("\x1B[93m", "\x1B[39m"),
-      blueBright: f3("\x1B[94m", "\x1B[39m"),
-      magentaBright: f3("\x1B[95m", "\x1B[39m"),
-      cyanBright: f3("\x1B[96m", "\x1B[39m"),
-      whiteBright: f3("\x1B[97m", "\x1B[39m"),
-      bgBlackBright: f3("\x1B[100m", "\x1B[49m"),
-      bgRedBright: f3("\x1B[101m", "\x1B[49m"),
-      bgGreenBright: f3("\x1B[102m", "\x1B[49m"),
-      bgYellowBright: f3("\x1B[103m", "\x1B[49m"),
-      bgBlueBright: f3("\x1B[104m", "\x1B[49m"),
-      bgMagentaBright: f3("\x1B[105m", "\x1B[49m"),
-      bgCyanBright: f3("\x1B[106m", "\x1B[49m"),
-      bgWhiteBright: f3("\x1B[107m", "\x1B[49m")
-    };
-  };
-  module.exports = createColors();
-  module.exports.createColors = createColors;
-});
-
 // src/commands/watch/phases/implementation-git-helpers.ts
 import { spawn as spawn5 } from "node:child_process";
 async function getCurrentBranch2(cwd2) {
@@ -75105,7 +75145,7 @@ var init_sqlite_client = () => {};
 
 // src/commands/content/phases/db-manager.ts
 import { existsSync as existsSync80, mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname47 } from "node:path";
+import { dirname as dirname48 } from "node:path";
 function initDatabase(dbPath) {
   ensureParentDir(dbPath);
   const db = openDatabase(dbPath);
@@ -75126,7 +75166,7 @@ function runRetentionCleanup(db, retentionDays = 90) {
   db.prepare("DELETE FROM git_events WHERE processed = 1 AND created_at < ?").run(cutoff);
 }
 function ensureParentDir(dbPath) {
-  const dir = dirname47(dbPath);
+  const dir = dirname48(dbPath);
   if (dir && !existsSync80(dir)) {
     mkdirSync8(dir, { recursive: true });
   }
@@ -85190,12 +85230,13 @@ async function applyBudgetDefaults(settingsPath, projectClaudeDir, requiredFract
 var ENGINEER_SKILL_COUNT_THRESHOLD = 20;
 async function checkSkillBudget(setup, projectDir) {
   const projectClaudeDir = resolve31(projectDir, ".claude");
-  const globalClaudeDir = PathResolver.getGlobalKitDir();
+  const globalClaudeDir = resolve31(PathResolver.getGlobalKitDir());
+  const projectScopeAliasesGlobal = projectClaudeDir === globalClaudeDir;
   const [projectSkills, globalSkills] = await Promise.all([
-    scanSkills2(join75(projectClaudeDir, "skills")),
+    projectScopeAliasesGlobal ? Promise.resolve([]) : scanSkills2(join75(projectClaudeDir, "skills")),
     scanSkills2(join75(globalClaudeDir, "skills"))
   ]);
-  if (!isEngineerLikeProject(setup, projectSkills))
+  if (!isEngineerLikeProject(setup, [...projectSkills, ...globalSkills]))
     return [];
   const settingsPath = join75(projectClaudeDir, "settings.json");
   const settings = await readProjectSettings(settingsPath);
@@ -85216,7 +85257,10 @@ function isEngineerLikeProject(setup, projectSkills) {
   const metadataText = [
     setup.project.metadata?.name,
     setup.project.metadata?.description,
-    setup.project.metadata?.repository?.url
+    setup.project.metadata?.repository?.url,
+    setup.global.metadata?.name,
+    setup.global.metadata?.description,
+    setup.global.metadata?.repository?.url
   ].filter(Boolean).join(" ").toLowerCase();
   return metadataText.includes("engineer") || projectSkills.length >= ENGINEER_SKILL_COUNT_THRESHOLD;
 }
@@ -85593,7 +85637,7 @@ init_path_resolver();
 import { existsSync as existsSync54 } from "node:fs";
 import { readFile as readFile41 } from "node:fs/promises";
 import { homedir as homedir41 } from "node:os";
-import { dirname as dirname27, join as join79, normalize as normalize6, resolve as resolve32 } from "node:path";
+import { dirname as dirname28, join as join79, normalize as normalize6, resolve as resolve32 } from "node:path";
 async function checkPathRefsValid(projectDir) {
   const globalClaudeMd = join79(PathResolver.getGlobalKitDir(), "CLAUDE.md");
   const projectClaudeMd = join79(projectDir, ".claude", "CLAUDE.md");
@@ -85624,7 +85668,7 @@ async function checkPathRefsValid(projectDir) {
         autoFixable: false
       };
     }
-    const baseDir = dirname27(claudeMdPath);
+    const baseDir = dirname28(claudeMdPath);
     const home6 = homedir41();
     const broken = [];
     for (const ref of refs) {
@@ -86280,7 +86324,7 @@ function getClaudeSettingsFiles(projectDir) {
   return candidates.filter((candidate) => existsSync56(candidate.path));
 }
 function isAlreadyCanonical(cmd) {
-  return /^node\s+"\$HOME\/\.claude\/[^"]+"/.test(cmd) || /^node\s+"\$CLAUDE_PROJECT_DIR"\/\.claude\/\S+/.test(cmd);
+  return /^node\s+"\$HOME\/\.claude\/[^"]+"/.test(cmd) || /^node\s+"\$CLAUDE_PROJECT_DIR"\/\.claude\/\S+/.test(cmd) || /^bash\s+"\$HOME\/\.claude\/hooks\/node-hook-runner\.sh"\s+"\$HOME\/\.claude\/[^"]+"/.test(cmd) || /^bash\s+"\$CLAUDE_PROJECT_DIR"\/\.claude\/hooks\/node-hook-runner\.sh\s+"\$CLAUDE_PROJECT_DIR"\/\.claude\/\S+/.test(cmd);
 }
 function collectHookCommandFindings(settings, settingsFile) {
   if (!settings.hooks) {
@@ -86292,7 +86336,7 @@ function collectHookCommandFindings(settings, settingsFile) {
       if ("command" in entry && typeof entry.command === "string") {
         if (isAlreadyCanonical(entry.command))
           continue;
-        const repair = repairClaudeNodeCommandPath(entry.command, settingsFile.root);
+        const repair = repairClaudeHookCommandPath(entry.command, settingsFile.root);
         if (repair.changed && repair.issue) {
           findings.push({
             path: settingsFile.path,
@@ -86313,7 +86357,7 @@ function collectHookCommandFindings(settings, settingsFile) {
         }
         if (isAlreadyCanonical(hook.command))
           continue;
-        const repair = repairClaudeNodeCommandPath(hook.command, settingsFile.root);
+        const repair = repairClaudeHookCommandPath(hook.command, settingsFile.root);
         if (!repair.changed || !repair.issue) {
           continue;
         }
@@ -88647,14 +88691,14 @@ class AutoHealer {
 import { execSync as execSync4, spawnSync as spawnSync6 } from "node:child_process";
 import { readFileSync as readFileSync16, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname28, join as join87 } from "node:path";
+import { dirname as dirname29, join as join87 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 init_environment();
 init_logger();
 init_dist2();
 function getCliVersion4() {
   try {
-    const __dirname4 = dirname28(fileURLToPath4(import.meta.url));
+    const __dirname4 = dirname29(fileURLToPath4(import.meta.url));
     const pkgPath = join87(__dirname4, "../../../package.json");
     const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
     return pkg.version || "unknown";
@@ -89119,7 +89163,7 @@ init_github_client();
 init_config_version_checker();
 
 // src/domains/sync/sync-engine.ts
-import { lstat as lstat6, readFile as readFile45, readlink as readlink2, realpath as realpath6, stat as stat14 } from "node:fs/promises";
+import { lstat as lstat6, readFile as readFile45, readlink as readlink2, realpath as realpath7, stat as stat14 } from "node:fs/promises";
 import { isAbsolute as isAbsolute8, join as join88, normalize as normalize8, relative as relative17 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
@@ -89747,14 +89791,14 @@ class JsonDiff extends Diff {
   }
   castInput(value, options2) {
     const { undefinedReplacement, stringifyReplacer = (k2, v2) => typeof v2 === "undefined" ? undefinedReplacement : v2 } = options2;
-    return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
+    return typeof value === "string" ? value : JSON.stringify(canonicalize2(value, null, null, stringifyReplacer), null, "  ");
   }
   equals(left, right, options2) {
     return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options2);
   }
 }
 var jsonDiff = new JsonDiff;
-function canonicalize(obj, stack, replacementStack, replacer, key) {
+function canonicalize2(obj, stack, replacementStack, replacer, key) {
   stack = stack || [];
   replacementStack = replacementStack || [];
   if (replacer) {
@@ -89772,7 +89816,7 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
     canonicalizedObj = new Array(obj.length);
     replacementStack.push(canonicalizedObj);
     for (i = 0;i < obj.length; i += 1) {
-      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
+      canonicalizedObj[i] = canonicalize2(obj[i], stack, replacementStack, replacer, String(i));
     }
     stack.pop();
     replacementStack.pop();
@@ -89795,7 +89839,7 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
     sortedKeys.sort();
     for (i = 0;i < sortedKeys.length; i += 1) {
       key2 = sortedKeys[i];
-      canonicalizedObj[key2] = canonicalize(obj[key2], stack, replacementStack, replacer, key2);
+      canonicalizedObj[key2] = canonicalize2(obj[key2], stack, replacementStack, replacer, key2);
     }
     stack.pop();
     replacementStack.pop();
@@ -90378,8 +90422,8 @@ async function validateSyncPath(basePath, filePath) {
   }
   await validateSymlinkChain(fullPath, basePath);
   try {
-    const resolvedBase = await realpath6(basePath);
-    const resolvedFull = await realpath6(fullPath);
+    const resolvedBase = await realpath7(basePath);
+    const resolvedFull = await realpath7(fullPath);
     const resolvedRel = relative17(resolvedBase, resolvedFull);
     if (resolvedRel.startsWith("..") || isAbsolute8(resolvedRel)) {
       throw new Error(`Symlink escapes base directory: ${filePath}`);
@@ -90388,8 +90432,8 @@ async function validateSyncPath(basePath, filePath) {
     if (error.code === "ENOENT") {
       const parentPath = join88(fullPath, "..");
       try {
-        const resolvedBase = await realpath6(basePath);
-        const resolvedParent = await realpath6(parentPath);
+        const resolvedBase = await realpath7(basePath);
+        const resolvedParent = await realpath7(parentPath);
         const resolvedRel = relative17(resolvedBase, resolvedParent);
         if (resolvedRel.startsWith("..") || isAbsolute8(resolvedRel)) {
           throw new Error(`Parent symlink escapes base directory: ${filePath}`);
@@ -93222,7 +93266,7 @@ import path9 from "node:path";
 
 // node_modules/tar/dist/esm/list.js
 import fs10 from "node:fs";
-import { dirname as dirname31, parse as parse4 } from "path";
+import { dirname as dirname32, parse as parse4 } from "path";
 
 // node_modules/tar/dist/esm/options.js
 var argmap = new Map([
@@ -96122,7 +96166,7 @@ var filesFilter = (opt, files) => {
       if (m2 !== undefined) {
         ret = m2;
       } else {
-        ret = mapHas(dirname31(file), root);
+        ret = mapHas(dirname32(file), root);
       }
     }
     map.set(file, ret);
@@ -99865,7 +99909,7 @@ import { join as join120 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync62, lstatSync as lstatSync3, readdirSync as readdirSync7, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname33, join as join106, relative as relative20, resolve as resolve38, sep as sep11 } from "node:path";
+import { dirname as dirname34, join as join106, relative as relative20, resolve as resolve38, sep as sep11 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
@@ -100091,7 +100135,7 @@ function expandGlobPatterns(patterns, claudeDir3) {
 var MAX_CLEANUP_ITERATIONS = 50;
 function cleanupEmptyDirectories(filePath, claudeDir3) {
   const normalizedClaudeDir = resolve38(claudeDir3);
-  let currentDir = resolve38(dirname33(filePath));
+  let currentDir = resolve38(dirname34(filePath));
   let iterations = 0;
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
     iterations++;
@@ -100100,7 +100144,7 @@ function cleanupEmptyDirectories(filePath, claudeDir3) {
       if (entries.length === 0) {
         rmdirSync(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve38(dirname33(currentDir));
+        currentDir = resolve38(dirname34(currentDir));
       } else {
         break;
       }
@@ -100223,7 +100267,7 @@ init_logger();
 init_types3();
 var import_fs_extra15 = __toESM(require_lib(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname36, join as join110, relative as relative22 } from "node:path";
+import { dirname as dirname37, join as join110, relative as relative22 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat18 } from "node:fs/promises";
@@ -101894,13 +101938,13 @@ class FileScanner {
 // src/domains/installation/merger/settings-processor.ts
 import { execSync as execSync5 } from "node:child_process";
 import { homedir as homedir45 } from "node:os";
-import { dirname as dirname35, join as join109 } from "node:path";
+import { dirname as dirname36, join as join109 } from "node:path";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
 import { existsSync as existsSync63 } from "node:fs";
 import { mkdir as mkdir31, readFile as readFile49, writeFile as writeFile24 } from "node:fs/promises";
-import { dirname as dirname34, join as join108 } from "node:path";
+import { dirname as dirname35, join as join108 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -101951,7 +101995,7 @@ class InstalledSettingsTracker {
         data.kits[this.kitName] = {};
       }
       data.kits[this.kitName].installedSettings = settings;
-      await mkdir31(dirname34(ckJsonPath), { recursive: true });
+      await mkdir31(dirname35(ckJsonPath), { recursive: true });
       await writeFile24(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
       logger.debug(`Saved installed settings to ${ckJsonPath}`);
     } catch (error) {
@@ -102054,7 +102098,7 @@ class SettingsProcessor {
       } else {
         try {
           const parsedSettings = JSON.parse(transformedSource);
-          this.fixHookCommandPaths(parsedSettings);
+          this.logHookCommandRepair(this.fixHookCommandPaths(parsedSettings), "fresh install");
           await SettingsMerger.writeSettingsFile(destFile, parsedSettings);
           try {
             if (this.forceOverwriteSettings && destExists) {
@@ -102132,10 +102176,7 @@ class SettingsProcessor {
       }
       await this.tracker.saveInstalledSettings(installedSettings);
     }
-    const pathsFixed = this.fixHookCommandPaths(mergeResult.merged);
-    if (pathsFixed) {
-      logger.info("Fixed hook command paths to canonical quoted format");
-    }
+    this.logHookCommandRepair(this.fixHookCommandPaths(mergeResult.merged), "merged settings");
     const hooksPruned = this.pruneDeletedHooks(mergeResult.merged);
     if (hooksPruned > 0) {
       logger.info(`Pruned ${hooksPruned} stale hook(s) referencing deleted files`);
@@ -102279,7 +102320,7 @@ class SettingsProcessor {
       if (!content.trim())
         return null;
       const parsedSettings = JSON.parse(content);
-      this.fixHookCommandPaths(parsedSettings);
+      this.logHookCommandRepair(this.fixHookCommandPaths(parsedSettings), "existing global settings");
       return parsedSettings;
     } catch {
       return null;
@@ -102302,8 +102343,14 @@ class SettingsProcessor {
     }
     return transformed;
   }
+  logHookCommandRepair(count, context) {
+    if (count <= 0)
+      return;
+    const suffix = context ? ` (${context})` : "";
+    logger.info(`Repaired ${count} hook command path(s) to canonical quoted format${suffix} — protects against shells word-splitting on usernames with spaces`);
+  }
   fixHookCommandPaths(settings) {
-    let fixed = false;
+    let fixed = 0;
     if (settings.hooks) {
       for (const entries of Object.values(settings.hooks)) {
         for (const entry of entries) {
@@ -102311,7 +102358,7 @@ class SettingsProcessor {
             const result = this.fixSingleCommandPath(entry.command);
             if (result !== entry.command) {
               entry.command = result;
-              fixed = true;
+              fixed++;
             }
           }
           if ("hooks" in entry && entry.hooks) {
@@ -102320,7 +102367,7 @@ class SettingsProcessor {
                 const result = this.fixSingleCommandPath(hook.command);
                 if (result !== hook.command) {
                   hook.command = result;
-                  fixed = true;
+                  fixed++;
                 }
               }
             }
@@ -102333,13 +102380,13 @@ class SettingsProcessor {
       const result = this.fixSingleCommandPath(statusLine.command);
       if (result !== statusLine.command) {
         statusLine.command = result;
-        fixed = true;
+        fixed++;
       }
     }
     return fixed;
   }
   fixSingleCommandPath(cmd) {
-    return repairClaudeNodeCommandPath(cmd, this.getClaudeCommandRoot()).command;
+    return repairClaudeHookCommandPath(cmd, this.getClaudeCommandRoot()).command;
   }
   formatCommandPath(nodePrefix, capturedVar, relativePath, suffix = "") {
     const canonicalRoot = this.canonicalizePathRoot(capturedVar);
@@ -102391,20 +102438,19 @@ class SettingsProcessor {
       return false;
     }
     const pathsFixed = this.fixHookCommandPaths(settings);
-    if (!pathsFixed) {
+    if (pathsFixed === 0) {
       return false;
     }
+    this.logHookCommandRepair(pathsFixed, filePath);
     await SettingsMerger.writeSettingsFile(filePath, settings);
     return true;
   }
   async repairSiblingSettingsLocal(destFile) {
-    const settingsLocalPath = join109(dirname35(destFile), "settings.local.json");
+    const settingsLocalPath = join109(dirname36(destFile), "settings.local.json");
     if (settingsLocalPath === destFile || !await import_fs_extra14.pathExists(settingsLocalPath)) {
       return;
     }
-    if (await this.repairSettingsFile(settingsLocalPath)) {
-      logger.info(`Repaired stale .claude command paths in ${settingsLocalPath}`);
-    }
+    await this.repairSettingsFile(settingsLocalPath);
   }
   detectClaudeCodeVersion() {
     if (this.cachedVersion !== undefined)
@@ -102660,10 +102706,10 @@ class CopyExecutor {
   }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname36(relativePath);
+    let dir = dirname37(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname36(dir);
+      dir = dirname37(dir);
     }
   }
 }
@@ -105813,7 +105859,7 @@ async function runPreflightChecks() {
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
 import { existsSync as existsSync64, readdirSync as readdirSync8, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
-import { basename as basename25, dirname as dirname37, join as join132, resolve as resolve40 } from "node:path";
+import { basename as basename25, dirname as dirname38, join as join132, resolve as resolve40 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra34 = __toESM(require_lib(), 1);
@@ -105866,14 +105912,14 @@ async function analyzeFreshInstallation(claudeDir3) {
 }
 function cleanupEmptyDirectories2(filePath, claudeDir3) {
   const normalizedClaudeDir = resolve40(claudeDir3);
-  let currentDir = resolve40(dirname37(filePath));
+  let currentDir = resolve40(dirname38(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync8(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve40(dirname37(currentDir));
+        currentDir = resolve40(dirname38(currentDir));
       } else {
         break;
       }
@@ -106440,7 +106486,7 @@ async function handleSelection(ctx) {
 }
 // src/commands/init/phases/sync-handler.ts
 import { copyFile as copyFile8, mkdir as mkdir36, open as open5, readFile as readFile58, rename as rename10, stat as stat22, unlink as unlink12, writeFile as writeFile32 } from "node:fs/promises";
-import { dirname as dirname38, join as join134, resolve as resolve43 } from "node:path";
+import { dirname as dirname39, join as join134, resolve as resolve43 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra36 = __toESM(require_lib(), 1);
@@ -106559,7 +106605,7 @@ async function acquireSyncLock(global3) {
   const lockPath = join134(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir36(dirname38(lockPath), { recursive: true });
+  await mkdir36(dirname39(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open5(lockPath, "wx");
@@ -107512,7 +107558,7 @@ import { basename as basename27, join as join142, resolve as resolve46 } from "n
 init_logger();
 
 // src/ui/ck-cli-design/tokens.ts
-var import_picocolors27 = __toESM(require_picocolors2(), 1);
+var import_picocolors27 = __toESM(require_picocolors(), 1);
 import { homedir as homedir47, platform as platform16 } from "node:os";
 import { resolve as resolve45, win32 as win322 } from "node:path";
 var PANEL_MIN_WIDTH = 60;
@@ -107985,7 +108031,7 @@ init_dist2();
 init_model_taxonomy();
 import { mkdir as mkdir38, readFile as readFile63, writeFile as writeFile36 } from "node:fs/promises";
 import { homedir as homedir50 } from "node:os";
-import { dirname as dirname39, join as join141 } from "node:path";
+import { dirname as dirname40, join as join141 } from "node:path";
 
 // src/commands/portable/models-dev-cache.ts
 init_logger();
@@ -108338,7 +108384,7 @@ async function ensureOpenCodeModel(options2) {
     }
     const chosenModel2 = response2.action === "custom" ? response2.value : suggestion2.model;
     const next2 = { ...existing, model: chosenModel2 };
-    await mkdir38(dirname39(configPath), { recursive: true });
+    await mkdir38(dirname40(configPath), { recursive: true });
     await writeFile36(configPath, `${JSON.stringify(next2, null, 2)}
 `, "utf-8");
     return { path: configPath, action: "added", model: chosenModel2, reason: suggestion2.reason };
@@ -108349,7 +108395,7 @@ async function ensureOpenCodeModel(options2) {
       throw new OpenCodeAuthRequiredError(suggestion.failure);
     }
     const next2 = { ...existing ?? {}, model: suggestion.model };
-    await mkdir38(dirname39(configPath), { recursive: true });
+    await mkdir38(dirname40(configPath), { recursive: true });
     await writeFile36(configPath, `${JSON.stringify(next2, null, 2)}
 `, "utf-8");
     return {
@@ -108371,7 +108417,7 @@ async function ensureOpenCodeModel(options2) {
   }
   const chosenModel = response.action === "custom" ? response.value : suggestion.ok ? suggestion.model : "";
   const next = { ...existing ?? {}, model: chosenModel };
-  await mkdir38(dirname39(configPath), { recursive: true });
+  await mkdir38(dirname40(configPath), { recursive: true });
   await writeFile36(configPath, `${JSON.stringify(next, null, 2)}
 `, "utf-8");
   return {
@@ -108384,7 +108430,7 @@ async function ensureOpenCodeModel(options2) {
 
 // src/commands/portable/plan-display.ts
 var import_picocolors28 = __toESM(require_picocolors(), 1);
-import { basename as basename26, dirname as dirname40, extname as extname7 } from "node:path";
+import { basename as basename26, dirname as dirname41, extname as extname7 } from "node:path";
 var DEFAULT_MAX_PLAN_GROUP_ITEMS = 20;
 var TYPE_ORDER = [
   "agent",
@@ -108610,21 +108656,21 @@ function collectPlannedWhereLines(plan) {
   return destinations.map((destination) => `${formatDisplayPath(destination)} -> ${formatCdHint(resolveCdTarget(destination))}`);
 }
 function resolveCdTarget(destination) {
-  return extname7(destination).length > 0 ? dirname40(destination) : destination;
+  return extname7(destination).length > 0 ? dirname41(destination) : destination;
 }
 function normalizeWhereDestination(path16, portableType) {
   if (portableType === "agent" || portableType === "command" || portableType === "skill") {
-    return dirname40(path16);
+    return dirname41(path16);
   }
   if (portableType === "hooks") {
-    return dirname40(path16);
+    return dirname41(path16);
   }
   if (portableType === "rules") {
     const fileName = basename26(path16).toLowerCase();
     if (fileName === "agents.md" || fileName === "gemini.md" || fileName === ".goosehints" || fileName === "custom_modes.yaml" || fileName === "custom_modes.yml") {
       return path16;
     }
-    return dirname40(path16);
+    return dirname41(path16);
   }
   return path16;
 }
@@ -110342,7 +110388,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync68, statSync as statSync12 } from "node:fs";
-import { dirname as dirname44, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve51 } from "node:path";
+import { dirname as dirname45, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve51 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -110352,18 +110398,18 @@ init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync67, statSync as statSync11 } from "node:fs";
-import { basename as basename28, dirname as dirname42, join as join146, relative as relative30, resolve as resolve49 } from "node:path";
+import { basename as basename28, dirname as dirname43, join as join146, relative as relative30, resolve as resolve49 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
 init_config();
 init_plan_parser();
 init_plans_registry();
 import { existsSync as existsSync66 } from "node:fs";
-import { dirname as dirname41, join as join145 } from "node:path";
+import { dirname as dirname42, join as join145 } from "node:path";
 async function resolvePlanDependencies(references, currentPlanFile, options2 = {}) {
   if (references.length === 0)
     return [];
-  const currentPlanDir = dirname41(currentPlanFile);
+  const currentPlanDir = dirname42(currentPlanFile);
   const projectRoot = findProjectRoot(currentPlanDir);
   const config = options2.preloadedConfig ?? (await CkConfigManager.loadFull(projectRoot)).config;
   const defaultScope = inferPlanScopeForDir(currentPlanDir, config);
@@ -110450,7 +110496,7 @@ async function handleParse(target, options2) {
     console.log(JSON.stringify({ file: relative30(process.cwd(), planFile), frontmatter, phases }, null, 2));
     return;
   }
-  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename28(dirname42(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename28(dirname43(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
@@ -110561,7 +110607,7 @@ async function handleStatus(target, options2) {
         const blockedBy2 = await resolvePlanDependencies(s.blockedBy, pf, { preloadedConfig });
         const blocks2 = await resolvePlanDependencies(s.blocks, pf, { preloadedConfig });
         const bar = progressBar(s.completed, s.totalPhases);
-        const title2 = s.title ?? basename28(dirname42(pf));
+        const title2 = s.title ?? basename28(dirname43(pf));
         console.log(`  ${import_picocolors32.default.bold(title2)}`);
         console.log(`  ${bar}`);
         if (s.inProgress > 0)
@@ -110580,7 +110626,7 @@ async function handleStatus(target, options2) {
         }
         console.log();
       } catch {
-        console.log(`  [X] Failed to read: ${basename28(dirname42(pf))}`);
+        console.log(`  [X] Failed to read: ${basename28(dirname43(pf))}`);
         console.log();
       }
     }
@@ -110607,7 +110653,7 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify({ ...summary, dependencyStatus: { blockedBy, blocks } }, null, 2));
     return;
   }
-  const title = summary.title ?? basename28(dirname42(planFile));
+  const title = summary.title ?? basename28(dirname43(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  ${title}`));
   if (summary.status)
@@ -110670,7 +110716,7 @@ async function handleKanban(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const route = `/plans?dir=${encodeURIComponent(dirname42(dirname42(planFile)))}&view=kanban`;
+  const route = `/plans?dir=${encodeURIComponent(dirname43(dirname43(planFile)))}&view=kanban`;
   const url = `http://localhost:${server.port}${route}`;
   console.log();
   console.log(import_picocolors32.default.bold("  ClaudeKit Dashboard — Plans"));
@@ -110705,7 +110751,7 @@ init_plan_parser();
 init_plans_registry();
 init_output_manager();
 var import_picocolors33 = __toESM(require_picocolors(), 1);
-import { basename as basename29, dirname as dirname43, relative as relative31, resolve as resolve50 } from "node:path";
+import { basename as basename29, dirname as dirname44, relative as relative31, resolve as resolve50 } from "node:path";
 async function handleCreate(target, options2) {
   if (!options2.title) {
     output.error("[X] --title is required for create");
@@ -110805,7 +110851,7 @@ async function handleCheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname43(planFile);
+  const planDir = dirname44(planFile);
   let planStatus = "pending";
   try {
     const projectRoot = findProjectRoot(planDir);
@@ -110854,7 +110900,7 @@ async function handleUncheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname43(planFile);
+  const planDir = dirname44(planFile);
   try {
     const projectRoot = findProjectRoot(planDir);
     const summary = buildPlanSummary(planFile);
@@ -110893,7 +110939,7 @@ async function handleAddPhase(target, options2) {
   try {
     const result = addPhase(planFile, target, options2.after);
     try {
-      const planDir = dirname43(planFile);
+      const planDir = dirname44(planFile);
       const projectRoot = findProjectRoot(planDir);
       updateRegistryAddPhase({
         planDir,
@@ -110947,7 +110993,7 @@ function resolvePlanFile(target, baseDir) {
       const candidate = join147(dir, "plan.md");
       if (existsSync68(candidate))
         return candidate;
-      dir = dirname44(dir);
+      dir = dirname45(dir);
     }
   }
   return null;
@@ -111466,7 +111512,7 @@ import { readFile as readFile65 } from "node:fs/promises";
 import { join as join149 } from "node:path";
 
 // src/commands/skills/installed-skills-inventory.ts
-import { join as join148 } from "node:path";
+import { join as join148, resolve as resolve53 } from "node:path";
 init_path_resolver();
 var SCOPE_SORT_ORDER = {
   project: 0,
@@ -111474,9 +111520,11 @@ var SCOPE_SORT_ORDER = {
 };
 async function getActiveClaudeSkillInstallations(options2 = {}) {
   const projectDir = options2.projectDir ?? process.cwd();
-  const globalDir = options2.globalDir ?? PathResolver.getGlobalKitDir();
+  const globalDir = resolve53(options2.globalDir ?? PathResolver.getGlobalKitDir());
+  const projectClaudeDir = resolve53(projectDir, ".claude");
+  const projectScopeAliasesGlobal = projectClaudeDir === globalDir;
   const [projectSkills, globalSkills] = await Promise.all([
-    scanSkills2(join148(projectDir, ".claude", "skills")),
+    projectScopeAliasesGlobal ? Promise.resolve([]) : scanSkills2(join148(projectClaudeDir, "skills")),
     scanSkills2(join148(globalDir, "skills"))
   ]);
   const projectIds = new Set(projectSkills.map((skill) => skill.id));
@@ -112220,7 +112268,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync10, rmSync as rmSync5 } from "node:fs";
-import { basename as basename30, join as join151, resolve as resolve53, sep as sep13 } from "node:path";
+import { basename as basename30, join as join151, resolve as resolve54, sep as sep13 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -112229,7 +112277,7 @@ var import_fs_extra41 = __toESM(require_lib(), 1);
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync9, rmSync as rmSync4 } from "node:fs";
-import { dirname as dirname45, join as join150 } from "node:path";
+import { dirname as dirname46, join as join150 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_fs_extra40 = __toESM(require_lib(), 1);
@@ -112251,7 +112299,7 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname45(filePath);
+  let currentDir = dirname46(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync9(currentDir);
@@ -112259,7 +112307,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
         rmSync4(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname45(currentDir);
+        currentDir = dirname46(currentDir);
       } else {
         break;
       }
@@ -112404,8 +112452,8 @@ async function restoreUninstallBackup(backup) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve53(filePath);
-    const resolvedBase = resolve53(baseDir);
+    const resolvedPath = resolve54(filePath);
+    const resolvedBase = resolve54(baseDir);
     if (!resolvedPath.startsWith(resolvedBase + sep13) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
@@ -112413,7 +112461,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
     const stats = await import_fs_extra41.lstat(filePath);
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra41.realpath(filePath);
-      const resolvedReal = resolve53(realPath);
+      const resolvedReal = resolve54(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep13) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
@@ -114181,7 +114229,7 @@ init_file_io();
 init_logger();
 import { existsSync as existsSync71 } from "node:fs";
 import { mkdir as mkdir40, readFile as readFile67 } from "node:fs/promises";
-import { dirname as dirname46 } from "node:path";
+import { dirname as dirname47 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
@@ -114211,7 +114259,7 @@ async function loadWatchState(projectDir) {
 }
 async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
-  const configDir = dirname46(configPath);
+  const configDir = dirname47(configPath);
   if (!existsSync71(configDir)) {
     await mkdir40(configDir, { recursive: true });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "4.2.1",
+	"version": "4.2.3-dev.1",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {