claudekit-cli 3.30.3 → 3.31.0-dev.2

package/dist/index.js

@@ -7762,6 +7762,7 @@ var init_commands = __esm(() => {
     release: exports_external.string().optional(),
     check: exports_external.boolean().default(false),
     yes: exports_external.boolean().default(false),
+    dev: exports_external.boolean().default(false),
     beta: exports_external.boolean().default(false),
     registry: exports_external.string().url().optional()
   }).merge(GlobalOutputOptionsSchema);
@@ -15652,8 +15653,1455 @@ var require_extract_zip = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/semver/internal/constants.js
+// node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS((exports, module) => {
+  var WIN_SLASH = "\\\\/";
+  var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+  var DOT_LITERAL = "\\.";
+  var PLUS_LITERAL = "\\+";
+  var QMARK_LITERAL = "\\?";
+  var SLASH_LITERAL = "\\/";
+  var ONE_CHAR = "(?=.)";
+  var QMARK = "[^/]";
+  var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+  var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+  var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+  var NO_DOT = `(?!${DOT_LITERAL})`;
+  var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+  var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+  var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+  var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+  var STAR = `${QMARK}*?`;
+  var SEP = "/";
+  var POSIX_CHARS = {
+    DOT_LITERAL,
+    PLUS_LITERAL,
+    QMARK_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    QMARK,
+    END_ANCHOR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOTS,
+    NO_DOT_SLASH,
+    NO_DOTS_SLASH,
+    QMARK_NO_DOT,
+    STAR,
+    START_ANCHOR,
+    SEP
+  };
+  var WINDOWS_CHARS = {
+    ...POSIX_CHARS,
+    SLASH_LITERAL: `[${WIN_SLASH}]`,
+    QMARK: WIN_NO_SLASH,
+    STAR: `${WIN_NO_SLASH}*?`,
+    DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+    NO_DOT: `(?!${DOT_LITERAL})`,
+    NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+    NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+    NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+    QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+    START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+    END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+    SEP: "\\"
+  };
+  var POSIX_REGEX_SOURCE = {
+    alnum: "a-zA-Z0-9",
+    alpha: "a-zA-Z",
+    ascii: "\\x00-\\x7F",
+    blank: " \\t",
+    cntrl: "\\x00-\\x1F\\x7F",
+    digit: "0-9",
+    graph: "\\x21-\\x7E",
+    lower: "a-z",
+    print: "\\x20-\\x7E ",
+    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+    space: " \\t\\r\\n\\v\\f",
+    upper: "A-Z",
+    word: "A-Za-z0-9_",
+    xdigit: "A-Fa-f0-9"
+  };
+  module.exports = {
+    MAX_LENGTH: 1024 * 64,
+    POSIX_REGEX_SOURCE,
+    REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+    REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+    REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+    REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+    REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+    REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+    REPLACEMENTS: {
+      __proto__: null,
+      "***": "*",
+      "**/**": "**",
+      "**/**/**": "**"
+    },
+    CHAR_0: 48,
+    CHAR_9: 57,
+    CHAR_UPPERCASE_A: 65,
+    CHAR_LOWERCASE_A: 97,
+    CHAR_UPPERCASE_Z: 90,
+    CHAR_LOWERCASE_Z: 122,
+    CHAR_LEFT_PARENTHESES: 40,
+    CHAR_RIGHT_PARENTHESES: 41,
+    CHAR_ASTERISK: 42,
+    CHAR_AMPERSAND: 38,
+    CHAR_AT: 64,
+    CHAR_BACKWARD_SLASH: 92,
+    CHAR_CARRIAGE_RETURN: 13,
+    CHAR_CIRCUMFLEX_ACCENT: 94,
+    CHAR_COLON: 58,
+    CHAR_COMMA: 44,
+    CHAR_DOT: 46,
+    CHAR_DOUBLE_QUOTE: 34,
+    CHAR_EQUAL: 61,
+    CHAR_EXCLAMATION_MARK: 33,
+    CHAR_FORM_FEED: 12,
+    CHAR_FORWARD_SLASH: 47,
+    CHAR_GRAVE_ACCENT: 96,
+    CHAR_HASH: 35,
+    CHAR_HYPHEN_MINUS: 45,
+    CHAR_LEFT_ANGLE_BRACKET: 60,
+    CHAR_LEFT_CURLY_BRACE: 123,
+    CHAR_LEFT_SQUARE_BRACKET: 91,
+    CHAR_LINE_FEED: 10,
+    CHAR_NO_BREAK_SPACE: 160,
+    CHAR_PERCENT: 37,
+    CHAR_PLUS: 43,
+    CHAR_QUESTION_MARK: 63,
+    CHAR_RIGHT_ANGLE_BRACKET: 62,
+    CHAR_RIGHT_CURLY_BRACE: 125,
+    CHAR_RIGHT_SQUARE_BRACKET: 93,
+    CHAR_SEMICOLON: 59,
+    CHAR_SINGLE_QUOTE: 39,
+    CHAR_SPACE: 32,
+    CHAR_TAB: 9,
+    CHAR_UNDERSCORE: 95,
+    CHAR_VERTICAL_LINE: 124,
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+    extglobChars(chars) {
+      return {
+        "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+        "?": { type: "qmark", open: "(?:", close: ")?" },
+        "+": { type: "plus", open: "(?:", close: ")+" },
+        "*": { type: "star", open: "(?:", close: ")*" },
+        "@": { type: "at", open: "(?:", close: ")" }
+      };
+    },
+    globChars(win322) {
+      return win322 === true ? WINDOWS_CHARS : POSIX_CHARS;
+    }
+  };
+});
+
+// node_modules/picomatch/lib/utils.js
+var require_utils3 = __commonJS((exports) => {
+  var {
+    REGEX_BACKSLASH,
+    REGEX_REMOVE_BACKSLASH,
+    REGEX_SPECIAL_CHARS,
+    REGEX_SPECIAL_CHARS_GLOBAL
+  } = require_constants();
+  exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+  exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+  exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+  exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+  exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+  exports.isWindows = () => {
+    if (typeof navigator !== "undefined" && navigator.platform) {
+      const platform10 = navigator.platform.toLowerCase();
+      return platform10 === "win32" || platform10 === "windows";
+    }
+    if (typeof process !== "undefined" && process.platform) {
+      return process.platform === "win32";
+    }
+    return false;
+  };
+  exports.removeBackslashes = (str) => {
+    return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+      return match === "\\" ? "" : match;
+    });
+  };
+  exports.escapeLast = (input, char, lastIdx) => {
+    const idx = input.lastIndexOf(char, lastIdx);
+    if (idx === -1)
+      return input;
+    if (input[idx - 1] === "\\")
+      return exports.escapeLast(input, char, idx - 1);
+    return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+  };
+  exports.removePrefix = (input, state = {}) => {
+    let output2 = input;
+    if (output2.startsWith("./")) {
+      output2 = output2.slice(2);
+      state.prefix = "./";
+    }
+    return output2;
+  };
+  exports.wrapOutput = (input, state = {}, options = {}) => {
+    const prepend = options.contains ? "" : "^";
+    const append = options.contains ? "" : "$";
+    let output2 = `${prepend}(?:${input})${append}`;
+    if (state.negated === true) {
+      output2 = `(?:^(?!${output2}).*$)`;
+    }
+    return output2;
+  };
+  exports.basename = (path10, { windows } = {}) => {
+    const segs = path10.split(windows ? /[\\/]/ : "/");
+    const last = segs[segs.length - 1];
+    if (last === "") {
+      return segs[segs.length - 2];
+    }
+    return last;
+  };
+});
+
+// node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS((exports, module) => {
+  var utils = require_utils3();
+  var {
+    CHAR_ASTERISK,
+    CHAR_AT,
+    CHAR_BACKWARD_SLASH,
+    CHAR_COMMA,
+    CHAR_DOT,
+    CHAR_EXCLAMATION_MARK,
+    CHAR_FORWARD_SLASH,
+    CHAR_LEFT_CURLY_BRACE,
+    CHAR_LEFT_PARENTHESES,
+    CHAR_LEFT_SQUARE_BRACKET,
+    CHAR_PLUS,
+    CHAR_QUESTION_MARK,
+    CHAR_RIGHT_CURLY_BRACE,
+    CHAR_RIGHT_PARENTHESES,
+    CHAR_RIGHT_SQUARE_BRACKET
+  } = require_constants();
+  var isPathSeparator = (code2) => {
+    return code2 === CHAR_FORWARD_SLASH || code2 === CHAR_BACKWARD_SLASH;
+  };
+  var depth = (token) => {
+    if (token.isPrefix !== true) {
+      token.depth = token.isGlobstar ? Infinity : 1;
+    }
+  };
+  var scan = (input, options) => {
+    const opts = options || {};
+    const length = input.length - 1;
+    const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+    const slashes = [];
+    const tokens = [];
+    const parts = [];
+    let str = input;
+    let index = -1;
+    let start = 0;
+    let lastIndex = 0;
+    let isBrace = false;
+    let isBracket = false;
+    let isGlob = false;
+    let isExtglob = false;
+    let isGlobstar = false;
+    let braceEscaped = false;
+    let backslashes = false;
+    let negated = false;
+    let negatedExtglob = false;
+    let finished = false;
+    let braces = 0;
+    let prev;
+    let code2;
+    let token = { value: "", depth: 0, isGlob: false };
+    const eos = () => index >= length;
+    const peek = () => str.charCodeAt(index + 1);
+    const advance = () => {
+      prev = code2;
+      return str.charCodeAt(++index);
+    };
+    while (index < length) {
+      code2 = advance();
+      let next;
+      if (code2 === CHAR_BACKWARD_SLASH) {
+        backslashes = token.backslashes = true;
+        code2 = advance();
+        if (code2 === CHAR_LEFT_CURLY_BRACE) {
+          braceEscaped = true;
+        }
+        continue;
+      }
+      if (braceEscaped === true || code2 === CHAR_LEFT_CURLY_BRACE) {
+        braces++;
+        while (eos() !== true && (code2 = advance())) {
+          if (code2 === CHAR_BACKWARD_SLASH) {
+            backslashes = token.backslashes = true;
+            advance();
+            continue;
+          }
+          if (code2 === CHAR_LEFT_CURLY_BRACE) {
+            braces++;
+            continue;
+          }
+          if (braceEscaped !== true && code2 === CHAR_DOT && (code2 = advance()) === CHAR_DOT) {
+            isBrace = token.isBrace = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (braceEscaped !== true && code2 === CHAR_COMMA) {
+            isBrace = token.isBrace = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (code2 === CHAR_RIGHT_CURLY_BRACE) {
+            braces--;
+            if (braces === 0) {
+              braceEscaped = false;
+              isBrace = token.isBrace = true;
+              finished = true;
+              break;
+            }
+          }
+        }
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
+      if (code2 === CHAR_FORWARD_SLASH) {
+        slashes.push(index);
+        tokens.push(token);
+        token = { value: "", depth: 0, isGlob: false };
+        if (finished === true)
+          continue;
+        if (prev === CHAR_DOT && index === start + 1) {
+          start += 2;
+          continue;
+        }
+        lastIndex = index + 1;
+        continue;
+      }
+      if (opts.noext !== true) {
+        const isExtglobChar = code2 === CHAR_PLUS || code2 === CHAR_AT || code2 === CHAR_ASTERISK || code2 === CHAR_QUESTION_MARK || code2 === CHAR_EXCLAMATION_MARK;
+        if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+          isGlob = token.isGlob = true;
+          isExtglob = token.isExtglob = true;
+          finished = true;
+          if (code2 === CHAR_EXCLAMATION_MARK && index === start) {
+            negatedExtglob = true;
+          }
+          if (scanToEnd === true) {
+            while (eos() !== true && (code2 = advance())) {
+              if (code2 === CHAR_BACKWARD_SLASH) {
+                backslashes = token.backslashes = true;
+                code2 = advance();
+                continue;
+              }
+              if (code2 === CHAR_RIGHT_PARENTHESES) {
+                isGlob = token.isGlob = true;
+                finished = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+      }
+      if (code2 === CHAR_ASTERISK) {
+        if (prev === CHAR_ASTERISK)
+          isGlobstar = token.isGlobstar = true;
+        isGlob = token.isGlob = true;
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
+      if (code2 === CHAR_QUESTION_MARK) {
+        isGlob = token.isGlob = true;
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
+      if (code2 === CHAR_LEFT_SQUARE_BRACKET) {
+        while (eos() !== true && (next = advance())) {
+          if (next === CHAR_BACKWARD_SLASH) {
+            backslashes = token.backslashes = true;
+            advance();
+            continue;
+          }
+          if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+            isBracket = token.isBracket = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            break;
+          }
+        }
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
+      if (opts.nonegate !== true && code2 === CHAR_EXCLAMATION_MARK && index === start) {
+        negated = token.negated = true;
+        start++;
+        continue;
+      }
+      if (opts.noparen !== true && code2 === CHAR_LEFT_PARENTHESES) {
+        isGlob = token.isGlob = true;
+        if (scanToEnd === true) {
+          while (eos() !== true && (code2 = advance())) {
+            if (code2 === CHAR_LEFT_PARENTHESES) {
+              backslashes = token.backslashes = true;
+              code2 = advance();
+              continue;
+            }
+            if (code2 === CHAR_RIGHT_PARENTHESES) {
+              finished = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (isGlob === true) {
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
+    }
+    if (opts.noext === true) {
+      isExtglob = false;
+      isGlob = false;
+    }
+    let base = str;
+    let prefix = "";
+    let glob = "";
+    if (start > 0) {
+      prefix = str.slice(0, start);
+      str = str.slice(start);
+      lastIndex -= start;
+    }
+    if (base && isGlob === true && lastIndex > 0) {
+      base = str.slice(0, lastIndex);
+      glob = str.slice(lastIndex);
+    } else if (isGlob === true) {
+      base = "";
+      glob = str;
+    } else {
+      base = str;
+    }
+    if (base && base !== "" && base !== "/" && base !== str) {
+      if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+        base = base.slice(0, -1);
+      }
+    }
+    if (opts.unescape === true) {
+      if (glob)
+        glob = utils.removeBackslashes(glob);
+      if (base && backslashes === true) {
+        base = utils.removeBackslashes(base);
+      }
+    }
+    const state = {
+      prefix,
+      input,
+      start,
+      base,
+      glob,
+      isBrace,
+      isBracket,
+      isGlob,
+      isExtglob,
+      isGlobstar,
+      negated,
+      negatedExtglob
+    };
+    if (opts.tokens === true) {
+      state.maxDepth = 0;
+      if (!isPathSeparator(code2)) {
+        tokens.push(token);
+      }
+      state.tokens = tokens;
+    }
+    if (opts.parts === true || opts.tokens === true) {
+      let prevIndex;
+      for (let idx = 0;idx < slashes.length; idx++) {
+        const n = prevIndex ? prevIndex + 1 : start;
+        const i = slashes[idx];
+        const value = input.slice(n, i);
+        if (opts.tokens) {
+          if (idx === 0 && start !== 0) {
+            tokens[idx].isPrefix = true;
+            tokens[idx].value = prefix;
+          } else {
+            tokens[idx].value = value;
+          }
+          depth(tokens[idx]);
+          state.maxDepth += tokens[idx].depth;
+        }
+        if (idx !== 0 || value !== "") {
+          parts.push(value);
+        }
+        prevIndex = i;
+      }
+      if (prevIndex && prevIndex + 1 < input.length) {
+        const value = input.slice(prevIndex + 1);
+        parts.push(value);
+        if (opts.tokens) {
+          tokens[tokens.length - 1].value = value;
+          depth(tokens[tokens.length - 1]);
+          state.maxDepth += tokens[tokens.length - 1].depth;
+        }
+      }
+      state.slashes = slashes;
+      state.parts = parts;
+    }
+    return state;
+  };
+  module.exports = scan;
+});
+
+// node_modules/picomatch/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var constants5 = require_constants();
+  var utils = require_utils3();
+  var {
+    MAX_LENGTH,
+    POSIX_REGEX_SOURCE,
+    REGEX_NON_SPECIAL_CHARS,
+    REGEX_SPECIAL_CHARS_BACKREF,
+    REPLACEMENTS
+  } = constants5;
+  var expandRange = (args, options) => {
+    if (typeof options.expandRange === "function") {
+      return options.expandRange(...args, options);
+    }
+    args.sort();
+    const value = `[${args.join("-")}]`;
+    try {
+      new RegExp(value);
+    } catch (ex) {
+      return args.map((v2) => utils.escapeRegex(v2)).join("..");
+    }
+    return value;
+  };
+  var syntaxError = (type, char) => {
+    return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+  };
+  var parse5 = (input, options) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected a string");
+    }
+    input = REPLACEMENTS[input] || input;
+    const opts = { ...options };
+    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    let len = input.length;
+    if (len > max) {
+      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+    }
+    const bos = { type: "bos", value: "", output: opts.prepend || "" };
+    const tokens = [bos];
+    const capture = opts.capture ? "" : "?:";
+    const PLATFORM_CHARS = constants5.globChars(opts.windows);
+    const EXTGLOB_CHARS = constants5.extglobChars(PLATFORM_CHARS);
+    const {
+      DOT_LITERAL,
+      PLUS_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOT_SLASH,
+      NO_DOTS_SLASH,
+      QMARK,
+      QMARK_NO_DOT,
+      STAR,
+      START_ANCHOR
+    } = PLATFORM_CHARS;
+    const globstar = (opts2) => {
+      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+    };
+    const nodot = opts.dot ? "" : NO_DOT;
+    const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+    let star = opts.bash === true ? globstar(opts) : STAR;
+    if (opts.capture) {
+      star = `(${star})`;
+    }
+    if (typeof opts.noext === "boolean") {
+      opts.noextglob = opts.noext;
+    }
+    const state = {
+      input,
+      index: -1,
+      start: 0,
+      dot: opts.dot === true,
+      consumed: "",
+      output: "",
+      prefix: "",
+      backtrack: false,
+      negated: false,
+      brackets: 0,
+      braces: 0,
+      parens: 0,
+      quotes: 0,
+      globstar: false,
+      tokens
+    };
+    input = utils.removePrefix(input, state);
+    len = input.length;
+    const extglobs = [];
+    const braces = [];
+    const stack = [];
+    let prev = bos;
+    let value;
+    const eos = () => state.index === len - 1;
+    const peek = state.peek = (n = 1) => input[state.index + n];
+    const advance = state.advance = () => input[++state.index] || "";
+    const remaining = () => input.slice(state.index + 1);
+    const consume = (value2 = "", num = 0) => {
+      state.consumed += value2;
+      state.index += num;
+    };
+    const append = (token) => {
+      state.output += token.output != null ? token.output : token.value;
+      consume(token.value);
+    };
+    const negate = () => {
+      let count = 1;
+      while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+        advance();
+        state.start++;
+        count++;
+      }
+      if (count % 2 === 0) {
+        return false;
+      }
+      state.negated = true;
+      state.start++;
+      return true;
+    };
+    const increment = (type) => {
+      state[type]++;
+      stack.push(type);
+    };
+    const decrement = (type) => {
+      state[type]--;
+      stack.pop();
+    };
+    const push2 = (tok) => {
+      if (prev.type === "globstar") {
+        const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+        const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+        if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+          state.output = state.output.slice(0, -prev.output.length);
+          prev.type = "star";
+          prev.value = "*";
+          prev.output = star;
+          state.output += prev.output;
+        }
+      }
+      if (extglobs.length && tok.type !== "paren") {
+        extglobs[extglobs.length - 1].inner += tok.value;
+      }
+      if (tok.value || tok.output)
+        append(tok);
+      if (prev && prev.type === "text" && tok.type === "text") {
+        prev.output = (prev.output || prev.value) + tok.value;
+        prev.value += tok.value;
+        return;
+      }
+      tok.prev = prev;
+      tokens.push(tok);
+      prev = tok;
+    };
+    const extglobOpen = (type, value2) => {
+      const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+      token.prev = prev;
+      token.parens = state.parens;
+      token.output = state.output;
+      const output2 = (opts.capture ? "(" : "") + token.open;
+      increment("parens");
+      push2({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+      push2({ type: "paren", extglob: true, value: advance(), output: output2 });
+      extglobs.push(token);
+    };
+    const extglobClose = (token) => {
+      let output2 = token.close + (opts.capture ? ")" : "");
+      let rest;
+      if (token.type === "negate") {
+        let extglobStar = star;
+        if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+          extglobStar = globstar(opts);
+        }
+        if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+          output2 = token.close = `)$))${extglobStar}`;
+        }
+        if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+          const expression = parse5(rest, { ...options, fastpaths: false }).output;
+          output2 = token.close = `)${expression})${extglobStar})`;
+        }
+        if (token.prev.type === "bos") {
+          state.negatedExtglob = true;
+        }
+      }
+      push2({ type: "paren", extglob: true, value, output: output2 });
+      decrement("parens");
+    };
+    if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+      let backslashes = false;
+      let output2 = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m2, esc, chars, first, rest, index) => {
+        if (first === "\\") {
+          backslashes = true;
+          return m2;
+        }
+        if (first === "?") {
+          if (esc) {
+            return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+          }
+          if (index === 0) {
+            return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+          }
+          return QMARK.repeat(chars.length);
+        }
+        if (first === ".") {
+          return DOT_LITERAL.repeat(chars.length);
+        }
+        if (first === "*") {
+          if (esc) {
+            return esc + first + (rest ? star : "");
+          }
+          return star;
+        }
+        return esc ? m2 : `\\${m2}`;
+      });
+      if (backslashes === true) {
+        if (opts.unescape === true) {
+          output2 = output2.replace(/\\/g, "");
+        } else {
+          output2 = output2.replace(/\\+/g, (m2) => {
+            return m2.length % 2 === 0 ? "\\\\" : m2 ? "\\" : "";
+          });
+        }
+      }
+      if (output2 === input && opts.contains === true) {
+        state.output = input;
+        return state;
+      }
+      state.output = utils.wrapOutput(output2, state, options);
+      return state;
+    }
+    while (!eos()) {
+      value = advance();
+      if (value === "\x00") {
+        continue;
+      }
+      if (value === "\\") {
+        const next = peek();
+        if (next === "/" && opts.bash !== true) {
+          continue;
+        }
+        if (next === "." || next === ";") {
+          continue;
+        }
+        if (!next) {
+          value += "\\";
+          push2({ type: "text", value });
+          continue;
+        }
+        const match = /^\\+/.exec(remaining());
+        let slashes = 0;
+        if (match && match[0].length > 2) {
+          slashes = match[0].length;
+          state.index += slashes;
+          if (slashes % 2 !== 0) {
+            value += "\\";
+          }
+        }
+        if (opts.unescape === true) {
+          value = advance();
+        } else {
+          value += advance();
+        }
+        if (state.brackets === 0) {
+          push2({ type: "text", value });
+          continue;
+        }
+      }
+      if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+        if (opts.posix !== false && value === ":") {
+          const inner = prev.value.slice(1);
+          if (inner.includes("[")) {
+            prev.posix = true;
+            if (inner.includes(":")) {
+              const idx = prev.value.lastIndexOf("[");
+              const pre = prev.value.slice(0, idx);
+              const rest2 = prev.value.slice(idx + 2);
+              const posix = POSIX_REGEX_SOURCE[rest2];
+              if (posix) {
+                prev.value = pre + posix;
+                state.backtrack = true;
+                advance();
+                if (!bos.output && tokens.indexOf(prev) === 1) {
+                  bos.output = ONE_CHAR;
+                }
+                continue;
+              }
+            }
+          }
+        }
+        if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+          value = `\\${value}`;
+        }
+        if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+          value = `\\${value}`;
+        }
+        if (opts.posix === true && value === "!" && prev.value === "[") {
+          value = "^";
+        }
+        prev.value += value;
+        append({ value });
+        continue;
+      }
+      if (state.quotes === 1 && value !== '"') {
+        value = utils.escapeRegex(value);
+        prev.value += value;
+        append({ value });
+        continue;
+      }
+      if (value === '"') {
+        state.quotes = state.quotes === 1 ? 0 : 1;
+        if (opts.keepQuotes === true) {
+          push2({ type: "text", value });
+        }
+        continue;
+      }
+      if (value === "(") {
+        increment("parens");
+        push2({ type: "paren", value });
+        continue;
+      }
+      if (value === ")") {
+        if (state.parens === 0 && opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError("opening", "("));
+        }
+        const extglob = extglobs[extglobs.length - 1];
+        if (extglob && state.parens === extglob.parens + 1) {
+          extglobClose(extglobs.pop());
+          continue;
+        }
+        push2({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+        decrement("parens");
+        continue;
+      }
+      if (value === "[") {
+        if (opts.nobracket === true || !remaining().includes("]")) {
+          if (opts.nobracket !== true && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("closing", "]"));
+          }
+          value = `\\${value}`;
+        } else {
+          increment("brackets");
+        }
+        push2({ type: "bracket", value });
+        continue;
+      }
+      if (value === "]") {
+        if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+          push2({ type: "text", value, output: `\\${value}` });
+          continue;
+        }
+        if (state.brackets === 0) {
+          if (opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "["));
+          }
+          push2({ type: "text", value, output: `\\${value}` });
+          continue;
+        }
+        decrement("brackets");
+        const prevValue = prev.value.slice(1);
+        if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+          value = `/${value}`;
+        }
+        prev.value += value;
+        append({ value });
+        if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+          continue;
+        }
+        const escaped = utils.escapeRegex(prev.value);
+        state.output = state.output.slice(0, -prev.value.length);
+        if (opts.literalBrackets === true) {
+          state.output += escaped;
+          prev.value = escaped;
+          continue;
+        }
+        prev.value = `(${capture}${escaped}|${prev.value})`;
+        state.output += prev.value;
+        continue;
+      }
+      if (value === "{" && opts.nobrace !== true) {
+        increment("braces");
+        const open = {
+          type: "brace",
+          value,
+          output: "(",
+          outputIndex: state.output.length,
+          tokensIndex: state.tokens.length
+        };
+        braces.push(open);
+        push2(open);
+        continue;
+      }
+      if (value === "}") {
+        const brace = braces[braces.length - 1];
+        if (opts.nobrace === true || !brace) {
+          push2({ type: "text", value, output: value });
+          continue;
+        }
+        let output2 = ")";
+        if (brace.dots === true) {
+          const arr = tokens.slice();
+          const range = [];
+          for (let i = arr.length - 1;i >= 0; i--) {
+            tokens.pop();
+            if (arr[i].type === "brace") {
+              break;
+            }
+            if (arr[i].type !== "dots") {
+              range.unshift(arr[i].value);
+            }
+          }
+          output2 = expandRange(range, opts);
+          state.backtrack = true;
+        }
+        if (brace.comma !== true && brace.dots !== true) {
+          const out = state.output.slice(0, brace.outputIndex);
+          const toks = state.tokens.slice(brace.tokensIndex);
+          brace.value = brace.output = "\\{";
+          value = output2 = "\\}";
+          state.output = out;
+          for (const t of toks) {
+            state.output += t.output || t.value;
+          }
+        }
+        push2({ type: "brace", value, output: output2 });
+        decrement("braces");
+        braces.pop();
+        continue;
+      }
+      if (value === "|") {
+        if (extglobs.length > 0) {
+          extglobs[extglobs.length - 1].conditions++;
+        }
+        push2({ type: "text", value });
+        continue;
+      }
+      if (value === ",") {
+        let output2 = value;
+        const brace = braces[braces.length - 1];
+        if (brace && stack[stack.length - 1] === "braces") {
+          brace.comma = true;
+          output2 = "|";
+        }
+        push2({ type: "comma", value, output: output2 });
+        continue;
+      }
+      if (value === "/") {
+        if (prev.type === "dot" && state.index === state.start + 1) {
+          state.start = state.index + 1;
+          state.consumed = "";
+          state.output = "";
+          tokens.pop();
+          prev = bos;
+          continue;
+        }
+        push2({ type: "slash", value, output: SLASH_LITERAL });
+        continue;
+      }
+      if (value === ".") {
+        if (state.braces > 0 && prev.type === "dot") {
+          if (prev.value === ".")
+            prev.output = DOT_LITERAL;
+          const brace = braces[braces.length - 1];
+          prev.type = "dots";
+          prev.output += value;
+          prev.value += value;
+          brace.dots = true;
+          continue;
+        }
+        if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+          push2({ type: "text", value, output: DOT_LITERAL });
+          continue;
+        }
+        push2({ type: "dot", value, output: DOT_LITERAL });
+        continue;
+      }
+      if (value === "?") {
+        const isGroup = prev && prev.value === "(";
+        if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          extglobOpen("qmark", value);
+          continue;
+        }
+        if (prev && prev.type === "paren") {
+          const next = peek();
+          let output2 = value;
+          if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+            output2 = `\\${value}`;
+          }
+          push2({ type: "text", value, output: output2 });
+          continue;
+        }
+        if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+          push2({ type: "qmark", value, output: QMARK_NO_DOT });
+          continue;
+        }
+        push2({ type: "qmark", value, output: QMARK });
+        continue;
+      }
+      if (value === "!") {
+        if (opts.noextglob !== true && peek() === "(") {
+          if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+            extglobOpen("negate", value);
+            continue;
+          }
+        }
+        if (opts.nonegate !== true && state.index === 0) {
+          negate();
+          continue;
+        }
+      }
+      if (value === "+") {
+        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          extglobOpen("plus", value);
+          continue;
+        }
+        if (prev && prev.value === "(" || opts.regex === false) {
+          push2({ type: "plus", value, output: PLUS_LITERAL });
+          continue;
+        }
+        if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+          push2({ type: "plus", value });
+          continue;
+        }
+        push2({ type: "plus", value: PLUS_LITERAL });
+        continue;
+      }
+      if (value === "@") {
+        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          push2({ type: "at", extglob: true, value, output: "" });
+          continue;
+        }
+        push2({ type: "text", value });
+        continue;
+      }
+      if (value !== "*") {
+        if (value === "$" || value === "^") {
+          value = `\\${value}`;
+        }
+        const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+        if (match) {
+          value += match[0];
+          state.index += match[0].length;
+        }
+        push2({ type: "text", value });
+        continue;
+      }
+      if (prev && (prev.type === "globstar" || prev.star === true)) {
+        prev.type = "star";
+        prev.star = true;
+        prev.value += value;
+        prev.output = star;
+        state.backtrack = true;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
+      let rest = remaining();
+      if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+        extglobOpen("star", value);
+        continue;
+      }
+      if (prev.type === "star") {
+        if (opts.noglobstar === true) {
+          consume(value);
+          continue;
+        }
+        const prior = prev.prev;
+        const before = prior.prev;
+        const isStart = prior.type === "slash" || prior.type === "bos";
+        const afterStar = before && (before.type === "star" || before.type === "globstar");
+        if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+          push2({ type: "star", value, output: "" });
+          continue;
+        }
+        const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+        const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+        if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+          push2({ type: "star", value, output: "" });
+          continue;
+        }
+        while (rest.slice(0, 3) === "/**") {
+          const after = input[state.index + 4];
+          if (after && after !== "/") {
+            break;
+          }
+          rest = rest.slice(3);
+          consume("/**", 3);
+        }
+        if (prior.type === "bos" && eos()) {
+          prev.type = "globstar";
+          prev.value += value;
+          prev.output = globstar(opts);
+          state.output = prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+          state.output = state.output.slice(0, -(prior.output + prev.output).length);
+          prior.output = `(?:${prior.output}`;
+          prev.type = "globstar";
+          prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+          prev.value += value;
+          state.globstar = true;
+          state.output += prior.output + prev.output;
+          consume(value);
+          continue;
+        }
+        if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+          const end = rest[1] !== undefined ? "|$" : "";
+          state.output = state.output.slice(0, -(prior.output + prev.output).length);
+          prior.output = `(?:${prior.output}`;
+          prev.type = "globstar";
+          prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+          prev.value += value;
+          state.output += prior.output + prev.output;
+          state.globstar = true;
+          consume(value + advance());
+          push2({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        if (prior.type === "bos" && rest[0] === "/") {
+          prev.type = "globstar";
+          prev.value += value;
+          prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+          state.output = prev.output;
+          state.globstar = true;
+          consume(value + advance());
+          push2({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        state.output = state.output.slice(0, -prev.output.length);
+        prev.type = "globstar";
+        prev.output = globstar(opts);
+        prev.value += value;
+        state.output += prev.output;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
+      const token = { type: "star", value, output: star };
+      if (opts.bash === true) {
+        token.output = ".*?";
+        if (prev.type === "bos" || prev.type === "slash") {
+          token.output = nodot + token.output;
+        }
+        push2(token);
+        continue;
+      }
+      if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+        token.output = value;
+        push2(token);
+        continue;
+      }
+      if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+        if (prev.type === "dot") {
+          state.output += NO_DOT_SLASH;
+          prev.output += NO_DOT_SLASH;
+        } else if (opts.dot === true) {
+          state.output += NO_DOTS_SLASH;
+          prev.output += NO_DOTS_SLASH;
+        } else {
+          state.output += nodot;
+          prev.output += nodot;
+        }
+        if (peek() !== "*") {
+          state.output += ONE_CHAR;
+          prev.output += ONE_CHAR;
+        }
+      }
+      push2(token);
+    }
+    while (state.brackets > 0) {
+      if (opts.strictBrackets === true)
+        throw new SyntaxError(syntaxError("closing", "]"));
+      state.output = utils.escapeLast(state.output, "[");
+      decrement("brackets");
+    }
+    while (state.parens > 0) {
+      if (opts.strictBrackets === true)
+        throw new SyntaxError(syntaxError("closing", ")"));
+      state.output = utils.escapeLast(state.output, "(");
+      decrement("parens");
+    }
+    while (state.braces > 0) {
+      if (opts.strictBrackets === true)
+        throw new SyntaxError(syntaxError("closing", "}"));
+      state.output = utils.escapeLast(state.output, "{");
+      decrement("braces");
+    }
+    if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+      push2({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+    }
+    if (state.backtrack === true) {
+      state.output = "";
+      for (const token of state.tokens) {
+        state.output += token.output != null ? token.output : token.value;
+        if (token.suffix) {
+          state.output += token.suffix;
+        }
+      }
+    }
+    return state;
+  };
+  parse5.fastpaths = (input, options) => {
+    const opts = { ...options };
+    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    const len = input.length;
+    if (len > max) {
+      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+    }
+    input = REPLACEMENTS[input] || input;
+    const {
+      DOT_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOTS_SLASH,
+      STAR,
+      START_ANCHOR
+    } = constants5.globChars(opts.windows);
+    const nodot = opts.dot ? NO_DOTS : NO_DOT;
+    const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+    const capture = opts.capture ? "" : "?:";
+    const state = { negated: false, prefix: "" };
+    let star = opts.bash === true ? ".*?" : STAR;
+    if (opts.capture) {
+      star = `(${star})`;
+    }
+    const globstar = (opts2) => {
+      if (opts2.noglobstar === true)
+        return star;
+      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+    };
+    const create3 = (str) => {
+      switch (str) {
+        case "*":
+          return `${nodot}${ONE_CHAR}${star}`;
+        case ".*":
+          return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+        case "*.*":
+          return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+        case "*/*":
+          return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+        case "**":
+          return nodot + globstar(opts);
+        case "**/*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+        case "**/*.*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+        case "**/.*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+        default: {
+          const match = /^(.*?)\.(\w+)$/.exec(str);
+          if (!match)
+            return;
+          const source2 = create3(match[1]);
+          if (!source2)
+            return;
+          return source2 + DOT_LITERAL + match[2];
+        }
+      }
+    };
+    const output2 = utils.removePrefix(input, state);
+    let source = create3(output2);
+    if (source && opts.strictSlashes !== true) {
+      source += `${SLASH_LITERAL}?`;
+    }
+    return source;
+  };
+  module.exports = parse5;
+});
+
+// node_modules/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS((exports, module) => {
+  var scan = require_scan();
+  var parse5 = require_parse();
+  var utils = require_utils3();
+  var constants5 = require_constants();
+  var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+  var picomatch = (glob, options, returnState = false) => {
+    if (Array.isArray(glob)) {
+      const fns = glob.map((input) => picomatch(input, options, returnState));
+      const arrayMatcher = (str) => {
+        for (const isMatch of fns) {
+          const state2 = isMatch(str);
+          if (state2)
+            return state2;
+        }
+        return false;
+      };
+      return arrayMatcher;
+    }
+    const isState = isObject(glob) && glob.tokens && glob.input;
+    if (glob === "" || typeof glob !== "string" && !isState) {
+      throw new TypeError("Expected pattern to be a non-empty string");
+    }
+    const opts = options || {};
+    const posix = opts.windows;
+    const regex2 = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+    const state = regex2.state;
+    delete regex2.state;
+    let isIgnored = () => false;
+    if (opts.ignore) {
+      const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+      isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+    }
+    const matcher = (input, returnObject = false) => {
+      const { isMatch, match, output: output2 } = picomatch.test(input, regex2, options, { glob, posix });
+      const result = { glob, state, regex: regex2, posix, input, output: output2, match, isMatch };
+      if (typeof opts.onResult === "function") {
+        opts.onResult(result);
+      }
+      if (isMatch === false) {
+        result.isMatch = false;
+        return returnObject ? result : false;
+      }
+      if (isIgnored(input)) {
+        if (typeof opts.onIgnore === "function") {
+          opts.onIgnore(result);
+        }
+        result.isMatch = false;
+        return returnObject ? result : false;
+      }
+      if (typeof opts.onMatch === "function") {
+        opts.onMatch(result);
+      }
+      return returnObject ? result : true;
+    };
+    if (returnState) {
+      matcher.state = state;
+    }
+    return matcher;
+  };
+  picomatch.test = (input, regex2, options, { glob, posix } = {}) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected input to be a string");
+    }
+    if (input === "") {
+      return { isMatch: false, output: "" };
+    }
+    const opts = options || {};
+    const format = opts.format || (posix ? utils.toPosixSlashes : null);
+    let match = input === glob;
+    let output2 = match && format ? format(input) : input;
+    if (match === false) {
+      output2 = format ? format(input) : input;
+      match = output2 === glob;
+    }
+    if (match === false || opts.capture === true) {
+      if (opts.matchBase === true || opts.basename === true) {
+        match = picomatch.matchBase(input, regex2, options, posix);
+      } else {
+        match = regex2.exec(output2);
+      }
+    }
+    return { isMatch: Boolean(match), match, output: output2 };
+  };
+  picomatch.matchBase = (input, glob, options) => {
+    const regex2 = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+    return regex2.test(utils.basename(input));
+  };
+  picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+  picomatch.parse = (pattern, options) => {
+    if (Array.isArray(pattern))
+      return pattern.map((p) => picomatch.parse(p, options));
+    return parse5(pattern, { ...options, fastpaths: false });
+  };
+  picomatch.scan = (input, options) => scan(input, options);
+  picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+    if (returnOutput === true) {
+      return state.output;
+    }
+    const opts = options || {};
+    const prepend = opts.contains ? "" : "^";
+    const append = opts.contains ? "" : "$";
+    let source = `${prepend}(?:${state.output})${append}`;
+    if (state && state.negated === true) {
+      source = `^(?!${source}).*$`;
+    }
+    const regex2 = picomatch.toRegex(source, options);
+    if (returnState === true) {
+      regex2.state = state;
+    }
+    return regex2;
+  };
+  picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+    if (!input || typeof input !== "string") {
+      throw new TypeError("Expected a non-empty string");
+    }
+    let parsed = { negated: false, fastpaths: true };
+    if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+      parsed.output = parse5.fastpaths(input, options);
+    }
+    if (!parsed.output) {
+      parsed = parse5(input, options);
+    }
+    return picomatch.compileRe(parsed, options, returnOutput, returnState);
+  };
+  picomatch.toRegex = (source, options) => {
+    try {
+      const opts = options || {};
+      return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+    } catch (err) {
+      if (options && options.debug === true)
+        throw err;
+      return /$^/;
+    }
+  };
+  picomatch.constants = constants5;
+  module.exports = picomatch;
+});
+
+// node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS((exports, module) => {
+  var pico = require_picomatch();
+  var utils = require_utils3();
+  function picomatch(glob, options, returnState = false) {
+    if (options && (options.windows === null || options.windows === undefined)) {
+      options = { ...options, windows: utils.isWindows() };
+    }
+    return pico(glob, options, returnState);
+  }
+  Object.assign(picomatch, pico);
+  module.exports = picomatch;
+});
+
+// node_modules/semver/internal/constants.js
+var require_constants2 = __commonJS((exports, module) => {
   var SEMVER_SPEC_VERSION = "2.0.0";
   var MAX_LENGTH = 256;
   var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
@@ -15692,7 +17140,7 @@ var require_re = __commonJS((exports, module) => {
     MAX_SAFE_COMPONENT_LENGTH,
     MAX_SAFE_BUILD_LENGTH,
     MAX_LENGTH
-  } = require_constants();
+  } = require_constants2();
   var debug = require_debug();
   exports = module.exports = {};
   var re2 = exports.re = [];
@@ -15812,7 +17260,7 @@ var require_identifiers = __commonJS((exports, module) => {
 // node_modules/semver/classes/semver.js
 var require_semver = __commonJS((exports, module) => {
   var debug = require_debug();
-  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants2();
   var { safeRe: re2, t } = require_re();
   var parseOptions = require_parse_options();
   var { compareIdentifiers } = require_identifiers();
@@ -16079,7 +17527,7 @@ var require_semver = __commonJS((exports, module) => {
 });
 
 // node_modules/semver/functions/parse.js
-var require_parse = __commonJS((exports, module) => {
+var require_parse2 = __commonJS((exports, module) => {
   var SemVer = require_semver();
   var parse5 = (version, options, throwErrors = false) => {
     if (version instanceof SemVer) {
@@ -16099,7 +17547,7 @@ var require_parse = __commonJS((exports, module) => {
 
 // node_modules/semver/functions/valid.js
 var require_valid = __commonJS((exports, module) => {
-  var parse5 = require_parse();
+  var parse5 = require_parse2();
   var valid = (version, options) => {
     const v2 = parse5(version, options);
     return v2 ? v2.version : null;
@@ -16109,7 +17557,7 @@ var require_valid = __commonJS((exports, module) => {
 
 // node_modules/semver/functions/clean.js
 var require_clean = __commonJS((exports, module) => {
-  var parse5 = require_parse();
+  var parse5 = require_parse2();
   var clean = (version, options) => {
     const s = parse5(version.trim().replace(/^[=v]+/, ""), options);
     return s ? s.version : null;
@@ -16137,7 +17585,7 @@ var require_inc = __commonJS((exports, module) => {
 
 // node_modules/semver/functions/diff.js
 var require_diff = __commonJS((exports, module) => {
-  var parse5 = require_parse();
+  var parse5 = require_parse2();
   var diff = (version1, version2) => {
     const v1 = parse5(version1, null, true);
     const v2 = parse5(version2, null, true);
@@ -16199,7 +17647,7 @@ var require_patch = __commonJS((exports, module) => {
 
 // node_modules/semver/functions/prerelease.js
 var require_prerelease = __commonJS((exports, module) => {
-  var parse5 = require_parse();
+  var parse5 = require_parse2();
   var prerelease = (version, options) => {
     const parsed = parse5(version, options);
     return parsed && parsed.prerelease.length ? parsed.prerelease : null;
@@ -16345,7 +17793,7 @@ var require_cmp = __commonJS((exports, module) => {
 // node_modules/semver/functions/coerce.js
 var require_coerce = __commonJS((exports, module) => {
   var SemVer = require_semver();
-  var parse5 = require_parse();
+  var parse5 = require_parse2();
   var { safeRe: re2, t } = require_re();
   var coerce2 = (version, options) => {
     if (version instanceof SemVer) {
@@ -16575,7 +18023,7 @@ var require_range = __commonJS((exports, module) => {
     tildeTrimReplace,
     caretTrimReplace
   } = require_re();
-  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants2();
   var isNullSet = (c2) => c2.value === "<0.0.0-0";
   var isAny = (c2) => c2.value === "";
   var isSatisfiable = (comparators, options) => {
@@ -17346,10 +18794,10 @@ var require_subset = __commonJS((exports, module) => {
 // node_modules/semver/index.js
 var require_semver2 = __commonJS((exports, module) => {
   var internalRe = require_re();
-  var constants5 = require_constants();
+  var constants5 = require_constants2();
   var SemVer = require_semver();
   var identifiers = require_identifiers();
-  var parse5 = require_parse();
+  var parse5 = require_parse2();
   var valid = require_valid();
   var clean = require_clean();
   var inc = require_inc();
@@ -18149,7 +19597,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -18159,20 +19607,20 @@ async function trySystemPager(content) {
       });
       const timeout = setTimeout(() => {
         pager.kill();
-        resolve11(false);
+        resolve12(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout);
-        resolve11(code2 === 0);
+        resolve12(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout);
-        resolve11(false);
+        resolve12(false);
       });
     } catch {
-      resolve11(false);
+      resolve12(false);
     }
   });
 }
@@ -18199,16 +19647,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve11) => {
+    await new Promise((resolve12) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve11();
+          resolve12();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve11();
+        resolve12();
       });
     });
   }
@@ -35225,22 +36673,11 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join53 } from "node:path";
+import { join as join54 } from "node:path";
 
-// src/domains/installation/file-merger.ts
-init_logger();
-init_types2();
-init_dist2();
-
-// src/domains/installation/merger/copy-executor.ts
-init_logger();
-init_types2();
-var import_fs_extra10 = __toESM(require_lib(), 1);
-var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname8, join as join43, relative as relative6 } from "node:path";
-
-// src/domains/installation/selective-merger.ts
-import { stat as stat6 } from "node:fs/promises";
+// src/domains/installation/deletion-handler.ts
+import { existsSync as existsSync17, lstatSync as lstatSync2, readdirSync, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname6, join as join40, relative as relative5, resolve as resolve6 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 import { join as join39 } from "node:path";
@@ -35389,7 +36826,212 @@ async function getUninstallManifest(claudeDir, kit) {
   };
 }
 
+// src/domains/installation/deletion-handler.ts
+init_logger();
+var import_fs_extra7 = __toESM(require_lib(), 1);
+var import_picomatch = __toESM(require_picomatch2(), 1);
+function findFileInMetadata(metadata, path10) {
+  if (!metadata)
+    return null;
+  if (metadata.kits) {
+    for (const kitMeta of Object.values(metadata.kits)) {
+      if (kitMeta?.files) {
+        const found = kitMeta.files.find((f3) => f3.path === path10);
+        if (found)
+          return found;
+      }
+    }
+  }
+  if (metadata.files) {
+    const found = metadata.files.find((f3) => f3.path === path10);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function shouldDeletePath(path10, metadata) {
+  const tracked = findFileInMetadata(metadata, path10);
+  if (!tracked)
+    return true;
+  return tracked.ownership !== "user";
+}
+function isGlobPattern(pattern) {
+  return pattern.includes("*") || pattern.includes("?") || pattern.includes("{");
+}
+function collectFilesRecursively(dir, baseDir) {
+  const results = [];
+  if (!existsSync17(dir))
+    return results;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join40(dir, entry.name);
+      const relativePath = relative5(baseDir, fullPath);
+      if (entry.isDirectory()) {
+        results.push(...collectFilesRecursively(fullPath, baseDir));
+      } else {
+        results.push(relativePath);
+      }
+    }
+  } catch {}
+  return results;
+}
+function expandGlobPatterns(patterns, claudeDir) {
+  const expanded = [];
+  const allFiles = collectFilesRecursively(claudeDir, claudeDir);
+  for (const pattern of patterns) {
+    if (isGlobPattern(pattern)) {
+      const matcher = import_picomatch.default(pattern);
+      const matches = allFiles.filter((file) => matcher(file));
+      expanded.push(...matches);
+      if (matches.length > 0) {
+        logger.debug(`Pattern "${pattern}" matched ${matches.length} files`);
+      }
+    } else {
+      expanded.push(pattern);
+    }
+  }
+  return [...new Set(expanded)];
+}
+var MAX_CLEANUP_ITERATIONS = 50;
+function cleanupEmptyDirectories(filePath, claudeDir) {
+  const normalizedClaudeDir = resolve6(claudeDir);
+  let currentDir = resolve6(dirname6(filePath));
+  let iterations = 0;
+  while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
+    iterations++;
+    try {
+      const entries = readdirSync(currentDir);
+      if (entries.length === 0) {
+        rmdirSync(currentDir);
+        logger.debug(`Removed empty directory: ${currentDir}`);
+        currentDir = resolve6(dirname6(currentDir));
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}
+function deletePath(fullPath, claudeDir) {
+  const normalizedPath = resolve6(fullPath);
+  const normalizedClaudeDir = resolve6(claudeDir);
+  if (!normalizedPath.startsWith(`${normalizedClaudeDir}/`) && normalizedPath !== normalizedClaudeDir) {
+    throw new Error(`Path traversal detected: ${fullPath}`);
+  }
+  try {
+    const stat6 = lstatSync2(fullPath);
+    if (stat6.isDirectory()) {
+      rmSync2(fullPath, { recursive: true, force: true });
+    } else {
+      unlinkSync3(fullPath);
+      cleanupEmptyDirectories(fullPath, claudeDir);
+    }
+  } catch (error) {
+    throw new Error(`Failed to delete ${fullPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function updateMetadataAfterDeletion(claudeDir, deletedPaths) {
+  const metadataPath = join40(claudeDir, "metadata.json");
+  if (!await import_fs_extra7.pathExists(metadataPath)) {
+    return;
+  }
+  let content;
+  try {
+    content = await import_fs_extra7.readFile(metadataPath, "utf-8");
+  } catch {
+    logger.debug("Failed to read metadata.json for cleanup");
+    return;
+  }
+  let metadata;
+  try {
+    metadata = JSON.parse(content);
+  } catch {
+    logger.debug("Failed to parse metadata.json for cleanup");
+    return;
+  }
+  const deletedSet = new Set(deletedPaths);
+  const isDeletedOrInDeletedDir = (path10) => {
+    if (deletedSet.has(path10))
+      return true;
+    for (const deleted of deletedPaths) {
+      if (path10.startsWith(`${deleted}/`))
+        return true;
+    }
+    return false;
+  };
+  if (metadata.kits) {
+    for (const kitName of Object.keys(metadata.kits)) {
+      const kit = metadata.kits[kitName];
+      if (kit?.files) {
+        kit.files = kit.files.filter((f3) => !isDeletedOrInDeletedDir(f3.path));
+      }
+    }
+  }
+  if (metadata.files) {
+    metadata.files = metadata.files.filter((f3) => !isDeletedOrInDeletedDir(f3.path));
+  }
+  try {
+    await import_fs_extra7.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    logger.debug(`Updated metadata.json, removed ${deletedPaths.length} entries`);
+  } catch {
+    logger.debug("Failed to write updated metadata.json");
+  }
+}
+async function handleDeletions(sourceMetadata, claudeDir) {
+  const deletionPatterns = sourceMetadata.deletions || [];
+  if (deletionPatterns.length === 0) {
+    return { deletedPaths: [], preservedPaths: [], errors: [] };
+  }
+  const deletions = expandGlobPatterns(deletionPatterns, claudeDir);
+  const userMetadata = await readManifest(claudeDir);
+  const result = { deletedPaths: [], preservedPaths: [], errors: [] };
+  for (const path10 of deletions) {
+    const fullPath = join40(claudeDir, path10);
+    const normalizedPath = resolve6(fullPath);
+    const normalizedClaudeDir = resolve6(claudeDir);
+    if (!normalizedPath.startsWith(`${normalizedClaudeDir}/`)) {
+      logger.warning(`Skipping invalid path: ${path10}`);
+      result.errors.push(path10);
+      continue;
+    }
+    if (!shouldDeletePath(path10, userMetadata)) {
+      result.preservedPaths.push(path10);
+      logger.verbose(`Preserved user file: ${path10}`);
+      continue;
+    }
+    if (existsSync17(fullPath)) {
+      try {
+        deletePath(fullPath, claudeDir);
+        result.deletedPaths.push(path10);
+        logger.verbose(`Deleted: ${path10}`);
+      } catch (error) {
+        result.errors.push(path10);
+        logger.debug(`Failed to delete ${path10}: ${error}`);
+      }
+    }
+  }
+  if (result.deletedPaths.length > 0) {
+    await updateMetadataAfterDeletion(claudeDir, result.deletedPaths);
+  }
+  return result;
+}
+
+// src/domains/installation/file-merger.ts
+init_logger();
+init_types2();
+init_dist2();
+
+// src/domains/installation/merger/copy-executor.ts
+init_logger();
+init_types2();
+var import_fs_extra11 = __toESM(require_lib(), 1);
+var import_ignore3 = __toESM(require_ignore(), 1);
+import { dirname as dirname9, join as join44, relative as relative7 } from "node:path";
+
 // src/domains/installation/selective-merger.ts
+import { stat as stat6 } from "node:fs/promises";
 init_logger();
 var import_semver = __toESM(require_semver2(), 1);
 
@@ -35562,10 +37204,10 @@ class SelectiveMerger {
 
 // src/domains/installation/merger/file-scanner.ts
 init_logger();
-var import_fs_extra7 = __toESM(require_lib(), 1);
+var import_fs_extra8 = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
-import { relative as relative5 } from "node:path";
-import { join as join40 } from "node:path";
+import { relative as relative6 } from "node:path";
+import { join as join41 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str) => {
@@ -37019,12 +38661,12 @@ class FileScanner {
   }
   async getFiles(dir, baseDir = dir) {
     const files = [];
-    const entries = await import_fs_extra7.readdir(dir, { encoding: "utf8" });
+    const entries = await import_fs_extra8.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join40(dir, entry);
-      const relativePath = relative5(baseDir, fullPath);
+      const fullPath = join41(dir, entry);
+      const relativePath = relative6(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const stats = await import_fs_extra7.lstat(fullPath);
+      const stats = await import_fs_extra8.lstat(fullPath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symbolic link: ${normalizedRelativePath}`);
         continue;
@@ -37055,9 +38697,9 @@ class FileScanner {
 }
 
 // src/domains/config/installed-settings-tracker.ts
-import { existsSync as existsSync17 } from "node:fs";
-import { mkdir as mkdir15, readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname6, join as join41 } from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import { mkdir as mkdir15, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname7, join as join42 } from "node:path";
 
 // src/shared/index.ts
 init_logger();
@@ -37097,17 +38739,17 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join41(this.projectDir, CK_JSON_FILE);
+      return join42(this.projectDir, CK_JSON_FILE);
     }
-    return join41(this.projectDir, ".claude", CK_JSON_FILE);
+    return join42(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
-    if (!existsSync17(ckJsonPath)) {
+    if (!existsSync18(ckJsonPath)) {
       return { hooks: [], mcpServers: [] };
     }
     try {
-      const content = await readFile13(ckJsonPath, "utf-8");
+      const content = await readFile14(ckJsonPath, "utf-8");
       const data = JSON.parse(content);
       const installed = data.kits?.[this.kitName]?.installedSettings;
       if (installed) {
@@ -37123,8 +38765,8 @@ class InstalledSettingsTracker {
     const ckJsonPath = this.getCkJsonPath();
     try {
       let data = {};
-      if (existsSync17(ckJsonPath)) {
-        const content = await readFile13(ckJsonPath, "utf-8");
+      if (existsSync18(ckJsonPath)) {
+        const content = await readFile14(ckJsonPath, "utf-8");
         data = JSON.parse(content);
       }
       if (!data.kits) {
@@ -37134,8 +38776,8 @@ class InstalledSettingsTracker {
         data.kits[this.kitName] = {};
       }
       data.kits[this.kitName].installedSettings = settings;
-      await mkdir15(dirname6(ckJsonPath), { recursive: true });
-      await writeFile10(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
+      await mkdir15(dirname7(ckJsonPath), { recursive: true });
+      await writeFile11(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
       logger.debug(`Saved installed settings to ${ckJsonPath}`);
     } catch (error) {
       logger.warning(`Failed to save installed settings: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -37556,18 +39198,18 @@ function mergeSettings(source, destination, options) {
 }
 // src/domains/config/merger/file-io.ts
 init_logger();
-var import_fs_extra8 = __toESM(require_lib(), 1);
+var import_fs_extra9 = __toESM(require_lib(), 1);
 import { randomUUID } from "node:crypto";
-import { dirname as dirname7, join as join42 } from "node:path";
+import { dirname as dirname8, join as join43 } from "node:path";
 function stripBOM(content) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
 async function readSettingsFile(filePath) {
   try {
-    if (!await import_fs_extra8.pathExists(filePath)) {
+    if (!await import_fs_extra9.pathExists(filePath)) {
       return null;
     }
-    const rawContent = await import_fs_extra8.readFile(filePath, "utf-8");
+    const rawContent = await import_fs_extra9.readFile(filePath, "utf-8");
     const content = stripBOM(rawContent);
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -37581,15 +39223,15 @@ async function readSettingsFile(filePath) {
   }
 }
 async function atomicWriteFile(filePath, content) {
-  const dir = dirname7(filePath);
-  const tempPath = join42(dir, `.settings-${randomUUID()}.tmp`);
+  const dir = dirname8(filePath);
+  const tempPath = join43(dir, `.settings-${randomUUID()}.tmp`);
   try {
-    await import_fs_extra8.writeFile(tempPath, content, "utf-8");
-    await import_fs_extra8.rename(tempPath, filePath);
+    await import_fs_extra9.writeFile(tempPath, content, "utf-8");
+    await import_fs_extra9.rename(tempPath, filePath);
   } catch (error) {
     try {
-      if (await import_fs_extra8.pathExists(tempPath)) {
-        await import_fs_extra8.unlink(tempPath);
+      if (await import_fs_extra9.pathExists(tempPath)) {
+        await import_fs_extra9.unlink(tempPath);
       }
     } catch {}
     throw error;
@@ -37618,7 +39260,7 @@ class SettingsMerger {
 // src/domains/installation/merger/settings-processor.ts
 init_environment();
 init_logger();
-var import_fs_extra9 = __toESM(require_lib(), 1);
+var import_fs_extra10 = __toESM(require_lib(), 1);
 
 class SettingsProcessor {
   isGlobal = false;
@@ -37651,7 +39293,7 @@ class SettingsProcessor {
   }
   async processSettingsJson(sourceFile, destFile) {
     try {
-      const sourceContent = await import_fs_extra9.readFile(sourceFile, "utf-8");
+      const sourceContent = await import_fs_extra10.readFile(sourceFile, "utf-8");
       let transformedSource = sourceContent;
       if (this.isGlobal) {
         const homeVar = isWindows() ? '"%USERPROFILE%"' : '"$HOME"';
@@ -37666,12 +39308,12 @@ class SettingsProcessor {
           logger.debug(`Transformed .claude/ paths to ${projectDirVar}/.claude/ in settings.json for local installation`);
         }
       }
-      const destExists = await import_fs_extra9.pathExists(destFile);
+      const destExists = await import_fs_extra10.pathExists(destFile);
       if (destExists && !this.forceOverwriteSettings) {
         await this.selectiveMergeSettings(transformedSource, destFile);
       } else {
         const formattedContent = this.formatJsonContent(transformedSource);
-        await import_fs_extra9.writeFile(destFile, formattedContent, "utf-8");
+        await import_fs_extra10.writeFile(destFile, formattedContent, "utf-8");
         try {
           const parsedSettings = JSON.parse(formattedContent);
           if (this.forceOverwriteSettings && destExists) {
@@ -37685,7 +39327,7 @@ class SettingsProcessor {
       }
     } catch (error) {
       logger.error(`Failed to process settings.json: ${error}`);
-      await import_fs_extra9.copy(sourceFile, destFile, { overwrite: true });
+      await import_fs_extra10.copy(sourceFile, destFile, { overwrite: true });
     }
   }
   async selectiveMergeSettings(transformedSourceContent, destFile) {
@@ -37695,7 +39337,7 @@ class SettingsProcessor {
     } catch {
       logger.warning("Failed to parse source settings.json, falling back to overwrite");
       const formattedContent = this.formatJsonContent(transformedSourceContent);
-      await import_fs_extra9.writeFile(destFile, formattedContent, "utf-8");
+      await import_fs_extra10.writeFile(destFile, formattedContent, "utf-8");
       return;
     }
     let destSettings;
@@ -37781,7 +39423,7 @@ class SettingsProcessor {
   }
   async readAndNormalizeGlobalSettings(destFile) {
     try {
-      const content = await import_fs_extra9.readFile(destFile, "utf-8");
+      const content = await import_fs_extra10.readFile(destFile, "utf-8");
       if (!content.trim())
         return null;
       const homeVar = isWindows() ? "%USERPROFILE%" : "$HOME";
@@ -37890,10 +39532,10 @@ class CopyExecutor {
     const conflicts = [];
     const files = await this.fileScanner.getFiles(sourceDir, sourceDir);
     for (const file of files) {
-      const relativePath = relative6(sourceDir, file);
+      const relativePath = relative7(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join43(destDir, relativePath);
-      if (await import_fs_extra10.pathExists(destPath)) {
+      const destPath = join44(destDir, relativePath);
+      if (await import_fs_extra11.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
           continue;
@@ -37912,16 +39554,16 @@ class CopyExecutor {
     let copiedCount = 0;
     let skippedCount = 0;
     for (const file of files) {
-      const relativePath = relative6(sourceDir, file);
+      const relativePath = relative7(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join43(destDir, relativePath);
+      const destPath = join44(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
         continue;
       }
       if (this.userConfigChecker.ignores(normalizedRelativePath)) {
-        const fileExists = await import_fs_extra10.pathExists(destPath);
+        const fileExists = await import_fs_extra11.pathExists(destPath);
         if (fileExists) {
           logger.debug(`Preserving user config: ${normalizedRelativePath}`);
           skippedCount++;
@@ -37952,7 +39594,7 @@ class CopyExecutor {
           continue;
         }
       }
-      await withRetry2(() => import_fs_extra10.copy(file, destPath, { overwrite: true }));
+      await withRetry2(() => import_fs_extra11.copy(file, destPath, { overwrite: true }));
       this.trackInstalledFile(normalizedRelativePath);
       copiedCount++;
     }
@@ -37991,10 +39633,10 @@ class CopyExecutor {
   }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname8(relativePath);
+    let dir = dirname9(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname8(dir);
+      dir = dirname9(dir);
     }
   }
 }
@@ -38084,15 +39726,15 @@ class FileMerger {
 
 // src/domains/migration/legacy-migration.ts
 import { readdir as readdir9, stat as stat7 } from "node:fs/promises";
-import { join as join47, relative as relative7 } from "node:path";
+import { join as join48, relative as relative8 } from "node:path";
 // src/services/file-operations/manifest/manifest-tracker.ts
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
-var import_fs_extra11 = __toESM(require_lib(), 1);
-import { join as join44 } from "node:path";
+var import_fs_extra12 = __toESM(require_lib(), 1);
+import { join as join45 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -38107,9 +39749,9 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join44(extractDir, "release-manifest.json");
+    const manifestPath = join45(extractDir, "release-manifest.json");
     try {
-      const content = await import_fs_extra11.readFile(manifestPath, "utf-8");
+      const content = await import_fs_extra12.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
       return ReleaseManifestSchema.parse(parsed);
     } catch (error) {
@@ -38127,15 +39769,15 @@ init_environment();
 init_logger();
 
 // src/services/file-operations/manifest/manifest-updater.ts
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 init_logger();
 init_types2();
-var import_fs_extra12 = __toESM(require_lib(), 1);
+var import_fs_extra13 = __toESM(require_lib(), 1);
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 async function writeManifest(claudeDir, kitName, version, scope, kitType, trackedFiles, userConfigFiles) {
-  const metadataPath = join45(claudeDir, "metadata.json");
+  const metadataPath = join46(claudeDir, "metadata.json");
   const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
-  await import_fs_extra12.ensureFile(metadataPath);
+  await import_fs_extra13.ensureFile(metadataPath);
   let release = null;
   try {
     release = await import_proper_lockfile2.lock(metadataPath, {
@@ -38148,9 +39790,9 @@ async function writeManifest(claudeDir, kitName, version, scope, kitType, tracke
       logger.warning(`Metadata migration warning: ${migrationResult.error}`);
     }
     let existingMetadata = { kits: {} };
-    if (await import_fs_extra12.pathExists(metadataPath)) {
+    if (await import_fs_extra13.pathExists(metadataPath)) {
       try {
-        const content = await import_fs_extra12.readFile(metadataPath, "utf-8");
+        const content = await import_fs_extra13.readFile(metadataPath, "utf-8");
         const parsed = JSON.parse(content);
         if (parsed && typeof parsed === "object" && Object.keys(parsed).length > 0) {
           existingMetadata = parsed;
@@ -38179,7 +39821,7 @@ async function writeManifest(claudeDir, kitName, version, scope, kitType, tracke
       userConfigFiles: [...USER_CONFIG_PATTERNS, ...userConfigFiles]
     };
     const validated = MetadataSchema.parse(metadata);
-    await import_fs_extra12.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
+    await import_fs_extra13.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
     logger.debug(`Wrote manifest for kit "${kit}" with ${trackedFiles.length} tracked files`);
   } finally {
     if (release) {
@@ -38189,8 +39831,8 @@ async function writeManifest(claudeDir, kitName, version, scope, kitType, tracke
   }
 }
 async function removeKitFromManifest(claudeDir, kit) {
-  const metadataPath = join45(claudeDir, "metadata.json");
-  if (!await import_fs_extra12.pathExists(metadataPath))
+  const metadataPath = join46(claudeDir, "metadata.json");
+  if (!await import_fs_extra13.pathExists(metadataPath))
     return false;
   let release = null;
   try {
@@ -38211,7 +39853,7 @@ async function removeKitFromManifest(claudeDir, kit) {
       ...metadata,
       kits: remainingKits
     };
-    await import_fs_extra12.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
+    await import_fs_extra13.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
     logger.debug(`Removed kit "${kit}" from metadata, ${Object.keys(remainingKits).length} kit(s) remaining`);
     return true;
   } finally {
@@ -38319,7 +39961,7 @@ function buildFileTrackingList(options) {
     if (!isGlobal && !installedPath.startsWith(".claude/"))
       continue;
     const relativePath = isGlobal ? installedPath : installedPath.replace(/^\.claude\//, "");
-    const filePath = join46(claudeDir, relativePath);
+    const filePath = join47(claudeDir, relativePath);
     const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
     const ownership = manifestEntry ? "ck" : "user";
     filesToTrack.push({
@@ -38392,7 +40034,7 @@ class ManifestWriter {
 
 // src/domains/migration/legacy-migration.ts
 init_logger();
-var import_fs_extra13 = __toESM(require_lib(), 1);
+var import_fs_extra14 = __toESM(require_lib(), 1);
 class LegacyMigration {
   static async detectLegacy(claudeDir) {
     const metadata = await ManifestWriter.readManifest(claudeDir);
@@ -38425,7 +40067,7 @@ class LegacyMigration {
         continue;
       if (SKIP_DIRS_ALL.includes(entry))
         continue;
-      const fullPath = join47(dir, entry);
+      const fullPath = join48(dir, entry);
       let stats;
       try {
         stats = await stat7(fullPath);
@@ -38458,7 +40100,7 @@ class LegacyMigration {
     };
     const filesInManifest = [];
     for (const file of files) {
-      const relativePath = relative7(claudeDir, file).replace(/\\/g, "/");
+      const relativePath = relative8(claudeDir, file).replace(/\\/g, "/");
       const manifestEntry = ReleaseManifestLoader.findFile(manifest, relativePath);
       if (!manifestEntry) {
         preview.userCreated.push(relativePath);
@@ -38527,7 +40169,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await mapWithLimit(filesToChecksum, async ({ relativePath, ownership }) => {
-        const fullPath = join47(claudeDir, relativePath);
+        const fullPath = join48(claudeDir, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       });
@@ -38548,8 +40190,8 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join47(claudeDir, "metadata.json");
-    await import_fs_extra13.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
+    const metadataPath = join48(claudeDir, "metadata.json");
+    await import_fs_extra14.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
   }
@@ -38651,32 +40293,32 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 }
 
 // src/services/file-operations/file-scanner.ts
-import { join as join48, relative as relative8, resolve as resolve6 } from "node:path";
+import { join as join49, relative as relative9, resolve as resolve7 } from "node:path";
 init_logger();
-var import_fs_extra14 = __toESM(require_lib(), 1);
+var import_fs_extra15 = __toESM(require_lib(), 1);
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
     const basePath = relativeTo || dirPath;
     const files = [];
-    if (!await import_fs_extra14.pathExists(dirPath)) {
+    if (!await import_fs_extra15.pathExists(dirPath)) {
       return files;
     }
     try {
-      const entries = await import_fs_extra14.readdir(dirPath, { encoding: "utf8" });
+      const entries = await import_fs_extra15.readdir(dirPath, { encoding: "utf8" });
       for (const entry of entries) {
         if (SKIP_DIRS_ALL.includes(entry)) {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join48(dirPath, entry);
+        const fullPath = join49(dirPath, entry);
         if (!FileScanner2.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
         }
         let stats;
         try {
-          stats = await import_fs_extra14.lstat(fullPath);
+          stats = await import_fs_extra15.lstat(fullPath);
         } catch (error) {
           if (error instanceof Error && "code" in error && (error.code === "EACCES" || error.code === "EPERM")) {
             logger.warning(`Skipping inaccessible path: ${entry}`);
@@ -38692,7 +40334,7 @@ class FileScanner2 {
           const subFiles = await FileScanner2.getFiles(fullPath, basePath);
           files.push(...subFiles);
         } else if (stats.isFile()) {
-          const relativePath = relative8(basePath, fullPath);
+          const relativePath = relative9(basePath, fullPath);
           files.push(FileScanner2.toPosixPath(relativePath));
         }
       }
@@ -38704,8 +40346,8 @@ class FileScanner2 {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join48(destDir, subPath);
-    const sourceSubDir = join48(sourceDir, subPath);
+    const destSubDir = join49(destDir, subPath);
+    const sourceSubDir = join49(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -38715,7 +40357,7 @@ class FileScanner2 {
     const sourceFiles = await FileScanner2.getFiles(sourceSubDir, sourceDir);
     logger.debug(`findCustomFiles - destFiles count: ${destFiles.length}`);
     logger.debug(`findCustomFiles - sourceFiles count: ${sourceFiles.length}`);
-    const sourceExists = await import_fs_extra14.pathExists(sourceSubDir);
+    const sourceExists = await import_fs_extra15.pathExists(sourceSubDir);
     if (sourceExists && sourceFiles.length === 0 && destFiles.length > 100) {
       logger.warning(`Source directory exists but is empty while destination has ${destFiles.length} files. This may indicate an extraction issue. Skipping custom file detection.`);
       return [];
@@ -38733,8 +40375,8 @@ class FileScanner2 {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve6(basePath);
-    const resolvedTarget = resolve6(targetPath);
+    const resolvedBase = resolve7(basePath);
+    const resolvedTarget = resolve7(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path11) {
@@ -38744,14 +40386,14 @@ class FileScanner2 {
 
 // src/services/transformers/commands-prefix/prefix-applier.ts
 init_logger();
-var import_fs_extra15 = __toESM(require_lib(), 1);
+var import_fs_extra16 = __toESM(require_lib(), 1);
 import { lstat as lstat5, mkdir as mkdir16, readdir as readdir12, stat as stat8 } from "node:fs/promises";
-import { join as join50 } from "node:path";
+import { join as join51 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
-import { readFile as readFile18, readdir as readdir11, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join49 } from "node:path";
+import { readFile as readFile19, readdir as readdir11, writeFile as writeFile16 } from "node:fs/promises";
+import { join as join50 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
   ".txt",
@@ -38819,7 +40461,7 @@ async function transformCommandReferences(directory, options = {}) {
   async function processDirectory(dir) {
     const entries = await readdir11(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join49(dir, entry.name);
+      const fullPath = join50(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -38827,13 +40469,13 @@ async function transformCommandReferences(directory, options = {}) {
         await processDirectory(fullPath);
       } else if (entry.isFile() && shouldTransformFile(entry.name)) {
         try {
-          const content = await readFile18(fullPath, "utf-8");
+          const content = await readFile19(fullPath, "utf-8");
           const { transformed, changes } = transformCommandContent(content);
           if (changes > 0) {
             if (options.dryRun) {
               logger.debug(`[dry-run] Would transform ${changes} command ref(s) in ${fullPath}`);
             } else {
-              await writeFile15(fullPath, transformed, "utf-8");
+              await writeFile16(fullPath, transformed, "utf-8");
               if (options.verbose) {
                 logger.verbose(`Transformed ${changes} command ref(s) in ${fullPath}`);
               }
@@ -38894,14 +40536,14 @@ function shouldApplyPrefix(options) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join50(extractDir, ".claude", "commands");
-  if (!await import_fs_extra15.pathExists(commandsDir)) {
+  const commandsDir = join51(extractDir, ".claude", "commands");
+  if (!await import_fs_extra16.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join50(extractDir, ".commands-backup");
-  const tempDir = join50(extractDir, ".commands-prefix-temp");
+  const backupDir = join51(extractDir, ".commands-backup");
+  const tempDir = join51(extractDir, ".commands-prefix-temp");
   try {
     const entries = await readdir12(commandsDir);
     if (entries.length === 0) {
@@ -38909,28 +40551,28 @@ async function applyPrefix(extractDir) {
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join50(commandsDir, "ck");
+      const ckDir2 = join51(commandsDir, "ck");
       const ckStat = await stat8(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
         return;
       }
     }
-    await import_fs_extra15.copy(commandsDir, backupDir);
+    await import_fs_extra16.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir16(tempDir, { recursive: true });
-    const ckDir = join50(tempDir, "ck");
+    const ckDir = join51(tempDir, "ck");
     await mkdir16(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join50(commandsDir, entry);
+      const sourcePath = join51(commandsDir, entry);
       const stats = await lstat5(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join50(ckDir, entry);
-      await import_fs_extra15.copy(sourcePath, destPath, {
+      const destPath = join51(ckDir, entry);
+      await import_fs_extra16.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
       });
@@ -38939,15 +40581,15 @@ async function applyPrefix(extractDir) {
     }
     if (processedCount === 0) {
       logger.warning("No files to move (all were symlinks or invalid)");
-      await import_fs_extra15.remove(backupDir);
-      await import_fs_extra15.remove(tempDir);
+      await import_fs_extra16.remove(backupDir);
+      await import_fs_extra16.remove(tempDir);
       return;
     }
-    await import_fs_extra15.remove(commandsDir);
-    await import_fs_extra15.move(tempDir, commandsDir);
-    await import_fs_extra15.remove(backupDir);
+    await import_fs_extra16.remove(commandsDir);
+    await import_fs_extra16.move(tempDir, commandsDir);
+    await import_fs_extra16.remove(backupDir);
     logger.success("Successfully reorganized commands to /ck: prefix");
-    const claudeDir = join50(extractDir, ".claude");
+    const claudeDir = join51(extractDir, ".claude");
     logger.info("Transforming command references in file contents...");
     const transformResult = await transformCommandReferences(claudeDir, {
       verbose: logger.isVerbose()
@@ -38958,46 +40600,46 @@ async function applyPrefix(extractDir) {
       logger.verbose("No command references needed transformation");
     }
   } catch (error) {
-    if (await import_fs_extra15.pathExists(backupDir)) {
+    if (await import_fs_extra16.pathExists(backupDir)) {
       try {
-        await import_fs_extra15.remove(commandsDir).catch(() => {});
-        await import_fs_extra15.move(backupDir, commandsDir);
+        await import_fs_extra16.remove(commandsDir).catch(() => {});
+        await import_fs_extra16.move(backupDir, commandsDir);
         logger.info("Restored original commands directory from backup");
       } catch (rollbackError) {
         logger.error(`Rollback failed: ${rollbackError}`);
       }
     }
-    if (await import_fs_extra15.pathExists(tempDir)) {
-      await import_fs_extra15.remove(tempDir).catch(() => {});
+    if (await import_fs_extra16.pathExists(tempDir)) {
+      await import_fs_extra16.remove(tempDir).catch(() => {});
     }
     logger.error("Failed to apply /ck: prefix to commands");
     throw error;
   } finally {
-    if (await import_fs_extra15.pathExists(backupDir)) {
-      await import_fs_extra15.remove(backupDir).catch(() => {});
+    if (await import_fs_extra16.pathExists(backupDir)) {
+      await import_fs_extra16.remove(backupDir).catch(() => {});
     }
-    if (await import_fs_extra15.pathExists(tempDir)) {
-      await import_fs_extra15.remove(tempDir).catch(() => {});
+    if (await import_fs_extra16.pathExists(tempDir)) {
+      await import_fs_extra16.remove(tempDir).catch(() => {});
     }
   }
 }
 
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
 import { lstat as lstat7, readdir as readdir14 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 init_logger();
-var import_fs_extra17 = __toESM(require_lib(), 1);
+var import_fs_extra18 = __toESM(require_lib(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
 import { lstat as lstat6, readdir as readdir13 } from "node:fs/promises";
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 init_logger();
-var import_fs_extra16 = __toESM(require_lib(), 1);
+var import_fs_extra17 = __toESM(require_lib(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
   const entries = await readdir13(dir);
   for (const entry of entries) {
-    const fullPath = join51(dir, entry);
+    const fullPath = join52(dir, entry);
     const stats = await lstat6(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -39020,7 +40662,7 @@ async function processFileOwnership(file, relativePath, metadata, claudeDir, opt
       action: "delete"
     });
     if (!dryRun) {
-      await import_fs_extra16.remove(file);
+      await import_fs_extra17.remove(file);
       logger.verbose(`Deleted CK file: ${relativePath}`);
     }
     accumulator.deletedCount++;
@@ -39035,7 +40677,7 @@ async function processFileOwnership(file, relativePath, metadata, claudeDir, opt
         reason: "force overwrite"
       });
       if (!dryRun) {
-        await import_fs_extra16.remove(file);
+        await import_fs_extra17.remove(file);
         logger.verbose(`Force-deleted modified file: ${relativePath}`);
       }
       accumulator.deletedCount++;
@@ -39059,7 +40701,7 @@ async function processFileOwnership(file, relativePath, metadata, claudeDir, opt
       reason: "force overwrite"
     });
     if (!dryRun) {
-      await import_fs_extra16.remove(file);
+      await import_fs_extra17.remove(file);
       logger.verbose(`Force-deleted user file: ${relativePath}`);
     }
     accumulator.deletedCount++;
@@ -39105,8 +40747,8 @@ function logCleanupSummary(deletedCount, preservedCount, dryRun, results) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
   const { dryRun = false } = options;
   validatePath(targetDir, "targetDir");
-  const claudeDir = isGlobal ? targetDir : join52(targetDir, ".claude");
-  const commandsDir = join52(claudeDir, "commands");
+  const claudeDir = isGlobal ? targetDir : join53(targetDir, ".claude");
+  const commandsDir = join53(claudeDir, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -39118,7 +40760,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
     preservedCount: 0,
     wasDryRun: dryRun
   };
-  if (!await import_fs_extra17.pathExists(commandsDir)) {
+  if (!await import_fs_extra18.pathExists(commandsDir)) {
     logger.verbose(`Commands directory does not exist: ${commandsDir}`);
     return result;
   }
@@ -39140,7 +40782,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
     return result;
   }
   for (const entry of entries) {
-    const entryPath = join52(commandsDir, entry);
+    const entryPath = join53(commandsDir, entry);
     const stats = await lstat7(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -39169,7 +40811,7 @@ async function processDirectory(entryPath, entry, claudeDir, metadata, options,
     }
   }
   if (canDeleteDir && !dryRun) {
-    await import_fs_extra17.remove(entryPath);
+    await import_fs_extra18.remove(entryPath);
     logger.verbose(`Removed directory: ${entry}`);
   }
 }
@@ -39184,7 +40826,7 @@ class CommandsPrefix {
 // src/commands/init/phases/merge-handler.ts
 init_logger();
 init_output_manager();
-var import_fs_extra18 = __toESM(require_lib(), 1);
+var import_fs_extra19 = __toESM(require_lib(), 1);
 async function handleMerge(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir || !ctx.kit || !ctx.kitType) {
     return ctx;
@@ -39193,7 +40835,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join53(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join54(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -39237,7 +40879,7 @@ async function handleMerge(ctx) {
   if (releaseManifest) {
     merger.setManifest(releaseManifest);
   }
-  if (!ctx.options.fresh && await import_fs_extra18.pathExists(ctx.claudeDir)) {
+  if (!ctx.options.fresh && await import_fs_extra19.pathExists(ctx.claudeDir)) {
     const legacyDetection = await LegacyMigration.detectLegacy(ctx.claudeDir);
     if (legacyDetection.isLegacy && releaseManifest) {
       logger.info("Legacy installation detected - migrating to ownership tracking...");
@@ -39257,13 +40899,34 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join53(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceDir = ctx.options.global ? join54(ctx.extractDir, ".claude") : ctx.extractDir;
   await merger.merge(sourceDir, ctx.resolvedDir, ctx.isNonInteractive);
   const fileConflicts = merger.getFileConflicts();
   if (fileConflicts.length > 0 && !ctx.isNonInteractive) {
     const summary = buildConflictSummary(fileConflicts, [], []);
     displayConflictSummary(summary);
   }
+  try {
+    const sourceMetadataPath = join54(sourceDir, "metadata.json");
+    if (await import_fs_extra19.pathExists(sourceMetadataPath)) {
+      const metadataContent = await import_fs_extra19.readFile(sourceMetadataPath, "utf-8");
+      const sourceMetadata = JSON.parse(metadataContent);
+      if (sourceMetadata.deletions && sourceMetadata.deletions.length > 0) {
+        const deletionResult = await handleDeletions(sourceMetadata, ctx.claudeDir);
+        if (deletionResult.deletedPaths.length > 0) {
+          logger.info(`Removed ${deletionResult.deletedPaths.length} deprecated file(s)`);
+          for (const path11 of deletionResult.deletedPaths) {
+            logger.verbose(`  - ${path11}`);
+          }
+        }
+        if (deletionResult.preservedPaths.length > 0) {
+          logger.verbose(`Preserved ${deletionResult.preservedPaths.length} user-owned file(s)`);
+        }
+      }
+    }
+  } catch (error) {
+    logger.debug(`Cleanup of deprecated files failed: ${error}`);
+  }
   const installedFiles = merger.getAllInstalledFiles();
   const filesToTrack = buildFileTrackingList({
     installedFiles,
@@ -39286,11 +40949,11 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
-var import_fs_extra21 = __toESM(require_lib(), 1);
+var import_fs_extra22 = __toESM(require_lib(), 1);
 
 // src/domains/skills/detection/config-detector.ts
 init_logger();
@@ -39298,17 +40961,17 @@ init_logger();
 // src/domains/skills/skills-manifest.ts
 init_logger();
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile19, readdir as readdir15, writeFile as writeFile16 } from "node:fs/promises";
-import { join as join54, relative as relative9 } from "node:path";
+import { readFile as readFile21, readdir as readdir15, writeFile as writeFile17 } from "node:fs/promises";
+import { join as join55, relative as relative10 } from "node:path";
 init_types2();
-var import_fs_extra19 = __toESM(require_lib(), 1);
+var import_fs_extra20 = __toESM(require_lib(), 1);
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
   static MANIFEST_VERSION = "1.0.0";
   static async generateManifest(skillsDir) {
     logger.debug(`Generating manifest for: ${skillsDir}`);
-    if (!await import_fs_extra19.pathExists(skillsDir)) {
+    if (!await import_fs_extra20.pathExists(skillsDir)) {
       throw new SkillsMigrationError(`Skills directory does not exist: ${skillsDir}`);
     }
     const structure = await SkillsManifestManager.detectStructure(skillsDir);
@@ -39323,18 +40986,18 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir, manifest) {
-    const manifestPath = join54(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    await writeFile16(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = join55(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    await writeFile17(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir) {
-    const manifestPath = join54(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    if (!await import_fs_extra19.pathExists(manifestPath)) {
+    const manifestPath = join55(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    if (!await import_fs_extra20.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
     }
     try {
-      const content = await readFile19(manifestPath, "utf-8");
+      const content = await readFile21(manifestPath, "utf-8");
       const data = JSON.parse(content);
       const manifest = SkillsManifestSchema.parse(data);
       logger.debug(`Read manifest from: ${manifestPath}`);
@@ -39351,7 +41014,7 @@ class SkillsManifestManager {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join54(skillsDir, dir.name);
+      const dirPath = join55(skillsDir, dir.name);
       const subEntries = await readdir15(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
@@ -39370,7 +41033,7 @@ class SkillsManifestManager {
       const entries = await readdir15(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join54(skillsDir, entry.name);
+          const skillPath = join55(skillsDir, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -39382,11 +41045,11 @@ class SkillsManifestManager {
       const categories = await readdir15(skillsDir, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join54(skillsDir, category.name);
+          const categoryPath = join55(skillsDir, category.name);
           const skillEntries = await readdir15(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join54(categoryPath, skillEntry.name);
+              const skillPath = join55(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -39405,8 +41068,8 @@ class SkillsManifestManager {
     const files = await SkillsManifestManager.getAllFiles(dirPath);
     files.sort();
     for (const file of files) {
-      const relativePath = relative9(dirPath, file);
-      const content = await readFile19(file);
+      const relativePath = relative10(dirPath, file);
+      const content = await readFile21(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -39416,7 +41079,7 @@ class SkillsManifestManager {
     const files = [];
     const entries = await readdir15(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join54(dirPath, entry.name);
+      const fullPath = join55(dirPath, entry.name);
       if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
@@ -39536,11 +41199,11 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 }
 
 // src/domains/skills/detection/script-detector.ts
-var import_fs_extra20 = __toESM(require_lib(), 1);
+var import_fs_extra21 = __toESM(require_lib(), 1);
 import { readdir as readdir16 } from "node:fs/promises";
-import { join as join55 } from "node:path";
+import { join as join56 } from "node:path";
 async function scanDirectory(skillsDir) {
-  if (!await import_fs_extra20.pathExists(skillsDir)) {
+  if (!await import_fs_extra21.pathExists(skillsDir)) {
     return ["flat", []];
   }
   const entries = await readdir16(skillsDir, { withFileTypes: true });
@@ -39551,12 +41214,12 @@ async function scanDirectory(skillsDir) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join55(skillsDir, dir.name);
+    const dirPath = join56(skillsDir, dir.name);
     const subEntries = await readdir16(dirPath, { withFileTypes: true });
     const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
     if (subdirs.length > 0) {
       for (const subdir of subdirs.slice(0, 3)) {
-        const subdirPath = join55(dirPath, subdir.name);
+        const subdirPath = join56(dirPath, subdir.name);
         const subdirFiles = await readdir16(subdirPath, { withFileTypes: true });
         const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
         if (hasSkillMarker) {
@@ -39678,8 +41341,8 @@ async function detectViaManifest(oldSkillsDir, currentSkillsDir) {
 class SkillsMigrationDetector {
   static async detectMigration(oldSkillsDir, currentSkillsDir) {
     logger.debug("Detecting skills migration need...");
-    const oldExists = await import_fs_extra21.pathExists(oldSkillsDir);
-    const currentExists = await import_fs_extra21.pathExists(currentSkillsDir);
+    const oldExists = await import_fs_extra22.pathExists(oldSkillsDir);
+    const currentExists = await import_fs_extra22.pathExists(currentSkillsDir);
     if (!oldExists && !currentExists) {
       logger.debug("No skills directories found, migration not needed");
       return {
@@ -39713,13 +41376,13 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types2();
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
 import { copyFile as copyFile4, mkdir as mkdir17, readdir as readdir17, rm as rm3 } from "node:fs/promises";
-import { join as join56 } from "node:path";
-var import_fs_extra22 = __toESM(require_lib(), 1);
+import { join as join57 } from "node:path";
+var import_fs_extra23 = __toESM(require_lib(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
 init_environment();
@@ -39883,8 +41546,8 @@ async function copySkillDirectory(sourceDir, destDir) {
   await mkdir17(destDir, { recursive: true });
   const entries = await readdir17(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join56(sourceDir, entry.name);
-    const destPath = join56(destDir, entry.name);
+    const sourcePath = join57(sourceDir, entry.name);
+    const destPath = join57(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -39899,14 +41562,14 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join56(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join57(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir17(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
       try {
         const skillName = mapping.skillName;
         const currentSkillPath = mapping.oldPath;
-        if (!await import_fs_extra22.pathExists(currentSkillPath)) {
+        if (!await import_fs_extra23.pathExists(currentSkillPath)) {
           logger.warning(`Skill not found, skipping: ${skillName}`);
           continue;
         }
@@ -39920,9 +41583,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join56(tempDir, category, skillName) : join56(tempDir, skillName);
+        const targetPath = category ? join57(tempDir, category, skillName) : join57(tempDir, skillName);
         if (category) {
-          await mkdir17(join56(tempDir, category), { recursive: true });
+          await mkdir17(join57(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -39987,9 +41650,9 @@ function validateMigrationPath(path11, paramName) {
 // src/domains/skills/skills-backup-manager.ts
 init_logger();
 init_types2();
-var import_fs_extra23 = __toESM(require_lib(), 1);
+var import_fs_extra24 = __toESM(require_lib(), 1);
 import { copyFile as copyFile5, mkdir as mkdir18, readdir as readdir18, rm as rm4, stat as stat9 } from "node:fs/promises";
-import { basename as basename2, join as join57, normalize as normalize6 } from "node:path";
+import { basename as basename2, join as join58, normalize as normalize6 } from "node:path";
 function validatePath2(path11, paramName) {
   if (!path11 || typeof path11 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -40009,13 +41672,13 @@ class SkillsBackupManager {
     if (parentDir) {
       validatePath2(parentDir, "parentDir");
     }
-    if (!await import_fs_extra23.pathExists(skillsDir)) {
+    if (!await import_fs_extra24.pathExists(skillsDir)) {
       throw new SkillsMigrationError(`Cannot create backup: Skills directory does not exist: ${skillsDir}`);
     }
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join57(parentDir, backupDirName) : join57(skillsDir, "..", backupDirName);
+    const backupDir = parentDir ? join58(parentDir, backupDirName) : join58(skillsDir, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir18(backupDir, { recursive: true });
@@ -40032,12 +41695,12 @@ class SkillsBackupManager {
   static async restoreBackup(backupDir, targetDir) {
     validatePath2(backupDir, "backupDir");
     validatePath2(targetDir, "targetDir");
-    if (!await import_fs_extra23.pathExists(backupDir)) {
+    if (!await import_fs_extra24.pathExists(backupDir)) {
       throw new SkillsMigrationError(`Cannot restore: Backup directory does not exist: ${backupDir}`);
     }
     logger.info(`Restoring from backup: ${backupDir}`);
     try {
-      if (await import_fs_extra23.pathExists(targetDir)) {
+      if (await import_fs_extra24.pathExists(targetDir)) {
         await rm4(targetDir, { recursive: true, force: true });
       }
       await mkdir18(targetDir, { recursive: true });
@@ -40048,7 +41711,7 @@ class SkillsBackupManager {
     }
   }
   static async deleteBackup(backupDir) {
-    if (!await import_fs_extra23.pathExists(backupDir)) {
+    if (!await import_fs_extra24.pathExists(backupDir)) {
       logger.warning(`Backup directory does not exist: ${backupDir}`);
       return;
     }
@@ -40061,12 +41724,12 @@ class SkillsBackupManager {
     }
   }
   static async listBackups(parentDir) {
-    if (!await import_fs_extra23.pathExists(parentDir)) {
+    if (!await import_fs_extra24.pathExists(parentDir)) {
       return [];
     }
     try {
       const entries = await readdir18(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join57(parentDir, entry.name));
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join58(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -40086,7 +41749,7 @@ class SkillsBackupManager {
     }
   }
   static async getBackupSize(backupDir) {
-    if (!await import_fs_extra23.pathExists(backupDir)) {
+    if (!await import_fs_extra24.pathExists(backupDir)) {
       return 0;
     }
     return await SkillsBackupManager.getDirectorySize(backupDir);
@@ -40094,8 +41757,8 @@ class SkillsBackupManager {
   static async copyDirectory(sourceDir, destDir) {
     const entries = await readdir18(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join57(sourceDir, entry.name);
-      const destPath = join57(destDir, entry.name);
+      const sourcePath = join58(sourceDir, entry.name);
+      const destPath = join58(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -40111,7 +41774,7 @@ class SkillsBackupManager {
     let size = 0;
     const entries = await readdir18(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join57(dirPath, entry.name);
+      const fullPath = join58(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -40139,19 +41802,19 @@ class SkillsBackupManager {
 init_logger();
 
 // src/domains/skills/customization/comparison-engine.ts
-var import_fs_extra24 = __toESM(require_lib(), 1);
-import { relative as relative11 } from "node:path";
+var import_fs_extra25 = __toESM(require_lib(), 1);
+import { relative as relative12 } from "node:path";
 
 // src/domains/skills/customization/hash-calculator.ts
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
-import { readFile as readFile20, readdir as readdir19 } from "node:fs/promises";
-import { join as join58, relative as relative10 } from "node:path";
+import { readFile as readFile22, readdir as readdir19 } from "node:fs/promises";
+import { join as join59, relative as relative11 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
   const entries = await readdir19(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join58(dirPath, entry.name);
+    const fullPath = join59(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -40165,12 +41828,12 @@ async function getAllFiles(dirPath) {
   return files;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const hash = createHash3("sha256");
     const stream = createReadStream2(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => {
-      resolve7(hash.digest("hex"));
+      resolve8(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       stream.destroy();
@@ -40183,8 +41846,8 @@ async function hashDirectory(dirPath) {
   const files = await getAllFiles(dirPath);
   files.sort();
   for (const file of files) {
-    const relativePath = relative10(dirPath, file);
-    const content = await readFile20(file);
+    const relativePath = relative11(dirPath, file);
+    const content = await readFile22(file);
     hash.update(relativePath);
     hash.update(content);
   }
@@ -40217,8 +41880,8 @@ async function compareDirectories(dir1, dir2) {
   if (files1.length !== files2.length) {
     return true;
   }
-  const relFiles1 = files1.map((f3) => relative11(dir1, f3)).sort();
-  const relFiles2 = files2.map((f3) => relative11(dir2, f3)).sort();
+  const relFiles1 = files1.map((f3) => relative12(dir1, f3)).sort();
+  const relFiles2 = files2.map((f3) => relative12(dir2, f3)).sort();
   if (JSON.stringify(relFiles1) !== JSON.stringify(relFiles2)) {
     return true;
   }
@@ -40234,14 +41897,14 @@ async function compareDirectories(dir1, dir2) {
 async function detectFileChanges(currentSkillPath, baselineSkillPath) {
   const changes = [];
   const currentFiles = await getAllFiles(currentSkillPath);
-  const baselineFiles = await import_fs_extra24.pathExists(baselineSkillPath) ? await getAllFiles(baselineSkillPath) : [];
+  const baselineFiles = await import_fs_extra25.pathExists(baselineSkillPath) ? await getAllFiles(baselineSkillPath) : [];
   const currentFileMap = new Map(await Promise.all(currentFiles.map(async (f3) => {
-    const relPath = relative11(currentSkillPath, f3);
+    const relPath = relative12(currentSkillPath, f3);
     const hash = await hashFile(f3);
     return [relPath, hash];
   })));
   const baselineFileMap = new Map(await Promise.all(baselineFiles.map(async (f3) => {
-    const relPath = relative11(baselineSkillPath, f3);
+    const relPath = relative12(baselineSkillPath, f3);
     const hash = await hashFile(f3);
     return [relPath, hash];
   })));
@@ -40276,9 +41939,9 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 
 // src/domains/skills/customization/scan-reporter.ts
 init_types2();
-var import_fs_extra25 = __toESM(require_lib(), 1);
+var import_fs_extra26 = __toESM(require_lib(), 1);
 import { readdir as readdir20 } from "node:fs/promises";
-import { join as join59, normalize as normalize7 } from "node:path";
+import { join as join60, normalize as normalize7 } from "node:path";
 function validatePath3(path11, paramName) {
   if (!path11 || typeof path11 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -40291,7 +41954,7 @@ function validatePath3(path11, paramName) {
   }
 }
 async function scanSkillsDirectory(skillsDir) {
-  if (!await import_fs_extra25.pathExists(skillsDir)) {
+  if (!await import_fs_extra26.pathExists(skillsDir)) {
     return ["flat", []];
   }
   const entries = await readdir20(skillsDir, { withFileTypes: true });
@@ -40299,13 +41962,13 @@ async function scanSkillsDirectory(skillsDir) {
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join59(skillsDir, dirs[0].name);
+  const firstDirPath = join60(skillsDir, dirs[0].name);
   const subEntries = await readdir20(firstDirPath, { withFileTypes: true });
   const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   if (subdirs.length > 0) {
     let skillLikeCount = 0;
     for (const subdir of subdirs.slice(0, 3)) {
-      const subdirPath = join59(firstDirPath, subdir.name);
+      const subdirPath = join60(firstDirPath, subdir.name);
       const subdirFiles = await readdir20(subdirPath, { withFileTypes: true });
       const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
       if (hasSkillMarker) {
@@ -40315,7 +41978,7 @@ async function scanSkillsDirectory(skillsDir) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join59(skillsDir, dir.name);
+        const categoryPath = join60(skillsDir, dir.name);
         const skillDirs = await readdir20(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
@@ -40325,8 +41988,8 @@ async function scanSkillsDirectory(skillsDir) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir, skillName) {
-  const flatPath = join59(skillsDir, skillName);
-  if (await import_fs_extra25.pathExists(flatPath)) {
+  const flatPath = join60(skillsDir, skillName);
+  if (await import_fs_extra26.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
   const entries = await readdir20(skillsDir, { withFileTypes: true });
@@ -40334,9 +41997,9 @@ async function findSkillPath(skillsDir, skillName) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join59(skillsDir, entry.name);
-    const skillPath = join59(categoryPath, skillName);
-    if (await import_fs_extra25.pathExists(skillPath)) {
+    const categoryPath = join60(skillsDir, entry.name);
+    const skillPath = join60(categoryPath, skillName);
+    if (await import_fs_extra26.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
   }
@@ -40429,7 +42092,7 @@ class SkillsMigrator {
         }
       }
       if (options.backup && !options.dryRun) {
-        const claudeDir = join60(currentSkillsDir, "..");
+        const claudeDir = join61(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -40482,7 +42145,7 @@ class SkillsMigrator {
 // src/commands/init/phases/migration-handler.ts
 init_logger();
 init_path_resolver();
-var import_fs_extra26 = __toESM(require_lib(), 1);
+var import_fs_extra27 = __toESM(require_lib(), 1);
 async function handleMigration(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir)
     return ctx;
@@ -40490,9 +42153,9 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join61(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join62(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
-  if (!await import_fs_extra26.pathExists(newSkillsDir) || !await import_fs_extra26.pathExists(currentSkillsDir)) {
+  if (!await import_fs_extra27.pathExists(newSkillsDir) || !await import_fs_extra27.pathExists(currentSkillsDir)) {
     return ctx;
   }
   logger.info("Checking for skills directory migration...");
@@ -40514,13 +42177,13 @@ async function handleMigration(ctx) {
 }
 // src/commands/init/phases/opencode-handler.ts
 import { cp, readdir as readdir22, rm as rm5 } from "node:fs/promises";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
-import { readFile as readFile21, readdir as readdir21, writeFile as writeFile17 } from "node:fs/promises";
+import { readFile as readFile23, readdir as readdir21, writeFile as writeFile18 } from "node:fs/promises";
 import { platform as platform10 } from "node:os";
-import { extname as extname2, join as join62 } from "node:path";
+import { extname as extname2, join as join63 } from "node:path";
 var IS_WINDOWS3 = platform10() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
@@ -40581,7 +42244,7 @@ async function transformPathsForGlobalOpenCode(directory, options = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir21(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join62(dir, entry.name);
+      const fullPath = join63(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -40589,10 +42252,10 @@ async function transformPathsForGlobalOpenCode(directory, options = {}) {
         await processDirectory2(fullPath);
       } else if (entry.isFile() && shouldTransformFile2(entry.name)) {
         try {
-          const content = await readFile21(fullPath, "utf-8");
+          const content = await readFile23(fullPath, "utf-8");
           const { transformed, changes } = transformOpenCodeContent(content);
           if (changes > 0) {
-            await writeFile17(fullPath, transformed, "utf-8");
+            await writeFile18(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -40615,13 +42278,13 @@ async function transformPathsForGlobalOpenCode(directory, options = {}) {
 // src/commands/init/phases/opencode-handler.ts
 init_logger();
 init_path_resolver();
-var import_fs_extra27 = __toESM(require_lib(), 1);
+var import_fs_extra28 = __toESM(require_lib(), 1);
 async function handleOpenCode(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
     return ctx;
   }
-  const openCodeSource = join63(ctx.extractDir, ".opencode");
-  if (!await import_fs_extra27.pathExists(openCodeSource)) {
+  const openCodeSource = join64(ctx.extractDir, ".opencode");
+  if (!await import_fs_extra28.pathExists(openCodeSource)) {
     logger.debug("No .opencode directory in archive, skipping");
     return ctx;
   }
@@ -40635,12 +42298,12 @@ async function handleOpenCode(ctx) {
     if (transformResult.totalChanges > 0) {
       logger.success(`Transformed ${transformResult.totalChanges} OpenCode path(s) in ${transformResult.filesTransformed} file(s)`);
     }
-    await import_fs_extra27.ensureDir(targetDir);
+    await import_fs_extra28.ensureDir(targetDir);
     const entries = await readdir22(openCodeSource, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join63(openCodeSource, entry.name);
-      const targetPath = join63(targetDir, entry.name);
-      if (await import_fs_extra27.pathExists(targetPath)) {
+      const sourcePath = join64(openCodeSource, entry.name);
+      const targetPath = join64(targetDir, entry.name);
+      if (await import_fs_extra28.pathExists(targetPath)) {
         if (!ctx.options.forceOverwrite) {
           logger.verbose(`Skipping existing: ${entry.name}`);
           continue;
@@ -40660,18 +42323,18 @@ async function handleOpenCode(ctx) {
 init_logger();
 init_path_resolver();
 init_types2();
-import { existsSync as existsSync18 } from "node:fs";
-import { mkdir as mkdir19, readFile as readFile22, rename as rename2, rm as rm6, writeFile as writeFile18 } from "node:fs/promises";
+import { existsSync as existsSync19 } from "node:fs";
+import { mkdir as mkdir19, readFile as readFile24, rename as rename2, rm as rm6, writeFile as writeFile19 } from "node:fs/promises";
 import { chmod as chmod2 } from "node:fs/promises";
 import { platform as platform11 } from "node:os";
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 var PROJECT_CONFIG_FILE = ".ck.json";
 
 class ConfigManager {
   static config = null;
   static globalFlag = false;
   static getProjectConfigDir(projectDir, global3) {
-    return global3 ? projectDir : join64(projectDir, ".claude");
+    return global3 ? projectDir : join65(projectDir, ".claude");
   }
   static setGlobalFlag(global3) {
     ConfigManager.globalFlag = global3;
@@ -40686,8 +42349,8 @@ class ConfigManager {
     }
     const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
     try {
-      if (existsSync18(configFile)) {
-        const content = await readFile22(configFile, "utf-8");
+      if (existsSync19(configFile)) {
+        const content = await readFile24(configFile, "utf-8");
         const data = JSON.parse(content);
         ConfigManager.config = ConfigSchema.parse(data);
         logger.debug(`Config loaded from ${configFile}`);
@@ -40704,13 +42367,13 @@ class ConfigManager {
       const validConfig = ConfigSchema.parse(config);
       const configDir = PathResolver.getConfigDir(ConfigManager.globalFlag);
       const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
-      if (!existsSync18(configDir)) {
+      if (!existsSync19(configDir)) {
         await mkdir19(configDir, { recursive: true });
         if (platform11() !== "win32") {
           await chmod2(configDir, 448);
         }
       }
-      await writeFile18(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
+      await writeFile19(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
       if (platform11() !== "win32") {
         await chmod2(configFile, 384);
       }
@@ -40738,10 +42401,10 @@ class ConfigManager {
   }
   static async loadProjectConfig(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join64(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join65(configDir, PROJECT_CONFIG_FILE);
     try {
-      if (existsSync18(configPath)) {
-        const content = await readFile22(configPath, "utf-8");
+      if (existsSync19(configPath)) {
+        const content = await readFile24(configPath, "utf-8");
         const data = JSON.parse(content);
         const folders = FoldersConfigSchema.parse(data.paths || data);
         logger.debug(`Project config loaded from ${configPath}`);
@@ -40754,15 +42417,15 @@ class ConfigManager {
   }
   static async saveProjectConfig(projectDir, folders, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join64(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join65(configDir, PROJECT_CONFIG_FILE);
     try {
-      if (!existsSync18(configDir)) {
+      if (!existsSync19(configDir)) {
         await mkdir19(configDir, { recursive: true });
       }
       let existingConfig = {};
-      if (existsSync18(configPath)) {
+      if (existsSync19(configPath)) {
         try {
-          const content = await readFile22(configPath, "utf-8");
+          const content = await readFile24(configPath, "utf-8");
           existingConfig = JSON.parse(content);
         } catch (error) {
           logger.debug(`Could not parse existing config, starting fresh: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -40777,7 +42440,7 @@ class ConfigManager {
           ...validFolders
         }
       };
-      await writeFile18(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+      await writeFile19(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
       logger.debug(`Project config saved to ${configPath}`);
     } catch (error) {
       throw new Error(`Failed to save project config: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -40803,21 +42466,21 @@ class ConfigManager {
   }
   static projectConfigExists(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    return existsSync18(join64(configDir, PROJECT_CONFIG_FILE));
+    return existsSync19(join65(configDir, PROJECT_CONFIG_FILE));
   }
   static async migrateNestedConfig(globalDir) {
-    const correctPath = join64(globalDir, PROJECT_CONFIG_FILE);
-    const incorrectPath = join64(globalDir, ".claude", PROJECT_CONFIG_FILE);
-    if (existsSync18(correctPath)) {
+    const correctPath = join65(globalDir, PROJECT_CONFIG_FILE);
+    const incorrectPath = join65(globalDir, ".claude", PROJECT_CONFIG_FILE);
+    if (existsSync19(correctPath)) {
       logger.debug("Config already exists at correct location, skipping migration");
       return false;
     }
-    if (existsSync18(incorrectPath)) {
+    if (existsSync19(incorrectPath)) {
       try {
         logger.info("Migrating .ck.json from nested location to correct location...");
         await rename2(incorrectPath, correctPath);
         logger.success(`Migrated ${PROJECT_CONFIG_FILE} to ${correctPath}`);
-        const nestedClaudeDir = join64(globalDir, ".claude");
+        const nestedClaudeDir = join65(globalDir, ".claude");
         try {
           await rm6(nestedClaudeDir, { recursive: false });
           logger.debug("Removed empty nested .claude directory");
@@ -40908,20 +42571,20 @@ Please use only one download method.`);
   };
 }
 // src/commands/init/phases/post-install-handler.ts
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 init_logger();
 init_path_resolver();
-var import_fs_extra28 = __toESM(require_lib(), 1);
+var import_fs_extra29 = __toESM(require_lib(), 1);
 async function handlePostInstall(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join65(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join65(ctx.resolvedDir, "CLAUDE.md");
-    if (await import_fs_extra28.pathExists(claudeMdSource)) {
-      if (!await import_fs_extra28.pathExists(claudeMdDest)) {
-        await import_fs_extra28.copy(claudeMdSource, claudeMdDest);
+    const claudeMdSource = join66(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join66(ctx.resolvedDir, "CLAUDE.md");
+    if (await import_fs_extra29.pathExists(claudeMdSource)) {
+      if (!await import_fs_extra29.pathExists(claudeMdDest)) {
+        await import_fs_extra29.copy(claudeMdSource, claudeMdDest);
         logger.success("Copied CLAUDE.md to global directory");
       } else {
         logger.debug("CLAUDE.md already exists in global directory (preserved)");
@@ -40966,7 +42629,7 @@ async function handlePostInstall(ctx) {
   }
   if (!ctx.options.skipSetup) {
     await promptSetupWizardIfNeeded({
-      envPath: join65(ctx.claudeDir, ".env"),
+      envPath: join66(ctx.claudeDir, ".env"),
       claudeDir: ctx.claudeDir,
       isGlobal: ctx.options.global,
       isNonInteractive: ctx.isNonInteractive,
@@ -40980,7 +42643,7 @@ async function handlePostInstall(ctx) {
 }
 // src/commands/init/phases/selection-handler.ts
 import { mkdir as mkdir20 } from "node:fs/promises";
-import { join as join67, resolve as resolve8 } from "node:path";
+import { join as join68, resolve as resolve9 } from "node:path";
 init_github_client();
 
 // src/domains/github/kit-access-checker.ts
@@ -41109,10 +42772,10 @@ async function runPreflightChecks() {
 }
 
 // src/domains/installation/fresh-installer.ts
-import { existsSync as existsSync19, readdirSync, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname9, join as join66, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync20, readdirSync as readdirSync2, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
+import { dirname as dirname10, join as join67, resolve as resolve8 } from "node:path";
 init_logger();
-var import_fs_extra29 = __toESM(require_lib(), 1);
+var import_fs_extra30 = __toESM(require_lib(), 1);
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "rules", "hooks"];
 async function analyzeFreshInstallation(claudeDir) {
   const metadata = await readManifest(claudeDir);
@@ -41156,16 +42819,16 @@ async function analyzeFreshInstallation(claudeDir) {
     hasMetadata: true
   };
 }
-function cleanupEmptyDirectories(filePath, claudeDir) {
-  const normalizedClaudeDir = resolve7(claudeDir);
-  let currentDir = resolve7(dirname9(filePath));
+function cleanupEmptyDirectories2(filePath, claudeDir) {
+  const normalizedClaudeDir = resolve8(claudeDir);
+  let currentDir = resolve8(dirname10(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
-      const entries = readdirSync(currentDir);
+      const entries = readdirSync2(currentDir);
       if (entries.length === 0) {
-        rmdirSync(currentDir);
+        rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve7(dirname9(currentDir));
+        currentDir = resolve8(dirname10(currentDir));
       } else {
         break;
       }
@@ -41182,13 +42845,13 @@ async function removeFilesByOwnership(claudeDir, analysis, includeModified) {
   const filesToRemove = includeModified ? [...analysis.ckFiles, ...analysis.ckModifiedFiles] : analysis.ckFiles;
   const filesToPreserve = includeModified ? analysis.userFiles : [...analysis.ckModifiedFiles, ...analysis.userFiles];
   for (const file of filesToRemove) {
-    const fullPath = join66(claudeDir, file.path);
+    const fullPath = join67(claudeDir, file.path);
     try {
-      if (existsSync19(fullPath)) {
-        unlinkSync3(fullPath);
+      if (existsSync20(fullPath)) {
+        unlinkSync4(fullPath);
         removedFiles.push(file.path);
         logger.debug(`Removed: ${file.path}`);
-        cleanupEmptyDirectories(fullPath, claudeDir);
+        cleanupEmptyDirectories2(fullPath, claudeDir);
       }
     } catch (error) {
       logger.debug(`Failed to remove ${file.path}: ${error}`);
@@ -41207,13 +42870,13 @@ async function removeFilesByOwnership(claudeDir, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir, removedFiles) {
-  const metadataPath = join66(claudeDir, "metadata.json");
-  if (!await import_fs_extra29.pathExists(metadataPath)) {
+  const metadataPath = join67(claudeDir, "metadata.json");
+  if (!await import_fs_extra30.pathExists(metadataPath)) {
     return;
   }
   let content;
   try {
-    content = await import_fs_extra29.readFile(metadataPath, "utf-8");
+    content = await import_fs_extra30.readFile(metadataPath, "utf-8");
   } catch (readError) {
     logger.warning(`Failed to read metadata.json: ${readError instanceof Error ? readError.message : String(readError)}`);
     return;
@@ -41239,7 +42902,7 @@ async function updateMetadataAfterFresh(claudeDir, removedFiles) {
     metadata.files = metadata.files.filter((f3) => !removedSet.has(f3.path));
   }
   try {
-    await import_fs_extra29.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    await import_fs_extra30.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
     logger.debug(`Updated metadata.json, removed ${removedFiles.length} file entries`);
   } catch (writeError) {
     logger.warning(`Failed to write metadata.json: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -41250,17 +42913,17 @@ async function removeSubdirectoriesFallback(claudeDir) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-    const subdirPath = join66(claudeDir, subdir);
-    if (await import_fs_extra29.pathExists(subdirPath)) {
-      rmSync2(subdirPath, { recursive: true, force: true });
+    const subdirPath = join67(claudeDir, subdir);
+    if (await import_fs_extra30.pathExists(subdirPath)) {
+      rmSync3(subdirPath, { recursive: true, force: true });
       removedDirCount++;
       removedFiles.push(`${subdir}/ (entire directory)`);
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join66(claudeDir, "metadata.json");
-  if (await import_fs_extra29.pathExists(metadataPath)) {
-    unlinkSync3(metadataPath);
+  const metadataPath = join67(claudeDir, "metadata.json");
+  if (await import_fs_extra30.pathExists(metadataPath)) {
+    unlinkSync4(metadataPath);
     removedFiles.push("metadata.json");
   }
   return {
@@ -41272,7 +42935,7 @@ async function removeSubdirectoriesFallback(claudeDir) {
   };
 }
 async function handleFreshInstallation(claudeDir, prompts) {
-  if (!await import_fs_extra29.pathExists(claudeDir)) {
+  if (!await import_fs_extra30.pathExists(claudeDir)) {
     logger.info(".claude directory does not exist, proceeding with fresh installation");
     return true;
   }
@@ -41306,7 +42969,7 @@ async function handleFreshInstallation(claudeDir, prompts) {
 init_logger();
 init_path_resolver();
 init_types2();
-var import_fs_extra30 = __toESM(require_lib(), 1);
+var import_fs_extra31 = __toESM(require_lib(), 1);
 
 // src/commands/init/types.ts
 function isSyncContext(ctx) {
@@ -41475,7 +43138,7 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve8(targetDir);
+  const resolvedDir = resolve9(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (!ctx.options.global && PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're at HOME directory. Installing here modifies your GLOBAL ClaudeKit.");
@@ -41497,7 +43160,7 @@ async function handleSelection(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  if (!await import_fs_extra30.pathExists(resolvedDir)) {
+  if (!await import_fs_extra31.pathExists(resolvedDir)) {
     if (ctx.options.global) {
       await mkdir20(resolvedDir, { recursive: true });
       logger.info(`Created global directory: ${resolvedDir}`);
@@ -41509,7 +43172,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join67(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join68(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir);
       if (existingMetadata?.kits) {
@@ -41541,7 +43204,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join67(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join68(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -41560,7 +43223,7 @@ async function handleSelection(ctx) {
     logger.info("Fetching available versions...");
     let currentVersion = null;
     try {
-      const metadataPath = ctx.options.global ? join67(PathResolver.getGlobalKitDir(), "metadata.json") : join67(resolvedDir, ".claude", "metadata.json");
+      const metadataPath = ctx.options.global ? join68(PathResolver.getGlobalKitDir(), "metadata.json") : join68(resolvedDir, ".claude", "metadata.json");
       const metadata = await readClaudeKitMetadata(metadataPath);
       currentVersion = metadata?.version || null;
       if (currentVersion) {
@@ -41634,25 +43297,25 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname10, join as join68, resolve as resolve9 } from "node:path";
+import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile21 } from "node:fs/promises";
+import { dirname as dirname11, join as join69, resolve as resolve10 } from "node:path";
 init_logger();
 init_path_resolver();
-var import_fs_extra31 = __toESM(require_lib(), 1);
+var import_fs_extra32 = __toESM(require_lib(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
 async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve9(ctx.options.dir || ".");
-  const claudeDir = ctx.options.global ? resolvedDir : join68(resolvedDir, ".claude");
-  if (!await import_fs_extra31.pathExists(claudeDir)) {
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve10(ctx.options.dir || ".");
+  const claudeDir = ctx.options.global ? resolvedDir : join69(resolvedDir, ".claude");
+  if (!await import_fs_extra32.pathExists(claudeDir)) {
     logger.error("Cannot sync: no .claude directory found");
     ctx.prompts.note("Run 'ck init' without --sync to install first.", "No Installation Found");
     return { ...ctx, cancelled: true };
   }
-  const metadataPath = join68(claudeDir, "metadata.json");
-  if (!await import_fs_extra31.pathExists(metadataPath)) {
+  const metadataPath = join69(claudeDir, "metadata.json");
+  if (!await import_fs_extra32.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
 Run 'ck init' to update.`, "Legacy Installation");
@@ -41751,10 +43414,10 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join68(cacheDir, ".sync-lock");
+  const lockPath = join69(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir21(dirname10(lockPath), { recursive: true });
+  await mkdir21(dirname11(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open(lockPath, "wx");
@@ -41778,7 +43441,7 @@ async function acquireSyncLock(global3) {
           }
           logger.debug(`Lock stat failed: ${statError}`);
         }
-        await new Promise((resolve10) => setTimeout(resolve10, 100));
+        await new Promise((resolve11) => setTimeout(resolve11, 100));
         continue;
       }
       throw err;
@@ -41797,7 +43460,7 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join68(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join69(ctx.extractDir, ".claude") : ctx.extractDir;
     logger.info("Analyzing file changes...");
     const plan = await SyncEngine.createSyncPlan(trackedFiles, ctx.claudeDir, upstreamDir);
     displaySyncPlan(plan);
@@ -41816,7 +43479,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join68(targetPath, "..");
+          const targetDir = join69(targetPath, "..");
           try {
             await mkdir21(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -41897,7 +43560,7 @@ async function executeSyncMerge(ctx) {
         try {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
-            await writeFile20(tempPath, result.result, "utf-8");
+            await writeFile21(tempPath, result.result, "utf-8");
             await rename3(tempPath, currentPath);
           } catch (atomicError) {
             await unlink7(tempPath).catch(() => {});
@@ -41985,9 +43648,9 @@ async function createBackup(claudeDir, files, backupDir) {
   for (const file of files) {
     try {
       const sourcePath = await validateSyncPath(claudeDir, file.path);
-      if (await import_fs_extra31.pathExists(sourcePath)) {
+      if (await import_fs_extra32.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join68(targetPath, "..");
+        const targetDir = join69(targetPath, "..");
         await mkdir21(targetDir, { recursive: true });
         await copyFile6(sourcePath, targetPath);
       }
@@ -42001,7 +43664,7 @@ async function createBackup(claudeDir, files, backupDir) {
   }
 }
 // src/commands/init/phases/transform-handler.ts
-import { join as join72 } from "node:path";
+import { join as join73 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -42010,40 +43673,40 @@ init_types2();
 // src/services/transformers/folder-transform/folder-renamer.ts
 init_logger();
 init_types2();
-var import_fs_extra32 = __toESM(require_lib(), 1);
+var import_fs_extra33 = __toESM(require_lib(), 1);
 import { rename as rename4, rm as rm7 } from "node:fs/promises";
-import { join as join69, relative as relative12 } from "node:path";
+import { join as join70, relative as relative13 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join69(extractDir, DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra32.pathExists(docsPath)) {
+    const docsPath = join70(extractDir, DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra33.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join69(extractDir, folders.docs)
+        to: join70(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join69(extractDir, ".claude", DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra32.pathExists(claudeDocsPath)) {
+    const claudeDocsPath = join70(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra33.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join69(extractDir, ".claude", folders.docs)
+        to: join70(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join69(extractDir, DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra32.pathExists(plansPath)) {
+    const plansPath = join70(extractDir, DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra33.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join69(extractDir, folders.plans)
+        to: join70(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join69(extractDir, ".claude", DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra32.pathExists(claudePlansPath)) {
+    const claudePlansPath = join70(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra33.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join69(extractDir, ".claude", folders.plans)
+        to: join70(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -42055,7 +43718,7 @@ async function moveAcrossDevices(src, dest) {
   } catch (e2) {
     if (e2.code === "EXDEV") {
       logger.debug(`Cross-device move detected, using copy+delete: ${src} -> ${dest}`);
-      await import_fs_extra32.copy(src, dest, { overwrite: true });
+      await import_fs_extra33.copy(src, dest, { overwrite: true });
       await rm7(src, { recursive: true, force: true });
     } else {
       throw e2;
@@ -42066,11 +43729,11 @@ async function renameFolders(dirsToRename, extractDir, options) {
   let foldersRenamed = 0;
   for (const { from, to } of dirsToRename) {
     if (options.dryRun) {
-      logger.info(`[dry-run] Would rename: ${relative12(extractDir, from)} -> ${relative12(extractDir, to)}`);
+      logger.info(`[dry-run] Would rename: ${relative13(extractDir, from)} -> ${relative13(extractDir, to)}`);
     } else {
       try {
         await moveAcrossDevices(from, to);
-        logger.debug(`Renamed: ${relative12(extractDir, from)} -> ${relative12(extractDir, to)}`);
+        logger.debug(`Renamed: ${relative13(extractDir, from)} -> ${relative13(extractDir, to)}`);
         foldersRenamed++;
       } catch (error) {
         logger.warning(`Failed to rename ${from}: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -42083,8 +43746,8 @@ async function renameFolders(dirsToRename, extractDir, options) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types2();
-import { readFile as readFile24, readdir as readdir23, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join70, relative as relative13 } from "node:path";
+import { readFile as readFile26, readdir as readdir23, writeFile as writeFile22 } from "node:fs/promises";
+import { join as join71, relative as relative14 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -42137,7 +43800,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
   let replacementsCount = 0;
   const entries = await readdir23(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join70(dir, entry.name);
+    const fullPath = join71(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -42150,7 +43813,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile24(fullPath, "utf-8");
+        const content = await readFile26(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -42164,10 +43827,10 @@ async function transformFileContents(dir, compiledReplacements, options) {
         }
         if (changeCount > 0) {
           if (options.dryRun) {
-            logger.debug(`[dry-run] Would update ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
+            logger.debug(`[dry-run] Would update ${relative14(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile21(fullPath, newContent, "utf-8");
-            logger.debug(`Updated ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
+            await writeFile22(fullPath, newContent, "utf-8");
+            logger.debug(`Updated ${relative14(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
           replacementsCount += changeCount;
@@ -42272,9 +43935,9 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile25, readdir as readdir24, writeFile as writeFile22 } from "node:fs/promises";
+import { readFile as readFile27, readdir as readdir24, writeFile as writeFile23 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
-import { extname as extname3, join as join71 } from "node:path";
+import { extname as extname3, join as join72 } from "node:path";
 var IS_WINDOWS4 = platform12() === "win32";
 var HOME_PREFIX = IS_WINDOWS4 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
@@ -42384,7 +44047,7 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir24(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join71(dir, entry.name);
+      const fullPath = join72(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -42392,10 +44055,10 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
         await processDirectory2(fullPath);
       } else if (entry.isFile() && shouldTransformFile3(entry.name)) {
         try {
-          const content = await readFile25(fullPath, "utf-8");
+          const content = await readFile27(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile22(fullPath, transformed, "utf-8");
+            await writeFile23(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -42460,7 +44123,7 @@ async function handleTransforms(ctx) {
       logger.debug(ctx.options.global ? "Saved folder configuration to ~/.claude/.ck.json" : "Saved folder configuration to .claude/.ck.json");
     }
   }
-  const claudeDir = ctx.options.global ? ctx.resolvedDir : join72(ctx.resolvedDir, ".claude");
+  const claudeDir = ctx.options.global ? ctx.resolvedDir : join73(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -42650,11 +44313,11 @@ init_types2();
 var import_picocolors20 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types2();
-var import_fs_extra33 = __toESM(require_lib(), 1);
+var import_fs_extra34 = __toESM(require_lib(), 1);
 async function directorySetup(validOptions, prompts) {
   const isNonInteractive2 = !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
   const config = await ConfigManager.get();
@@ -42735,7 +44398,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve10(targetDir);
+  const resolvedDir = resolve11(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -42753,8 +44416,8 @@ async function directorySetup(validOptions, prompts) {
       return null;
     }
   }
-  if (await import_fs_extra33.pathExists(resolvedDir)) {
-    const files = await import_fs_extra33.readdir(resolvedDir);
+  if (await import_fs_extra34.pathExists(resolvedDir)) {
+    const files = await import_fs_extra34.readdir(resolvedDir);
     const isEmpty = files.length === 0;
     if (!isEmpty) {
       if (isNonInteractive2) {
@@ -42790,7 +44453,7 @@ async function handleDirectorySetup(ctx) {
   };
 }
 // src/commands/new/phases/project-creation.ts
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 init_github_client();
 init_logger();
 init_output_manager();
@@ -42917,7 +44580,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir = join73(resolvedDir, ".claude");
+  const claudeDir = join74(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -42963,7 +44626,7 @@ async function handleProjectCreation(ctx) {
   };
 }
 // src/commands/new/phases/post-setup.ts
-import { join as join74 } from "node:path";
+import { join as join75 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
@@ -42995,9 +44658,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir = join74(resolvedDir, ".claude");
+  const claudeDir = join75(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join74(claudeDir, ".env"),
+    envPath: join75(claudeDir, ".env"),
     claudeDir,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -43066,7 +44729,7 @@ var import_picocolors22 = __toESM(require_picocolors(), 1);
 
 // src/commands/uninstall/installation-detector.ts
 init_path_resolver();
-var import_fs_extra34 = __toESM(require_lib(), 1);
+var import_fs_extra35 = __toESM(require_lib(), 1);
 async function detectInstallations() {
   const installations = [];
   const setup = await getClaudeKitSetup(process.cwd());
@@ -43075,28 +44738,28 @@ async function detectInstallations() {
     installations.push({
       type: "local",
       path: setup.project.path,
-      exists: await import_fs_extra34.pathExists(setup.project.path)
+      exists: await import_fs_extra35.pathExists(setup.project.path)
     });
   }
   if (setup.global.path && setup.global.metadata) {
     installations.push({
       type: "global",
       path: setup.global.path,
-      exists: await import_fs_extra34.pathExists(setup.global.path)
+      exists: await import_fs_extra35.pathExists(setup.global.path)
     });
   }
   return installations.filter((i) => i.exists);
 }
 
 // src/commands/uninstall/removal-handler.ts
-import { readdirSync as readdirSync3, rmSync as rmSync4 } from "node:fs";
-import { join as join76 } from "node:path";
+import { readdirSync as readdirSync4, rmSync as rmSync5 } from "node:fs";
+import { join as join77 } from "node:path";
 init_logger();
-var import_fs_extra35 = __toESM(require_lib(), 1);
+var import_fs_extra36 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
-import { readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
-import { dirname as dirname11, join as join75 } from "node:path";
+import { readdirSync as readdirSync3, rmSync as rmSync4 } from "node:fs";
+import { dirname as dirname12, join as join76 } from "node:path";
 init_logger();
 var import_picocolors21 = __toESM(require_picocolors(), 1);
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
@@ -43111,17 +44774,17 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
   }
   return { action: "preserve", reason: "user-created" };
 }
-async function cleanupEmptyDirectories2(filePath, installationRoot) {
+async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname11(filePath);
+  let currentDir = dirname12(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
-      const entries = readdirSync2(currentDir);
+      const entries = readdirSync3(currentDir);
       if (entries.length === 0) {
-        rmSync3(currentDir, { recursive: true });
+        rmSync4(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname11(currentDir);
+        currentDir = dirname12(currentDir);
       } else {
         break;
       }
@@ -43143,7 +44806,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join75(installation.path, trackedFile.path);
+      const filePath = join76(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -43173,7 +44836,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join75(installation.path, trackedFile.path);
+    const filePath = join76(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -43233,21 +44896,21 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join76(installation.path, item.path);
-        if (await import_fs_extra35.pathExists(filePath)) {
-          await import_fs_extra35.remove(filePath);
+        const filePath = join77(installation.path, item.path);
+        if (await import_fs_extra36.pathExists(filePath)) {
+          await import_fs_extra36.remove(filePath);
           removedCount++;
           logger.debug(`Removed: ${item.path}`);
-          cleanedDirs += await cleanupEmptyDirectories2(filePath, installation.path);
+          cleanedDirs += await cleanupEmptyDirectories3(filePath, installation.path);
         }
       }
       if (options.kit && analysis.remainingKits.length > 0) {
         await ManifestWriter.removeKitFromManifest(installation.path, options.kit);
       }
       try {
-        const remaining = readdirSync3(installation.path);
+        const remaining = readdirSync4(installation.path);
         if (remaining.length === 0) {
-          rmSync4(installation.path, { recursive: true });
+          rmSync5(installation.path, { recursive: true });
           logger.debug(`Removed empty installation directory: ${installation.path}`);
         }
       } catch {}
@@ -43404,7 +45067,7 @@ ${import_picocolors22.default.yellow("User modifications will be permanently del
 }
 // src/commands/update-cli.ts
 import { exec as exec8 } from "node:child_process";
-import { join as join77 } from "node:path";
+import { join as join78 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 
 // src/domains/github/npm-registry.ts
@@ -43475,19 +45138,22 @@ class NpmRegistryClient {
     }
   }
   static async getBetaVersion(packageName, registryUrl) {
+    return NpmRegistryClient.getDevVersion(packageName, registryUrl);
+  }
+  static async getDevVersion(packageName, registryUrl) {
     try {
       const info = await NpmRegistryClient.getPackageInfo(packageName, registryUrl);
       if (!info)
         return null;
-      const betaVersion = info["dist-tags"]?.beta || info["dist-tags"]?.next;
-      if (!betaVersion) {
-        logger.debug(`No beta version found for ${packageName}`);
+      const devVersion = info["dist-tags"]?.dev || info["dist-tags"]?.beta || info["dist-tags"]?.next;
+      if (!devVersion) {
+        logger.debug(`No dev version found for ${packageName}`);
         return null;
       }
-      return betaVersion;
+      return devVersion;
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      logger.debug(`Failed to get beta version for ${packageName}: ${message}`);
+      logger.debug(`Failed to get dev version for ${packageName}: ${message}`);
       return null;
     }
   }
@@ -43547,11 +45213,11 @@ init_logger();
 init_types2();
 init_types2();
 var import_compare_versions3 = __toESM(require_umd(), 1);
-var import_fs_extra36 = __toESM(require_lib(), 1);
+var import_fs_extra37 = __toESM(require_lib(), 1);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.30.3",
+  version: "3.31.0-dev.2",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -43617,6 +45283,7 @@ var package_default = {
     ora: "^8.0.0",
     "p-limit": "^7.2.0",
     picocolors: "^1.1.1",
+    picomatch: "^4.0.3",
     "proper-lockfile": "^4.1.2",
     semver: "^7.7.3",
     tar: "^7.4.3",
@@ -43632,6 +45299,7 @@ var package_default = {
     "@types/diff": "^8.0.0",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.10.1",
+    "@types/picomatch": "^4.0.2",
     "@types/proper-lockfile": "^4.1.4",
     "@types/semver": "^7.7.1",
     "@types/tar": "^6.1.13",
@@ -43665,7 +45333,7 @@ function buildInitCommand(isGlobal, kit, beta) {
 function isBetaVersion(version) {
   if (!version)
     return false;
-  return /-(beta|alpha|rc)[.\d]/i.test(version);
+  return /-(beta|alpha|rc|dev)[.\d]/i.test(version);
 }
 function selectKitForUpdate(params) {
   const { hasLocal, hasGlobal, localKits, globalKits } = params;
@@ -43698,12 +45366,12 @@ function selectKitForUpdate(params) {
   };
 }
 async function readMetadataFile(claudeDir) {
-  const metadataPath = join77(claudeDir, "metadata.json");
+  const metadataPath = join78(claudeDir, "metadata.json");
   try {
-    if (!await import_fs_extra36.pathExists(metadataPath)) {
+    if (!await import_fs_extra37.pathExists(metadataPath)) {
       return null;
     }
-    const content = await import_fs_extra36.readFile(metadataPath, "utf-8");
+    const content = await import_fs_extra37.readFile(metadataPath, "utf-8");
     const parsed = JSON.parse(content);
     const validated = MetadataSchema.safeParse(parsed);
     if (!validated.success) {
@@ -43786,14 +45454,14 @@ async function updateCliCommand(options) {
       }
       targetVersion = opts.release;
       s.stop(`Target version: ${targetVersion}`);
-    } else if (opts.beta) {
-      targetVersion = await NpmRegistryClient.getBetaVersion(PACKAGE_NAME, opts.registry);
+    } else if (opts.dev || opts.beta) {
+      targetVersion = await NpmRegistryClient.getDevVersion(PACKAGE_NAME, opts.registry);
       if (!targetVersion) {
-        s.stop("No beta version available");
-        logger.warning("No beta version found. Using latest stable version instead.");
+        s.stop("No dev version available");
+        logger.warning("No dev version found. Using latest stable version instead.");
         targetVersion = await NpmRegistryClient.getLatestVersion(PACKAGE_NAME, opts.registry);
       } else {
-        s.stop(`Latest beta version: ${targetVersion}`);
+        s.stop(`Latest dev version: ${targetVersion}`);
       }
     } else {
       targetVersion = await NpmRegistryClient.getLatestVersion(PACKAGE_NAME, opts.registry);
@@ -43805,7 +45473,7 @@ async function updateCliCommand(options) {
     const comparison = import_compare_versions3.compareVersions(currentVersion, targetVersion);
     if (comparison === 0) {
       outro(`[+] Already on the latest CLI version (${currentVersion})`);
-      await promptKitUpdate(opts.beta);
+      await promptKitUpdate(opts.dev || opts.beta);
       return;
     }
     if (comparison > 0 && !opts.release) {
@@ -43819,7 +45487,7 @@ async function updateCliCommand(options) {
       note(`CLI update available: ${currentVersion} -> ${targetVersion}
 
 Run 'ck update' to install`, "Update Check");
-      await promptKitUpdate(opts.beta);
+      await promptKitUpdate(opts.dev || opts.beta);
       outro("Check complete");
       return;
     }
@@ -43859,11 +45527,11 @@ Manual update: ${updateCmd}`);
       const newVersion = newVersionMatch ? newVersionMatch[1] : targetVersion;
       s.stop(`Installed version: ${newVersion}`);
       outro(`[+] Successfully updated ClaudeKit CLI to ${newVersion}`);
-      await promptKitUpdate(opts.beta);
+      await promptKitUpdate(opts.dev || opts.beta);
     } catch {
       s.stop("Verification completed");
       outro(`[+] Update completed. Please restart your terminal to use CLI ${targetVersion}`);
-      await promptKitUpdate(opts.beta);
+      await promptKitUpdate(opts.dev || opts.beta);
     }
   } catch (error) {
     if (error instanceof CliUpdateError) {
@@ -43991,7 +45659,7 @@ function registerCommands(cli) {
     }
     await initCommand(options);
   });
-  cli.command("update", "Update ClaudeKit CLI to the latest version").option("-r, --release <version>", "Update to a specific version").option("--check", "Check for updates without installing").option("-y, --yes", "Non-interactive mode with sensible defaults (skip all prompts)").option("--beta", "Update to the latest beta version").option("--registry <url>", "Custom npm registry URL").option("--kit <kit>", "[DEPRECATED] Use 'ck init --kit <kit>' instead").option("-g, --global", "[DEPRECATED] Use 'ck init --global' instead").action(async (options) => {
+  cli.command("update", "Update ClaudeKit CLI to the latest version").option("-r, --release <version>", "Update to a specific version").option("--check", "Check for updates without installing").option("-y, --yes", "Non-interactive mode with sensible defaults (skip all prompts)").option("-d, --dev", "Update to the latest dev version").option("--beta", "Alias for --dev (deprecated)").option("--registry <url>", "Custom npm registry URL").option("--kit <kit>", "[DEPRECATED] Use 'ck init --kit <kit>' instead").option("-g, --global", "[DEPRECATED] Use 'ck init --global' instead").action(async (options) => {
     if (options.kit || options.global) {
       console.log();
       const deprecatedFlags = [options.kit && "--kit", options.global && "--global"].filter(Boolean).join(" and ");
@@ -44030,8 +45698,8 @@ function registerCommands(cli) {
 }
 
 // src/cli/version-display.ts
-import { existsSync as existsSync21, readFileSync as readFileSync7 } from "node:fs";
-import { join as join79 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync7 } from "node:fs";
+import { join as join80 } from "node:path";
 
 // src/domains/versioning/checking/version-utils.ts
 var import_compare_versions4 = __toESM(require_umd(), 1);
@@ -44058,25 +45726,25 @@ init_types2();
 // src/domains/versioning/version-cache.ts
 init_logger();
 init_path_resolver();
-import { existsSync as existsSync20 } from "node:fs";
-import { mkdir as mkdir22, readFile as readFile27, writeFile as writeFile23 } from "node:fs/promises";
-import { join as join78 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { mkdir as mkdir22, readFile as readFile29, writeFile as writeFile24 } from "node:fs/promises";
+import { join as join79 } from "node:path";
 
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join78(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join79(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (!existsSync20(cacheFile)) {
+      if (!existsSync21(cacheFile)) {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile27(cacheFile, "utf-8");
+      const content = await readFile29(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -44093,10 +45761,10 @@ class VersionCacheManager {
     const cacheFile = VersionCacheManager.getCacheFile();
     const cacheDir = PathResolver.getCacheDir(false);
     try {
-      if (!existsSync20(cacheDir)) {
+      if (!existsSync21(cacheDir)) {
         await mkdir22(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile23(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile24(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -44115,7 +45783,7 @@ class VersionCacheManager {
   static async clear() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (existsSync20(cacheFile)) {
+      if (existsSync21(cacheFile)) {
         const fs14 = await import("node:fs/promises");
         await fs14.unlink(cacheFile);
         logger.debug("Version check cache cleared");
@@ -44335,11 +46003,11 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join79(globalKitDir, "metadata.json");
+  const globalMetadataPath = join80(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join79(process.cwd(), prefix, "metadata.json") : join79(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join80(process.cwd(), prefix, "metadata.json") : join80(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
-  if (!isLocalSameAsGlobal && existsSync21(localMetadataPath)) {
+  if (!isLocalSameAsGlobal && existsSync22(localMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync7(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
@@ -44353,7 +46021,7 @@ async function displayVersion() {
       logger.verbose("Failed to parse local metadata.json", { error });
     }
   }
-  if (existsSync21(globalMetadataPath)) {
+  if (existsSync22(globalMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync7(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);