@ccpluginizer/ccpluginizer 0.5.1 → 0.6.0

package/dist/index.js

@@ -899,8 +899,523 @@ class R2 {
   }
 }
 
+// ../../node_modules/.bun/@crustjs+style@0.1.0+7524df1edfed9f02/node_modules/@crustjs/style/dist/index.js
+var rF = Object.defineProperty;
+var sF = (F3) => F3;
+function aF(F3, Y) {
+  this[F3] = sF.bind(null, Y);
+}
+var oF = (F3, Y) => {
+  for (var B3 in Y)
+    rF(F3, B3, { get: Y[B3], enumerable: true, configurable: true, set: aF.bind(Y, B3) });
+};
+var E2 = {};
+oF(E2, { yellow: () => o, white: () => FF, underline: () => c, strikethrough: () => d, reset: () => p, red: () => s, magenta: () => t, italic: () => h4, inverse: () => n, hidden: () => l, green: () => a, gray: () => BF, dim: () => m, cyan: () => e, brightYellow: () => ZF, brightWhite: () => JF, brightRed: () => YF, brightMagenta: () => zF, brightGreen: () => VF, brightCyan: () => QF, brightBlue: () => $F, bold: () => u, blue: () => i, black: () => r, bgYellow: () => GF, bgWhite: () => OF, bgRed: () => KF, bgMagenta: () => HF, bgGreen: () => jF, bgCyan: () => _F, bgBrightYellow: () => AF, bgBrightWhite: () => TF, bgBrightRed: () => qF, bgBrightMagenta: () => MF, bgBrightGreen: () => RF, bgBrightCyan: () => IF, bgBrightBlue: () => LF, bgBrightBlack: () => DF, bgBlue: () => UF, bgBlack: () => XF });
+function J(F3, Y) {
+  return { open: `\x1B[${F3}m`, close: `\x1B[${Y}m` };
+}
+var p = J(0, 0);
+var u = J(1, 22);
+var m = J(2, 22);
+var h4 = J(3, 23);
+var c = J(4, 24);
+var n = J(7, 27);
+var l = J(8, 28);
+var d = J(9, 29);
+var r = J(30, 39);
+var s = J(31, 39);
+var a = J(32, 39);
+var o = J(33, 39);
+var i = J(34, 39);
+var t = J(35, 39);
+var e = J(36, 39);
+var FF = J(37, 39);
+var BF = J(90, 39);
+var YF = J(91, 39);
+var VF = J(92, 39);
+var ZF = J(93, 39);
+var $F = J(94, 39);
+var zF = J(95, 39);
+var QF = J(96, 39);
+var JF = J(97, 39);
+var XF = J(40, 49);
+var KF = J(41, 49);
+var jF = J(42, 49);
+var GF = J(43, 49);
+var UF = J(44, 49);
+var HF = J(45, 49);
+var _F = J(46, 49);
+var OF = J(47, 49);
+var DF = J(100, 49);
+var qF = J(101, 49);
+var RF = J(102, 49);
+var AF = J(103, 49);
+var LF = J(104, 49);
+var MF = J(105, 49);
+var IF = J(106, 49);
+var TF = J(107, 49);
+function iF(F3) {
+  return F3 >= 19968 && F3 <= 40959 || F3 >= 13312 && F3 <= 19903 || F3 >= 131072 && F3 <= 173791 || F3 >= 63744 && F3 <= 64255 || F3 >= 65281 && F3 <= 65376 || F3 >= 65504 && F3 <= 65510 || F3 >= 11904 && F3 <= 12031 || F3 >= 12032 && F3 <= 12255 || F3 >= 12288 && F3 <= 12351 || F3 >= 12352 && F3 <= 12447 || F3 >= 12448 && F3 <= 12543 || F3 >= 12544 && F3 <= 12591 || F3 >= 12592 && F3 <= 12687 || F3 >= 12800 && F3 <= 13055 || F3 >= 13056 && F3 <= 13311 || F3 >= 44032 && F3 <= 55215 || F3 >= 65072 && F3 <= 65103;
+}
+function O2(F3) {
+  let Y = Bun.stripANSI(F3), B3 = 0;
+  for (let V of Y) {
+    let Z = V.codePointAt(0);
+    if (Z === undefined)
+      continue;
+    B3 += iF(Z) ? 2 : 1;
+  }
+  return B3;
+}
+function M3(F3, Y) {
+  if (F3 === "always")
+    return true;
+  if (F3 === "never")
+    return false;
+  let V = Y !== undefined && "isTTY" in Y ? Y.isTTY ?? false : process.stdout?.isTTY ?? false, z3 = Y !== undefined && "noColor" in Y ? Y.noColor : process.env.NO_COLOR;
+  if (z3 !== undefined && z3 !== "")
+    return false;
+  return V;
+}
+function NF(F3, Y) {
+  if (F3 === "always")
+    return true;
+  if (F3 === "never")
+    return false;
+  return Y !== undefined && "isTTY" in Y ? Y.isTTY ?? false : process.stdout?.isTTY ?? false;
+}
+function kF(F3, Y) {
+  if (F3 === "always")
+    return true;
+  if (F3 === "never")
+    return false;
+  return Y !== undefined && "isTTY" in Y ? Y.isTTY ?? false : process.stdout?.isTTY ?? false;
+}
+function S2(F3, Y) {
+  if (F3 === "always")
+    return true;
+  if (F3 === "never")
+    return false;
+  if (!M3(F3, Y))
+    return false;
+  let Z = (Y !== undefined && "colorTerm" in Y ? Y.colorTerm : process.env.COLORTERM)?.toLowerCase();
+  if (Z === "truecolor" || Z === "24bit")
+    return true;
+  let $ = Y !== undefined && "term" in Y ? Y.term : process.env.TERM;
+  if ($ !== undefined) {
+    let K = $.toLowerCase();
+    if (K.includes("24bit") || K.includes("truecolor") || K.endsWith("-direct"))
+      return true;
+  }
+  return false;
+}
+function D3(F3, Y) {
+  if (F3 === "")
+    return "";
+  let { open: B3, close: V } = Y;
+  if (F3.includes(V))
+    F3 = F3.replaceAll(V, V + B3);
+  return B3 + F3 + V;
+}
+function f(F3, Y) {
+  if (!Number.isInteger(F3) || F3 < 0 || F3 > 255)
+    throw RangeError(`Invalid ${Y} value: ${String(F3)}. Must be an integer between 0 and 255.`);
+}
+function gF(F3, Y, B3) {
+  f(F3, "red"), f(Y, "green"), f(B3, "blue");
+}
+var zB = /^#([0-9a-f]{3})$/i;
+var QB = /^#([0-9a-f]{6})$/i;
+function y3(F3) {
+  let Y = zB.exec(F3);
+  if (Y) {
+    let V = Y[1], Z = V.charAt(0), z3 = V.charAt(1), $ = V.charAt(2);
+    return [Number.parseInt(Z + Z, 16), Number.parseInt(z3 + z3, 16), Number.parseInt($ + $, 16)];
+  }
+  let B3 = QB.exec(F3);
+  if (B3) {
+    let V = B3[1];
+    return [Number.parseInt(V.slice(0, 2), 16), Number.parseInt(V.slice(2, 4), 16), Number.parseInt(V.slice(4, 6), 16)];
+  }
+  throw TypeError(`Invalid hex color: "${F3}". Expected format: "#RGB" or "#RRGGBB".`);
+}
+function w3(F3, Y, B3) {
+  return gF(F3, Y, B3), { open: `\x1B[38;2;${F3};${Y};${B3}m`, close: "\x1B[39m" };
+}
+function C(F3, Y, B3) {
+  return gF(F3, Y, B3), { open: `\x1B[48;2;${F3};${Y};${B3}m`, close: "\x1B[49m" };
+}
+function WF(F3) {
+  let [Y, B3, V] = y3(F3);
+  return w3(Y, B3, V);
+}
+function SF(F3) {
+  let [Y, B3, V] = y3(F3);
+  return C(Y, B3, V);
+}
+function fF(F3, Y, B3, V) {
+  return D3(F3, w3(Y, B3, V));
+}
+function yF(F3, Y, B3, V) {
+  return D3(F3, C(Y, B3, V));
+}
+function wF(F3, Y) {
+  return D3(F3, WF(Y));
+}
+function CF(F3, Y) {
+  return D3(F3, SF(Y));
+}
+var xF = "\x1B]";
+var bF = "\x1B\\";
+var JB = `${xF}8;;${bF}`;
+var XB = /^[\x20-\x7e]*$/;
+var KB = /^[\x21-\x7e]*$/;
+function jB(F3, Y) {
+  if (!XB.test(F3))
+    throw TypeError(`Invalid ${Y}: must contain only printable ASCII characters.`);
+}
+function GB(F3, Y) {
+  if (!KB.test(F3))
+    throw TypeError(`Invalid ${Y}: must contain only printable ASCII characters without spaces.`);
+}
+function UB(F3) {
+  let Y = F3?.id;
+  if (Y === undefined || Y === "")
+    return "";
+  if (jB(Y, "hyperlink id"), Y.includes(":") || Y.includes(";"))
+    throw TypeError('Invalid hyperlink id: ":" and ";" are reserved by the OSC 8 format.');
+  return `id=${Y}`;
+}
+function PF(F3, Y) {
+  GB(F3, "hyperlink URL");
+  let B3 = UB(Y);
+  return { open: `${xF}8;${B3};${F3}${bF}`, close: JB };
+}
+function vF(F3, Y, B3) {
+  return D3(F3, PF(Y, B3));
+}
+function HB() {
+  let { reset: F3, ...Y } = E2;
+  return Y;
+}
+var x3 = Object.freeze(HB());
+var I4 = Object.freeze(Object.keys(x3));
+function pF(F3) {
+  return x3[F3];
+}
+var uF = Object.freeze(["bold", "dim", "italic", "underline", "inverse", "hidden", "strikethrough"]);
+var _B = new Set(uF);
+function mF(F3) {
+  return _B.has(F3);
+}
+var OB = new Set(uF.map((F3) => x3[F3]));
+function hF(F3) {
+  return OB.has(F3);
+}
+function DB(F3, Y, B3, V) {
+  if (F3 === "")
+    return F3;
+  let Z = F3;
+  for (let z3 = Y.length - 1;z3 >= 0; z3--) {
+    let $ = Y[z3];
+    if ($ === undefined)
+      continue;
+    if (mF($) ? !B3 : !V)
+      continue;
+    Z = D3(Z, pF($));
+  }
+  return Z;
+}
+function qB(F3, Y) {
+  let B3 = new Map;
+  function V(z3) {
+    return z3.join("|");
+  }
+  function Z(z3) {
+    let $ = V(z3), K = B3.get($);
+    if (K)
+      return K;
+    let j = (U2) => DB(U2, z3, F3, Y);
+    B3.set($, j);
+    for (let U2 of I4)
+      Object.defineProperty(j, U2, { configurable: false, enumerable: true, get() {
+        return Z([...z3, U2]);
+      } });
+    return Object.freeze(j);
+  }
+  return Z;
+}
+function RB(F3) {
+  let Y = {};
+  for (let B3 of I4)
+    Y[B3] = F3([B3]);
+  return Y;
+}
+function A4(F3) {
+  let Y = F3?.mode ?? "auto", B3 = NF(Y, F3?.overrides), V = M3(Y, F3?.overrides), Z = kF(Y, F3?.overrides), z3 = B3 || V, $ = S2(Y, F3?.overrides), K = qB(B3, V), j = RB(K), U2 = { enabled: z3, colorsEnabled: V, trueColorEnabled: $, apply: (X2, G) => {
+    return (hF(G) ? B3 : V) ? D3(X2, G) : X2;
+  }, link: Z ? (X2, G, _5) => vF(X2, G, _5) : (X2, G) => X2, rgb: $ ? (X2, G, _5, H) => fF(X2, G, _5, H) : (X2, G, _5, H) => X2, bgRgb: $ ? (X2, G, _5, H) => yF(X2, G, _5, H) : (X2, G, _5, H) => X2, hex: $ ? (X2, G) => wF(X2, G) : (X2, G) => X2, bgHex: $ ? (X2, G) => CF(X2, G) : (X2, G) => X2, ...j };
+  return Object.freeze(U2);
+}
+var L;
+var cF = new Map;
+function MB() {
+  if (L === "always")
+    return A4({ mode: "always" });
+  if (L === "never")
+    return A4({ mode: "auto", overrides: { isTTY: true, noColor: "1" } });
+  return A4({ mode: "auto" });
+}
+function b4() {
+  let F3 = `${L ?? "auto"}|${process.stdout?.isTTY ?? false}|${process.env.NO_COLOR ?? ""}`, Y = cF.get(F3);
+  if (Y)
+    return Y;
+  let B3 = MB();
+  return cF.set(F3, B3), B3;
+}
+var IB = ["apply", "link", "rgb", "bgRgb", "hex", "bgHex"];
+var TB = ["enabled", "colorsEnabled", "trueColorEnabled"];
+function EB() {
+  let F3 = {};
+  for (let Y of TB)
+    Object.defineProperty(F3, Y, { configurable: false, enumerable: true, get() {
+      return b4()[Y];
+    } });
+  for (let Y of IB)
+    Object.defineProperty(F3, Y, { configurable: false, enumerable: true, value: (...B3) => {
+      return b4()[Y](...B3);
+    }, writable: false });
+  for (let Y of I4)
+    Object.defineProperty(F3, Y, { configurable: false, enumerable: true, get() {
+      return b4()[Y];
+    } });
+  return Object.freeze(F3);
+}
+var Q = EB();
+var kB = (F3) => Q.red(F3);
+var gB = (F3) => Q.green(F3);
+var yB = (F3) => Q.cyan(F3);
+var ZY = (F3) => Q.bold(F3);
+var $Y = (F3) => Q.dim(F3);
+function P4(F3) {
+  return Object.freeze({ heading1: (B3) => F3.bold(F3.underline(B3)), heading2: (B3) => F3.bold(B3), heading3: (B3) => F3.bold(F3.yellow(B3)), heading4: (B3) => F3.yellow(B3), heading5: (B3) => F3.dim(F3.yellow(B3)), heading6: (B3) => F3.dim(B3), text: (B3) => B3, emphasis: (B3) => F3.italic(B3), strong: (B3) => F3.bold(B3), strongEmphasis: (B3) => F3.bold(F3.italic(B3)), strikethrough: (B3) => F3.strikethrough(B3), inlineCode: (B3) => F3.cyan(B3), linkText: (B3) => F3.blue(F3.underline(B3)), linkUrl: (B3) => F3.dim(F3.underline(B3)), autolink: (B3) => F3.blue(F3.underline(B3)), blockquoteMarker: (B3) => F3.dim(F3.green(B3)), blockquoteText: (B3) => F3.italic(B3), listMarker: (B3) => F3.dim(B3), orderedListMarker: (B3) => F3.dim(B3), taskChecked: (B3) => F3.green(B3), taskUnchecked: (B3) => F3.dim(B3), codeFence: (B3) => F3.dim(B3), codeInfo: (B3) => F3.dim(F3.italic(B3)), codeText: (B3) => F3.cyan(B3), thematicBreak: (B3) => F3.dim(B3), tableHeader: (B3) => F3.bold(B3), tableCell: (B3) => B3, tableBorder: (B3) => F3.dim(B3), imageAltText: (B3) => F3.italic(F3.magenta(B3)), imageUrl: (B3) => F3.dim(F3.underline(B3)) });
+}
+function nF(F3) {
+  let Y = A4(F3?.style), B3 = P4(Y), V = F3?.overrides;
+  if (!V)
+    return B3;
+  let Z = { heading1: V.heading1 ?? B3.heading1, heading2: V.heading2 ?? B3.heading2, heading3: V.heading3 ?? B3.heading3, heading4: V.heading4 ?? B3.heading4, heading5: V.heading5 ?? B3.heading5, heading6: V.heading6 ?? B3.heading6, text: V.text ?? B3.text, emphasis: V.emphasis ?? B3.emphasis, strong: V.strong ?? B3.strong, strongEmphasis: V.strongEmphasis ?? B3.strongEmphasis, strikethrough: V.strikethrough ?? B3.strikethrough, inlineCode: V.inlineCode ?? B3.inlineCode, linkText: V.linkText ?? B3.linkText, linkUrl: V.linkUrl ?? B3.linkUrl, autolink: V.autolink ?? B3.autolink, blockquoteMarker: V.blockquoteMarker ?? B3.blockquoteMarker, blockquoteText: V.blockquoteText ?? B3.blockquoteText, listMarker: V.listMarker ?? B3.listMarker, orderedListMarker: V.orderedListMarker ?? B3.orderedListMarker, taskChecked: V.taskChecked ?? B3.taskChecked, taskUnchecked: V.taskUnchecked ?? B3.taskUnchecked, codeFence: V.codeFence ?? B3.codeFence, codeInfo: V.codeInfo ?? B3.codeInfo, codeText: V.codeText ?? B3.codeText, thematicBreak: V.thematicBreak ?? B3.thematicBreak, tableHeader: V.tableHeader ?? B3.tableHeader, tableCell: V.tableCell ?? B3.tableCell, tableBorder: V.tableBorder ?? B3.tableBorder, imageAltText: V.imageAltText ?? B3.imageAltText, imageUrl: V.imageUrl ?? B3.imageUrl };
+  return Object.freeze(Z);
+}
+var MY = nF();
+
+// ../../node_modules/.bun/@crustjs+prompts@0.0.13+7524df1edfed9f02/node_modules/@crustjs/prompts/dist/index.js
+import * as QJ from "readline";
+
+// ../../node_modules/.bun/@crustjs+progress@0.0.3+7524df1edfed9f02/node_modules/@crustjs/progress/dist/index.js
+var Q2 = "\x1B[";
+var N3 = `${Q2}?25l`;
+var J2 = `${Q2}?25h`;
+var V = `${Q2}2K`;
+
+// ../../node_modules/.bun/@crustjs+prompts@0.0.13+7524df1edfed9f02/node_modules/@crustjs/prompts/dist/index.js
+var b5 = { prefix: yB, message: ZY, placeholder: $Y, cursor: yB, selected: yB, unselected: $Y, error: kB, success: gB, hint: $Y, filterMatch: yB };
+var h5;
+function w4(J3) {
+  if (!h5 && !J3)
+    return b5;
+  return { ...b5, ...h5, ...J3 };
+}
+var i2 = Symbol("submit");
+function M4(J3) {
+  return { [i2]: J3 };
+}
+var o2 = false;
+var u2 = "\x1B[";
+var zJ = `${u2}?25l`;
+var NJ = `${u2}?25h`;
+var qJ = `${u2}2K`;
+function e2(J3) {
+  return J3 > 0 ? `${u2}${J3}A` : "";
+}
+function JJ(J3, Q3) {
+  let Z = J3.split(`
+`), W2 = 0;
+  for (let G of Z) {
+    let $ = O2(G);
+    W2 += $ === 0 ? 1 : Math.ceil($ / Q3);
+  }
+  return W2;
+}
+
+class a2 extends Error {
+  constructor(J3) {
+    super(J3 ?? "Prompts require an interactive terminal (TTY).");
+    this.name = "NonInteractiveError";
+  }
+}
+
+class s2 extends Error {
+  constructor(J3) {
+    super(J3 ?? "Prompt was cancelled.");
+    this.name = "CancelledError";
+  }
+}
+function _5() {
+  return !!process.stdin.isTTY;
+}
+function ZJ() {
+  if (!_5())
+    throw new a2;
+}
+function HJ(J3) {
+  return typeof J3 === "object" && J3 !== null && i2 in J3;
+}
+function D4(J3) {
+  let { render: Q3, handleKey: Z, initialState: W2, theme: G, renderSubmitted: $ } = J3;
+  return new Promise((K, Y) => {
+    if (o2) {
+      Y(Error("Cannot run multiple prompts concurrently. Await each prompt before starting the next."));
+      return;
+    }
+    try {
+      ZJ();
+    } catch (U2) {
+      Y(U2);
+      return;
+    }
+    o2 = true;
+    let j = W2, X2 = 0, F3 = false, B3 = process.stdin, z3 = process.stderr;
+    function N4() {
+      if (F3)
+        return;
+      if (F3 = true, o2 = false, B3.removeListener("keypress", x4), B3.isTTY && B3.isRaw)
+        B3.setRawMode(false);
+      B3.pause(), z3.write(NJ);
+    }
+    function H(U2) {
+      let T3 = z3.columns || 80;
+      if (X2 > 0) {
+        z3.write(`${e2(X2 - 1)}\r`);
+        for (let p2 = 0;p2 < X2; p2++)
+          if (z3.write(qJ), p2 < X2 - 1)
+            z3.write(`${u2}1B`);
+        if (X2 > 1)
+          z3.write(e2(X2 - 1));
+        z3.write("\r");
+      }
+      z3.write(U2), X2 = JJ(U2, T3);
+    }
+    let P5 = Promise.resolve(), R3 = null;
+    function I5() {
+      if (R3 !== null)
+        return;
+      R3 = setTimeout(() => {
+        if (R3 = null, !F3)
+          H(Q3(j, G));
+      }, 0);
+    }
+    function y4() {
+      if (R3 !== null)
+        clearTimeout(R3), R3 = null;
+    }
+    function x4(U2, T3) {
+      if (T3?.ctrl && T3.name === "c") {
+        y4(), z3.write(`
+`), N4(), Y(new s2);
+        return;
+      }
+      let p2 = { char: U2 ?? "", name: T3?.name ?? "", ctrl: T3?.ctrl ?? false, meta: T3?.meta ?? false, shift: T3?.shift ?? false };
+      P5 = P5.then(async () => {
+        if (F3)
+          return;
+        try {
+          let d2 = await Z(p2, j);
+          if (HJ(d2)) {
+            y4();
+            let t2 = d2[i2];
+            if ($)
+              H($(j, t2, G));
+            z3.write(`
+`), N4(), K(t2);
+          } else
+            j = d2, I5();
+        } catch (d2) {
+          y4(), N4(), Y(d2);
+        }
+      });
+    }
+    try {
+      QJ.emitKeypressEvents(B3), B3.setRawMode(true), B3.resume(), z3.write(zJ);
+      let U2 = Q3(j, G);
+      z3.write(U2);
+      let T3 = z3.columns || 80;
+      X2 = JJ(U2, T3), B3.on("keypress", x4);
+    } catch (U2) {
+      N4(), Y(U2);
+    }
+  });
+}
+var V2 = "┃";
+var E3 = "✓";
+function c2(J3, Q3) {
+  if (Q3)
+    return `${J3} ${Q3}`;
+  return J3;
+}
+function A5(J3, Q3, Z) {
+  let W2 = [J3];
+  if (Q3)
+    W2.push(Q3);
+  if (Z)
+    W2.push(Z);
+  return W2.join(" ");
+}
+function L2(J3, Q3, Z, W2) {
+  let G = c2(J3, Q3), $ = W2 ?? "";
+  if (Q3)
+    return `${G}${$}
+  ${Z}`;
+  return `${G}${$} ${Z}`;
+}
+function MJ(J3, Q3) {
+  if (J3.name === "return")
+    return M4(Q3.value);
+  if (J3.name === "left" || J3.name === "right")
+    return { value: !Q3.value };
+  if (J3.name === "h")
+    return { value: true };
+  if (J3.name === "l")
+    return { value: false };
+  if (J3.name === "tab")
+    return { value: !Q3.value };
+  if (J3.char === "y" || J3.char === "Y")
+    return { value: true };
+  if (J3.char === "n" || J3.char === "N")
+    return { value: false };
+  return Q3;
+}
+var DJ = " · ";
+function AJ(J3, Q3, Z, W2, G) {
+  let $ = Q3.prefix(V2), K = Q3.message(Z ?? "Are you sure?"), Y = J3.value ? `${Q3.selected("●")} ${Q3.selected(W2)}` : `${Q3.unselected("○")} ${Q3.unselected(W2)}`, j = J3.value ? `${Q3.unselected("○")} ${Q3.unselected(G)}` : `${Q3.selected("●")} ${Q3.selected(G)}`, X2 = `${Y}${DJ}${j}`;
+  return L2($, K, X2);
+}
+function UJ(J3, Q3, Z, W2, G, $) {
+  let K = Z.success(E3), Y = Z.message(W2 ?? "Are you sure?"), j = Q3 ? G : $;
+  return A5(K, Y, Z.success(j));
+}
+async function wJ(J3) {
+  if (J3.initial !== undefined)
+    return J3.initial;
+  if (!_5() && J3.default !== undefined)
+    return J3.default;
+  let Q3 = w4(J3.theme), Z = J3.active ?? "Yes", W2 = J3.inactive ?? "No", $ = { value: J3.default ?? true };
+  return D4({ initialState: $, theme: Q3, render: (K, Y) => AJ(K, Y, J3.message, Z, W2), handleKey: MJ, renderSubmitted: (K, Y, j) => UJ(K, Y, j, J3.message, Z, W2) });
+}
+
 // src/commands/scan.ts
-import { writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync as mkdirSync2, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/sources/github.ts
 import { spawnSync } from "node:child_process";
@@ -998,20 +1513,6 @@ async function resolveSource(input) {
   return resolveGithub(parsed.repo);
 }
 
-// src/detector/marketplaceGuard.ts
-import { existsSync } from "node:fs";
-import { join as join2 } from "node:path";
-function checkMarketplaceGuard(repoRoot) {
-  const marketplaceFile = join2(repoRoot, ".claude-plugin", "marketplace.json");
-  if (existsSync(marketplaceFile)) {
-    throw new AlreadyMarketplaceError(repoRoot);
-  }
-}
-
-// src/detector/markerFile.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join as join3 } from "node:path";
-
 // ../../node_modules/.bun/valibot@1.3.1+7524df1edfed9f02/node_modules/valibot/dist/index.mjs
 var store$4;
 function getGlobalConfig(config$1) {
@@ -1091,6 +1592,28 @@ function _joinExpects(values$1, separator) {
     return `(${list.join(` ${separator} `)})`;
   return list[0] ?? "never";
 }
+function getDotPath(issue) {
+  if (issue.path) {
+    let key = "";
+    for (const item of issue.path)
+      if (typeof item.key === "string" || typeof item.key === "number")
+        if (key)
+          key += `.${item.key}`;
+        else
+          key += item.key;
+      else
+        return null;
+    return key;
+  }
+  return null;
+}
+var ValiError = class extends Error {
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
 function regex(requirement, message$1) {
   return {
     kind: "validation",
@@ -1123,6 +1646,19 @@ function startsWith(requirement, message$1) {
     }
   };
 }
+function transform(operation) {
+  return {
+    kind: "transformation",
+    type: "transform",
+    reference: transform,
+    async: false,
+    operation,
+    "~run"(dataset) {
+      dataset.value = this.operation(dataset.value);
+      return dataset;
+    }
+  };
+}
 var _LruCache = class {
   constructor(config$1) {
     this.refCount = 0;
@@ -1259,6 +1795,27 @@ function boolean(message$1) {
     }
   };
 }
+function custom(check$1, message$1) {
+  return {
+    kind: "schema",
+    type: "custom",
+    reference: custom,
+    expects: "unknown",
+    async: false,
+    check: check$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.check(dataset.value))
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
 function literal(literal_, message$1) {
   return {
     kind: "schema",
@@ -1653,6 +2210,12 @@ function unknown() {
     }
   };
 }
+function parse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  if (dataset.issues)
+    throw new ValiError(dataset.issues);
+  return dataset.value;
+}
 function pipe(...pipe$1) {
   return {
     ...pipe$1[0],
@@ -1684,35 +2247,238 @@ function safeParse(schema, input, config$1) {
   };
 }
 
+// src/detector/marketplaceGuard.ts
+import { existsSync } from "node:fs";
+import { join as join2 } from "node:path";
+function isAlreadyMarketplace(repoRoot) {
+  return existsSync(join2(repoRoot, ".claude-plugin", "marketplace.json"));
+}
+function checkMarketplaceGuard(repoRoot) {
+  if (isAlreadyMarketplace(repoRoot)) {
+    throw new AlreadyMarketplaceError(repoRoot);
+  }
+}
+
+// src/detector/markerFile.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/detector/fsWalk.ts
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+function isPermissionError(err) {
+  const code = err?.code;
+  return code === "EACCES" || code === "EPERM";
+}
+function makeDirLister(onSkip) {
+  const cache = new Map;
+  return (dir) => {
+    const hit = cache.get(dir);
+    if (hit !== undefined) {
+      return hit;
+    }
+    let out = [];
+    try {
+      out = readdirSync(dir, { withFileTypes: true }).map((d2) => {
+        if (d2.isSymbolicLink()) {
+          try {
+            const s3 = statSync(join3(dir, d2.name));
+            return { name: d2.name, isDirectory: s3.isDirectory(), isFile: s3.isFile(), isSymlink: true };
+          } catch {
+            return { name: d2.name, isDirectory: false, isFile: false, isSymlink: true };
+          }
+        }
+        return { name: d2.name, isDirectory: d2.isDirectory(), isFile: d2.isFile(), isSymlink: false };
+      });
+    } catch (err) {
+      if (isPermissionError(err)) {
+        onSkip?.(dir, err);
+      }
+    }
+    cache.set(dir, out);
+    return out;
+  };
+}
+function dirContainsFile(list, dir, name) {
+  return list(dir).some((e3) => e3.isFile && e3.name === name);
+}
+function dirContainsDir(list, dir, name) {
+  return list(dir).some((e3) => e3.isDirectory && e3.name === name);
+}
+function walkTree(root, options) {
+  const list = options.list ?? makeDirLister();
+  const realDirs = [];
+  const pendingSymlinks = [];
+  let seen = null;
+  const idOf = (dir) => {
+    try {
+      const st = statSync(dir);
+      return `${String(st.dev)}:${String(st.ino)}`;
+    } catch {
+      return null;
+    }
+  };
+  const walkInto = (dir) => {
+    options.onDir?.(dir);
+    const entries = list(dir).filter((e3) => !options.skipDirs.has(e3.name));
+    for (const entry of entries) {
+      if (entry.isFile) {
+        options.onFile?.(join3(dir, entry.name));
+      }
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory && !entry.isSymlink) {
+        const full = join3(dir, entry.name);
+        realDirs.push(full);
+        if (seen !== null) {
+          const id = idOf(full);
+          if (id === null || seen.has(id)) {
+            continue;
+          }
+          seen.add(id);
+        }
+        walkInto(full);
+      } else if (entry.isDirectory && entry.isSymlink) {
+        pendingSymlinks.push(join3(dir, entry.name));
+      }
+    }
+  };
+  realDirs.push(root);
+  walkInto(root);
+  while (pendingSymlinks.length > 0) {
+    seen ??= new Set(realDirs.map(idOf).filter((id2) => id2 !== null));
+    const dir = pendingSymlinks.shift();
+    if (dir === undefined) {
+      break;
+    }
+    const id = idOf(dir);
+    if (id === null || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    walkInto(dir);
+  }
+}
+function readJsonFile(file) {
+  let raw;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch (e3) {
+    throw new Error(`Cannot read ${file}: ${e3 instanceof Error ? e3.message : String(e3)}`, { cause: e3 });
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (e3) {
+    throw new Error(`Invalid JSON in ${file}: ${e3 instanceof Error ? e3.message : String(e3)}`, {
+      cause: e3
+    });
+  }
+}
+
+// src/schemas/marketplaceEntry.ts
+var PathString = pipe(string(), startsWith("./"));
+var GithubSourceSchema = strictObject({
+  source: literal("github"),
+  repo: pipe(string(), regex(/^[\w.-]+\/[\w.-]+$/)),
+  ref: optional(string()),
+  sha: optional(string())
+});
+var UrlSourceSchema = strictObject({
+  source: literal("url"),
+  url: string(),
+  ref: optional(string()),
+  sha: optional(string())
+});
+var GitSubdirSourceSchema = strictObject({
+  source: literal("git-subdir"),
+  url: string(),
+  path: string(),
+  ref: optional(string()),
+  sha: optional(string())
+});
+var SourceSchema = union([GithubSourceSchema, UrlSourceSchema, GitSubdirSourceSchema]);
+var DependencySchema = union([
+  string(),
+  object({ name: string(), version: optional(string()) })
+]);
+var NAME_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+var MarketplaceEntrySchema = object({
+  name: pipe(string(), regex(NAME_REGEX)),
+  source: SourceSchema,
+  strict: optional(boolean()),
+  dependencies: optional(array(DependencySchema)),
+  description: optional(string()),
+  version: optional(string()),
+  author: optional(union([string(), object({ name: string() })])),
+  homepage: optional(string()),
+  repository: optional(string()),
+  license: optional(string()),
+  keywords: optional(array(string())),
+  skills: optional(array(PathString)),
+  agents: optional(array(PathString)),
+  commands: optional(array(PathString)),
+  hooks: optional(union([PathString, record(string(), unknown())])),
+  mcpServers: optional(union([PathString, record(string(), unknown())])),
+  outputStyles: optional(array(PathString)),
+  themes: optional(array(PathString)),
+  monitors: optional(PathString)
+});
+
 // src/schemas/markerFile.ts
+var PathString2 = pipe(string(), startsWith("./"));
+var GroupSchema = strictObject({
+  slug: pipe(string(), regex(NAME_REGEX)),
+  skills: array(PathString2)
+});
 var MarkerFileSchema = strictObject({
-  name: pipe(string(), regex(/^[a-z0-9][a-z0-9-]*$/)),
+  name: pipe(string(), regex(NAME_REGEX)),
   description: optional(string()),
-  skills: optional(array(pipe(string(), startsWith("./")))),
-  agents: optional(array(pipe(string(), startsWith("./")))),
-  commands: optional(array(pipe(string(), startsWith("./")))),
+  groups: optional(array(GroupSchema)),
+  core: optional(boolean()),
+  umbrella: optional(boolean()),
+  skills: optional(array(PathString2)),
+  agents: optional(array(PathString2)),
+  commands: optional(array(PathString2)),
   hooks: optional(string()),
   mcpServers: optional(string()),
-  outputStyles: optional(array(pipe(string(), startsWith("./")))),
-  themes: optional(array(pipe(string(), startsWith("./")))),
+  outputStyles: optional(array(PathString2)),
+  themes: optional(array(PathString2)),
   monitors: optional(string()),
   license: optional(string()),
   homepage: optional(string()),
   repository: optional(string())
 });
+var MARKER_COMPONENT_FIELDS = [
+  "skills",
+  "agents",
+  "commands",
+  "hooks",
+  "mcpServers",
+  "outputStyles",
+  "themes",
+  "monitors"
+];
 
 // src/detector/markerFile.ts
+function hasComponentCuration(marker) {
+  return MARKER_COMPONENT_FIELDS.some((key) => marker[key] !== undefined);
+}
+function markerSuppressesSplit(marker) {
+  return marker.groups === undefined || marker.groups.length === 0;
+}
+function isFreezeOnlyMarker(marker) {
+  return marker.groups !== undefined && !hasComponentCuration(marker);
+}
 function detectMarkerFile(repoRoot) {
-  const markerPath = join3(repoRoot, ".ccpluginizer.json");
+  const markerPath = join4(repoRoot, ".ccpluginizer.json");
   if (!existsSync2(markerPath)) {
     return null;
   }
-  const raw = readFileSync(markerPath, "utf8");
   let parsed;
   try {
-    parsed = JSON.parse(raw);
-  } catch (e) {
-    throw new MarkerFileError(`Invalid JSON in ${markerPath}: ${e instanceof Error ? e.message : String(e)}`, []);
+    parsed = readJsonFile(markerPath);
+  } catch (e3) {
+    throw new MarkerFileError(e3 instanceof Error ? e3.message : String(e3), []);
   }
   const result = safeParse(MarkerFileSchema, parsed);
   if (!result.success) {
@@ -1722,35 +2488,40 @@ function detectMarkerFile(repoRoot) {
 }
 
 // src/detector/conventions.ts
-import { existsSync as existsSync3, readdirSync, statSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
+var ARTIFACT_DIR_FOLDERS = ["commands", "output-styles", "themes"];
+var ARTIFACT_JSON_KINDS = ["hooks", "monitors"];
+var ARTIFACT_FOLDER_KIND = {
+  commands: "commands",
+  "output-styles": "outputStyles",
+  themes: "themes"
+};
 var FOLDER_KINDS = [
   { folder: "skills", kind: "skills", emit: "directory" },
   { folder: "agents", kind: "agents", emit: { enumerateFiles: ".md" } },
-  { folder: "commands", kind: "commands", emit: "directory" },
-  { folder: "output-styles", kind: "outputStyles", emit: "directory" },
-  { folder: "themes", kind: "themes", emit: "directory" }
+  ...ARTIFACT_DIR_FOLDERS.map((folder) => ({ folder, kind: ARTIFACT_FOLDER_KIND[folder], emit: "directory" }))
 ];
 var FILE_KINDS = [
   { file: "hooks/hooks.json", kind: "hooks" },
   { file: ".mcp.json", kind: "mcpServers" },
   { file: "monitors/monitors.json", kind: "monitors" }
 ];
-function detectConventions(repoRoot) {
-  const rootFindings = scanRoot(repoRoot, "");
-  const dotfilesFindings = scanRoot(repoRoot, ".claude");
+function detectConventions(repoRoot, caches = {}) {
+  const list = caches.list ?? makeDirLister();
+  const rootFindings = scanRoot(repoRoot, "", list);
+  const dotfilesFindings = scanRoot(repoRoot, ".claude", list);
   return mergeByKind([...rootFindings, ...dotfilesFindings]);
 }
-function scanRoot(repoRoot, prefix) {
+function scanRoot(repoRoot, prefix, list) {
   const findings = [];
-  const baseDir = prefix === "" ? repoRoot : join4(repoRoot, prefix);
+  const baseDir = prefix === "" ? repoRoot : join5(repoRoot, prefix);
   const pathPrefix = prefix === "" ? "./" : `./${prefix}/`;
   for (const { folder, kind, emit } of FOLDER_KINDS) {
-    const folderPath = join4(baseDir, folder);
-    if (!existsSync3(folderPath) || !statSync(folderPath).isDirectory()) {
+    if (!dirContainsDir(list, baseDir, folder)) {
       continue;
     }
-    const entries = readdirSync(folderPath);
+    const folderPath = join5(baseDir, folder);
+    const entries = list(folderPath).map((e3) => e3.name);
     if (emit === "directory") {
       findings.push({
         kind,
@@ -1759,11 +2530,11 @@ function scanRoot(repoRoot, prefix) {
         source: "convention"
       });
     } else {
-      const files = entries.filter((e) => e.endsWith(emit.enumerateFiles));
+      const files = entries.filter((e3) => e3.endsWith(emit.enumerateFiles));
       if (files.length > 0) {
         findings.push({
           kind,
-          paths: files.map((f) => `${pathPrefix}${folder}/${f}`),
+          paths: files.map((f2) => `${pathPrefix}${folder}/${f2}`),
           confidence: "high",
           source: "convention"
         });
@@ -1771,7 +2542,10 @@ function scanRoot(repoRoot, prefix) {
     }
   }
   for (const { file, kind } of FILE_KINDS) {
-    if (existsSync3(join4(baseDir, file))) {
+    const parts = file.split("/");
+    const fileName = parts[parts.length - 1] ?? file;
+    const fileDir = parts.length > 1 ? join5(baseDir, ...parts.slice(0, -1)) : baseDir;
+    if (list(fileDir).some((e3) => e3.isFile && e3.name === fileName)) {
       findings.push({
         kind,
         paths: [`${pathPrefix}${file}`],
@@ -1803,8 +2577,8 @@ function mergeByKind(findings) {
 }
 
 // src/detector/nonStandardManifest.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // src/schemas/nonStandardManifest.ts
 var NonStandardManifestSchema = object({
@@ -1824,8 +2598,8 @@ var NonStandardManifestSchema = object({
 
 // src/detector/nonStandardManifest.ts
 function detectNonStandardManifest(repoRoot) {
-  const dir = join5(repoRoot, ".claude-plugin");
-  if (!existsSync4(dir) || !statSync2(dir).isDirectory()) {
+  const dir = join6(repoRoot, ".claude-plugin");
+  if (!existsSync3(dir) || !statSync2(dir).isDirectory()) {
     return null;
   }
   for (const entry of readdirSync2(dir)) {
@@ -1835,7 +2609,7 @@ function detectNonStandardManifest(repoRoot) {
     if (!entry.endsWith(".json")) {
       continue;
     }
-    const filePath = join5(dir, entry);
+    const filePath = join6(dir, entry);
     let parsed;
     try {
       parsed = JSON.parse(readFileSync2(filePath, "utf8"));
@@ -1846,119 +2620,263 @@ function detectNonStandardManifest(repoRoot) {
     if (!result.success) {
       continue;
     }
-    const m = result.output;
-    const hasComponent = m.skills !== undefined || m.agents !== undefined || m.commands !== undefined || m.hooks !== undefined || m.mcpServers !== undefined;
+    const m2 = result.output;
+    const hasComponent = m2.skills !== undefined || m2.agents !== undefined || m2.commands !== undefined || m2.hooks !== undefined || m2.mcpServers !== undefined;
     if (!hasComponent) {
       continue;
     }
-    return { filename: entry, manifest: m };
+    return { filename: entry, manifest: m2 };
   }
   return null;
 }
 
 // src/detector/contentSniff.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
-import { join as join6, dirname, relative } from "node:path";
+import { dirname, relative } from "node:path";
+
+// src/detector/frontmatterIo.ts
+import { readFileSync as readFileSync3 } from "node:fs";
 
 // src/schemas/frontmatter.ts
+var isScalar = (val) => typeof val === "string" || typeof val === "number" || typeof val === "boolean";
+var Stringy = pipe(custom((val) => isScalar(val) || Array.isArray(val) && val.length > 0 && val.every(isScalar)), transform((val) => Array.isArray(val) ? val.map(String).join(", ") : String(val)));
+var AdvisoryString = pipe(unknown(), transform((val) => isScalar(val) ? String(val) : undefined));
+var AdvisoryMetadata = pipe(unknown(), transform((val) => val !== null && typeof val === "object" && !Array.isArray(val) ? val : {}), object({
+  product: optional(AdvisoryString)
+}));
 var SkillFrontmatterSchema = object({
-  name: optional(string()),
-  description: string(),
-  "disable-model-invocation": optional(boolean())
+  name: optional(Stringy),
+  description: Stringy,
+  "disable-model-invocation": optional(boolean()),
+  metadata: optional(AdvisoryMetadata)
 });
 var AgentFrontmatterSchema = object({
-  name: string(),
-  description: string(),
+  name: Stringy,
+  description: Stringy,
   model: optional(string()),
   effort: optional(string()),
   maxTurns: optional(number()),
-  tools: optional(array(string())),
+  tools: optional(union([string(), array(string())])),
   disallowedTools: optional(union([string(), array(string())]))
 });
 
-// src/detector/contentSniff.ts
-function detectContentSniff(repoRoot) {
-  const skillDirs = new Set;
-  const agentFiles = new Set;
-  walk(repoRoot, repoRoot, (filePath) => {
-    if (filePath.endsWith("SKILL.md")) {
-      const fm = parseFrontmatter(filePath);
-      if (fm !== null && safeParse(SkillFrontmatterSchema, fm).success) {
-        const dir = dirname(filePath);
-        skillDirs.add(dir);
-      }
-      return;
-    }
-    if (filePath.endsWith(".md")) {
-      const fm = parseFrontmatter(filePath);
-      if (fm !== null && safeParse(AgentFrontmatterSchema, fm).success) {
-        agentFiles.add(filePath);
-      }
-    }
-  });
-  const findings = [];
-  if (skillDirs.size > 0) {
-    findings.push({
-      kind: "skills",
-      paths: Array.from(skillDirs).map((dir) => `./${relative(repoRoot, dir)}/`),
-      confidence: "medium",
-      source: "sniff"
-    });
-  }
-  if (agentFiles.size > 0) {
-    findings.push({
-      kind: "agents",
-      paths: Array.from(agentFiles).map((file) => `./${relative(repoRoot, file)}`),
-      confidence: "medium",
-      source: "sniff"
-    });
-  }
-  return findings;
-}
-function walk(repoRoot, dir, visit) {
-  for (const entry of readdirSync3(dir)) {
-    if (entry === "node_modules" || entry === ".git") {
-      continue;
-    }
-    const fullPath = join6(dir, entry);
-    const s = statSync3(fullPath);
-    if (s.isDirectory()) {
-      walk(repoRoot, fullPath, visit);
-    } else if (s.isFile()) {
-      visit(fullPath);
-    }
-  }
-}
-function parseFrontmatter(filePath) {
-  const content = readFileSync3(filePath, "utf8");
-  const match = /^---\n([\s\S]*?)\n---/.exec(content);
+// src/detector/yaml.ts
+function extractFrontmatter(fileContent) {
+  const text = fileContent.replace(/^\uFEFF/, "").replace(/\r\n?/g, `
+`);
+  const match = /^---\n([\s\S]*?)\n---/.exec(text);
   if (match === null) {
     return null;
   }
-  const yamlBody = match[1];
-  if (yamlBody === undefined) {
+  const body = match[1];
+  if (body === undefined) {
     return null;
   }
-  return parseYamlBlock(yamlBody);
+  return parseYamlFrontmatter(body);
 }
-function parseYamlBlock(body) {
-  const out = {};
-  for (const line of body.split(`
-`)) {
+function parseYamlFrontmatter(body) {
+  const lines = dedentCommonIndent(body.replace(/\r\n?/g, `
+`).split(`
+`));
+  const out = Object.create(null);
+  let i3 = 0;
+  while (i3 < lines.length) {
+    const line = lines[i3] ?? "";
     const trimmed = line.trim();
     if (trimmed === "" || trimmed.startsWith("#")) {
+      i3++;
+      continue;
+    }
+    if (leadingSpaces(line) > 0) {
+      i3++;
       continue;
     }
     const colonIdx = trimmed.indexOf(":");
     if (colonIdx === -1) {
+      i3++;
       continue;
     }
     const key = trimmed.slice(0, colonIdx).trim();
     const rawValue = trimmed.slice(colonIdx + 1).trim();
-    out[key] = coerceYamlValue(rawValue);
+    if (isBlockScalarIndicator(rawValue)) {
+      const { value, next } = collectBlockScalar(lines, i3 + 1, 0, rawValue);
+      out[key] = value;
+      i3 = next;
+      continue;
+    }
+    if (rawValue === "") {
+      const { value, next } = collectNested(lines, i3 + 1, 0);
+      out[key] = value;
+      i3 = next;
+      continue;
+    }
+    const cont = collectPlainContinuation(lines, i3 + 1);
+    if (cont.lines.length > 0) {
+      out[key] = [rawValue, ...cont.lines].join(" ");
+      i3 = cont.next;
+    } else {
+      out[key] = coerceYamlValue(rawValue);
+      i3++;
+    }
   }
   return out;
 }
+function collectPlainContinuation(lines, start) {
+  const collected = [];
+  let i3 = start;
+  for (;i3 < lines.length; i3++) {
+    const line = lines[i3] ?? "";
+    if (line.trim() === "" || line.trim().startsWith("#") || leadingSpaces(line) === 0) {
+      break;
+    }
+    collected.push(line.trim());
+  }
+  return { lines: collected, next: i3 };
+}
+function dedentCommonIndent(lines) {
+  let minIndent = Infinity;
+  for (const line of lines) {
+    const t2 = line.trim();
+    if (t2 === "" || t2.startsWith("#")) {
+      continue;
+    }
+    minIndent = Math.min(minIndent, leadingSpaces(line));
+  }
+  if (minIndent === 0 || !Number.isFinite(minIndent)) {
+    return lines;
+  }
+  return lines.map((line) => line.trim() === "" ? line : line.slice(minIndent));
+}
+function leadingSpaces(line) {
+  let n2 = 0;
+  for (const ch of line) {
+    if (ch === " " || ch === "\t") {
+      n2++;
+    } else {
+      break;
+    }
+  }
+  return n2;
+}
+function isBlockScalarIndicator(raw) {
+  return raw === ">" || raw === ">-" || raw === ">+" || raw === "|" || raw === "|-" || raw === "|+";
+}
+function collectBlockScalar(lines, start, baseIndent, indicator) {
+  const folded = indicator.startsWith(">");
+  const content = [];
+  let blockIndent = -1;
+  let i3 = start;
+  for (;i3 < lines.length; i3++) {
+    const line = lines[i3] ?? "";
+    if (line.trim() === "") {
+      content.push("");
+      continue;
+    }
+    if (leadingSpaces(line) <= baseIndent) {
+      break;
+    }
+    if (blockIndent === -1) {
+      blockIndent = leadingSpaces(line);
+    }
+    content.push(line.slice(Math.min(blockIndent, leadingSpaces(line))));
+  }
+  while (content.length > 0 && content[content.length - 1] === "") {
+    content.pop();
+  }
+  if (!folded) {
+    return { value: content.join(`
+`), next: i3 };
+  }
+  const paragraphs = [];
+  let current = [];
+  for (const line of content) {
+    if (line === "") {
+      paragraphs.push(current.join(" "));
+      current = [];
+    } else {
+      current.push(line.trim());
+    }
+  }
+  paragraphs.push(current.join(" "));
+  return { value: paragraphs.join(`
+`).trim(), next: i3 };
+}
+function collectNested(lines, start, baseIndent) {
+  let peek = start;
+  while (peek < lines.length) {
+    const t2 = (lines[peek] ?? "").trim();
+    if (t2 !== "" && !t2.startsWith("#")) {
+      break;
+    }
+    peek++;
+  }
+  if (peek >= lines.length) {
+    return { value: "", next: start };
+  }
+  const firstLine = lines[peek] ?? "";
+  if (leadingSpaces(firstLine) <= baseIndent) {
+    return { value: "", next: start };
+  }
+  const firstTrimmed = firstLine.trim();
+  const childIndent = leadingSpaces(firstLine);
+  if (firstTrimmed !== "-" && !firstTrimmed.startsWith("- ") && mappingColonIndex(firstTrimmed) === -1) {
+    const cont = collectPlainContinuation(lines, peek);
+    return { value: cont.lines.join(" "), next: cont.next };
+  }
+  if (firstTrimmed === "-" || firstTrimmed.startsWith("- ")) {
+    const arr = [];
+    let i4 = start;
+    for (;i4 < lines.length; i4++) {
+      const line = lines[i4] ?? "";
+      if (line.trim() === "") {
+        continue;
+      }
+      if (leadingSpaces(line) <= baseIndent) {
+        break;
+      }
+      if (leadingSpaces(line) > childIndent) {
+        continue;
+      }
+      const t2 = line.trim();
+      if (t2 === "-") {
+        arr.push(null);
+      } else if (t2.startsWith("- ")) {
+        arr.push(coerceYamlValue(t2.slice(2).trim()));
+      }
+    }
+    return { value: arr, next: i4 };
+  }
+  const map = Object.create(null);
+  let i3 = start;
+  for (;i3 < lines.length; i3++) {
+    const line = lines[i3] ?? "";
+    const t2 = line.trim();
+    if (t2 === "" || t2.startsWith("#")) {
+      continue;
+    }
+    if (leadingSpaces(line) <= baseIndent) {
+      break;
+    }
+    if (leadingSpaces(line) > childIndent) {
+      continue;
+    }
+    const ci = mappingColonIndex(t2);
+    if (ci === -1) {
+      continue;
+    }
+    const k3 = t2.slice(0, ci).trim();
+    const val = t2.slice(ci + 1).trim();
+    map[k3] = val === "" || isBlockScalarIndicator(val) ? null : coerceYamlValue(val);
+  }
+  return { value: map, next: i3 };
+}
+function mappingColonIndex(line) {
+  for (let i3 = line.indexOf(":");i3 !== -1; i3 = line.indexOf(":", i3 + 1)) {
+    if (i3 === line.length - 1 || line[i3 + 1] === " " || line[i3 + 1] === "\t") {
+      return i3;
+    }
+  }
+  return -1;
+}
 function coerceYamlValue(raw) {
   if (raw === "true")
     return true;
@@ -1966,17 +2884,144 @@ function coerceYamlValue(raw) {
     return false;
   if (raw === "null" || raw === "~")
     return null;
-  if (/^-?\d+$/.test(raw))
-    return Number(raw);
+  if (/^-?\d+$/.test(raw)) {
+    const n2 = Number(raw);
+    return String(n2) === raw ? n2 : raw;
+  }
   if (raw.startsWith('"') && raw.endsWith('"'))
     return raw.slice(1, -1);
   if (raw.startsWith("'") && raw.endsWith("'"))
     return raw.slice(1, -1);
+  if (raw.startsWith("[") && raw.endsWith("]")) {
+    const inner = raw.slice(1, -1).trim();
+    if (inner === "")
+      return [];
+    if (!inner.includes("[") && !inner.includes("]")) {
+      return splitFlowList(inner).map((s3) => coerceYamlValue(s3.trim()));
+    }
+  }
   return raw;
 }
+function splitFlowList(inner) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  for (const ch of inner) {
+    if (quote !== null) {
+      if (ch === quote) {
+        quote = null;
+      }
+      current += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+    } else if (ch === ",") {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  parts.push(current);
+  return parts;
+}
+
+// src/detector/frontmatterIo.ts
+function readFrontmatter(filePath, onSkip) {
+  let raw;
+  try {
+    raw = readFileSync3(filePath, "utf8");
+  } catch (err) {
+    if (isPermissionError(err)) {
+      onSkip?.(filePath, err);
+    }
+    return null;
+  }
+  return extractFrontmatter(raw);
+}
+function makeFrontmatterReader(onSkip) {
+  const cache = new Map;
+  return (file) => {
+    if (cache.has(file)) {
+      return cache.get(file) ?? null;
+    }
+    const fm = readFrontmatter(file, onSkip);
+    cache.set(file, fm);
+    return fm;
+  };
+}
+function isAgentFile(filePath, readFm = readFrontmatter) {
+  const fm = readFm(filePath);
+  return fm !== null && safeParse(AgentFrontmatterSchema, fm).success;
+}
+function parseSkillFile(filePath, readFm = readFrontmatter) {
+  const fm = readFm(filePath);
+  if (fm === null) {
+    return null;
+  }
+  const parsed = safeParse(SkillFrontmatterSchema, fm);
+  return parsed.success ? parsed.output : null;
+}
+function isSkillFile(filePath, readFm = readFrontmatter) {
+  return parseSkillFile(filePath, readFm) !== null;
+}
+
+// src/detector/contentSniff.ts
+var SNIFF_SKIP_DIRS = new Set(["node_modules", ".git"]);
+function detectContentSniff(repoRoot, caches = {}) {
+  const skillDirs = new Set;
+  const agentFiles = new Set;
+  const readFm = caches.readFrontmatter ?? readFrontmatter;
+  walkTree(repoRoot, {
+    skipDirs: SNIFF_SKIP_DIRS,
+    ...caches.list !== undefined ? { list: caches.list } : {},
+    onFile: (filePath) => {
+      if (filePath.endsWith("SKILL.md")) {
+        if (isSkillFile(filePath, readFm)) {
+          skillDirs.add(dirname(filePath));
+        }
+        return;
+      }
+      if (filePath.endsWith(".md") && isAgentFile(filePath, readFm)) {
+        agentFiles.add(filePath);
+      }
+    }
+  });
+  const findings = [];
+  if (skillDirs.size > 0) {
+    findings.push({
+      kind: "skills",
+      paths: Array.from(skillDirs).map((dir) => `./${relative(repoRoot, dir)}/`).sort(),
+      confidence: "medium",
+      source: "sniff"
+    });
+  }
+  if (agentFiles.size > 0) {
+    findings.push({
+      kind: "agents",
+      paths: Array.from(agentFiles).map((file) => `./${relative(repoRoot, file)}`).sort(),
+      confidence: "medium",
+      source: "sniff"
+    });
+  }
+  return findings;
+}
+
+// src/detector/caches.ts
+function makeScanCaches() {
+  const skippedPaths = [];
+  const onSkip = (p2) => {
+    skippedPaths.push(p2);
+  };
+  return {
+    list: makeDirLister(onSkip),
+    readFrontmatter: makeFrontmatterReader(onSkip),
+    skippedPaths
+  };
+}
 
 // src/detector/normalize.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { join as join7 } from "node:path";
 function normalizePath(input) {
   if (input.split("/").includes("..")) {
@@ -1999,7 +3044,7 @@ function normalizePathsAgainstRepo(repoRoot, paths) {
   for (const raw of paths) {
     const normalized = normalizePath(raw);
     const fullPath = join7(repoRoot, normalized);
-    if (existsSync5(fullPath)) {
+    if (existsSync4(fullPath)) {
       kept.push(normalized);
     } else {
       dropped.push(normalized);
@@ -2008,23 +3053,838 @@ function normalizePathsAgainstRepo(repoRoot, paths) {
   return { kept, dropped };
 }
 
+// src/detector/sourceLayout.ts
+import { basename, join as join9, relative as relative2, resolve, sep } from "node:path";
+
+// src/detector/slugify.ts
+var SLUG_FALLBACK = "group";
+function byCodeUnit(a3, b6) {
+  return a3 < b6 ? -1 : a3 > b6 ? 1 : 0;
+}
+function slugify(input) {
+  const slug = input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return slug === "" ? SLUG_FALLBACK : slug;
+}
+function stripCommonPrefix(keys) {
+  if (keys.length <= 1) {
+    return [...keys];
+  }
+  let prefix = keys[0] ?? "";
+  for (const k3 of keys.slice(1)) {
+    while (prefix !== "" && !k3.startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+    }
+    if (prefix === "") {
+      return [...keys];
+    }
+  }
+  const lastHyphen = prefix.lastIndexOf("-");
+  if (lastHyphen === -1) {
+    return [...keys];
+  }
+  const cut = lastHyphen + 1;
+  const stripped = keys.map((k3) => k3.slice(cut));
+  if (stripped.some((s3) => s3 === "")) {
+    return [...keys];
+  }
+  return stripped;
+}
+function uniqueWithin(used, desired) {
+  if (!used.has(desired)) {
+    return desired;
+  }
+  let n2 = 2;
+  while (used.has(`${desired}-${String(n2)}`)) {
+    n2++;
+  }
+  return `${desired}-${String(n2)}`;
+}
+function uniqueSlugs(slugs) {
+  const used = new Set;
+  const out = [];
+  for (const s3 of slugs) {
+    const candidate = uniqueWithin(used, s3);
+    used.add(candidate);
+    out.push(candidate);
+  }
+  return out;
+}
+
+// src/detector/skillMeta.ts
+import { join as join8 } from "node:path";
+function enumerateSkills(containerDir, list = makeDirLister(), readFm = readFrontmatter) {
+  const out = [];
+  const children = list(containerDir).filter((e3) => e3.isDirectory).map((e3) => e3.name).sort();
+  for (const dir of children) {
+    const skillPath = join8(containerDir, dir);
+    if (!dirContainsFile(list, skillPath, "SKILL.md")) {
+      continue;
+    }
+    const parsed = parseSkillFile(join8(skillPath, "SKILL.md"), readFm);
+    if (parsed === null) {
+      continue;
+    }
+    out.push(toMeta(dir, parsed));
+  }
+  return out;
+}
+function toMeta(dir, fm) {
+  return {
+    path: `./${dir}/`,
+    dir,
+    name: fm.name ?? dir,
+    description: fm.description,
+    ...fm.metadata?.product !== undefined ? { product: fm.metadata.product } : {}
+  };
+}
+function countSkillMdDirs(containerDir, list = makeDirLister(), skipDirs) {
+  return list(containerDir).filter((e3) => e3.isDirectory && !(skipDirs?.has(e3.name) ?? false) && dirContainsFile(list, join8(containerDir, e3.name), "SKILL.md")).length;
+}
+
+// src/detector/sourceLayout.ts
+import { realpathSync } from "node:fs";
+var SKIP_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "tests",
+  "test",
+  "__tests__",
+  "__mocks__",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".cache",
+  ".turbo",
+  ".github",
+  "vendor"
+]);
+function createLayoutResolver(repoRoot, caches = {}) {
+  repoRoot = resolve(repoRoot);
+  const list = caches.list ?? makeDirLister();
+  const readFm = caches.readFrontmatter ?? makeFrontmatterReader();
+  const dirs = [];
+  walkTree(repoRoot, { skipDirs: SKIP_DIRS, list, onDir: (d2) => dirs.push(d2) });
+  const insideSkillMemo = new Map;
+  const insideSkill = (dir) => {
+    if (dir === repoRoot) {
+      return false;
+    }
+    const memo = insideSkillMemo.get(dir);
+    if (memo !== undefined) {
+      return memo;
+    }
+    const parent = join9(dir, "..");
+    let result;
+    if (parent === dir || parent === repoRoot && (basename(dir) === "skills" || basename(dir) === "agents")) {
+      result = false;
+    } else {
+      const parentBundles = !dirIsPluginRoot(list, parent) && dirContainsFile(list, parent, "SKILL.md");
+      result = parentBundles || insideSkill(parent);
+    }
+    insideSkillMemo.set(dir, result);
+    return result;
+  };
+  const containerDirs = dirs.filter((d2) => !insideSkill(d2) && (basename(d2) === "skills" || !dirContainsFile(list, d2, "SKILL.md")));
+  const counted = containerDirs.map((absDir) => ({
+    absDir,
+    relPath: toRel(repoRoot, absDir),
+    count: countSkillMdDirs(absDir, list, SKIP_DIRS)
+  }));
+  const best = pickBest(counted);
+  const skillsContainer = best === null ? null : { absDir: best.absDir, relPath: best.relPath, hasSkillsChild: dirContainsDir(list, best.absDir, "skills") };
+  const totalSkillDirs = counted.reduce((sum, c3) => sum + c3.count, 0);
+  const skillDirsOutsideContainer = totalSkillDirs - (best?.count ?? 0);
+  const containerWarnings = [];
+  if (best !== null) {
+    try {
+      const realContainer = realpathSync(best.absDir);
+      const expected = join9(realpathSync(repoRoot), ...best.relPath === "." ? [] : best.relPath.split("/"));
+      if (realContainer !== expected) {
+        containerWarnings.push(`the skills container "${best.relPath}" resolves through a symlink; git-subdir checkouts would contain the link, not the skills — restructure or use --no-split.`);
+      }
+    } catch {}
+  }
+  let full = null;
+  return {
+    skillsContainer,
+    skillDirsOutsideContainer,
+    warnings: containerWarnings,
+    list,
+    readFrontmatter: readFm,
+    full() {
+      if (full === null) {
+        const pluginRoot = resolvePluginRoot(repoRoot, dirs, list);
+        full = {
+          skillsContainer,
+          skillDirsOutsideContainer,
+          agentsContainer: resolveAgentsContainer(repoRoot, containerDirs, list, readFm),
+          pluginRoot,
+          mcp: resolveMcp(repoRoot, dirs, list, pluginRoot),
+          artifacts: resolveArtifacts(repoRoot, dirs, list, pluginRoot)
+        };
+      }
+      return full;
+    }
+  };
+}
+function toRel(repoRoot, abs) {
+  const r2 = relative2(repoRoot, abs);
+  return r2 === "" ? "." : r2.split(sep).join("/");
+}
+function pickBest(candidates) {
+  let best = null;
+  for (const c3 of candidates) {
+    if (c3.count === 0) {
+      continue;
+    }
+    if (best === null || isBetter(c3, best)) {
+      best = c3;
+    }
+  }
+  return best;
+}
+function isBetter(a3, b6) {
+  return a3.count > b6.count || a3.count === b6.count && shallowerThenCodeUnit(a3.relPath, b6.relPath) < 0;
+}
+function shallowerThenCodeUnit(a3, b6) {
+  const segA = a3.split("/").length;
+  const segB = b6.split("/").length;
+  return segA !== segB ? segA - segB : byCodeUnit(a3, b6);
+}
+function resolveAgentsContainer(repoRoot, dirs, list, readFm) {
+  const score = (absDir) => {
+    const files = list(absDir).filter((e3) => e3.isFile && e3.name.endsWith(".md") && e3.name !== "SKILL.md").map((e3) => e3.name).filter((f2) => isAgentFile(join9(absDir, f2), readFm)).sort();
+    return {
+      absDir,
+      relPath: toRel(repoRoot, absDir),
+      count: files.length,
+      files,
+      hasSkillsChild: dirContainsDir(list, absDir, "skills")
+    };
+  };
+  const named = dirs.filter((d2) => basename(d2) === "agents").map(score);
+  const best = pickBest(named) ?? pickBest(dirs.map(score));
+  return best === null ? null : { absDir: best.absDir, relPath: best.relPath, hasSkillsChild: best.hasSkillsChild, files: best.files };
+}
+function dirIsPluginRoot(list, dir) {
+  return dirContainsDir(list, dir, ".claude-plugin") && dirContainsFile(list, join9(dir, ".claude-plugin"), "plugin.json");
+}
+function resolvePluginRoot(repoRoot, dirs, list) {
+  const candidates = dirs.filter((d2) => dirIsPluginRoot(list, d2)).map((d2) => ({ relPath: toRel(repoRoot, d2), count: 1 }));
+  const best = pickBest(candidates);
+  return best === null ? null : { relPath: best.relPath };
+}
+function anchoredDirs(repoRoot, dirs, pluginRoot) {
+  const anchors = new Set([repoRoot, join9(repoRoot, ".claude")]);
+  if (pluginRoot !== null && pluginRoot.relPath !== ".") {
+    const root = join9(repoRoot, pluginRoot.relPath);
+    anchors.add(root);
+    anchors.add(join9(root, ".claude"));
+  }
+  return dirs.filter((d2) => anchors.has(d2));
+}
+function resolveMcp(repoRoot, dirs, list, pluginRoot) {
+  const files = anchoredDirs(repoRoot, dirs, pluginRoot).filter((d2) => dirContainsFile(list, d2, ".mcp.json")).map((d2) => ({ file: join9(d2, ".mcp.json"), relPath: toRel(repoRoot, join9(d2, ".mcp.json")) })).sort((a3, b6) => preferUnder(pluginRoot, a3.relPath, b6.relPath));
+  for (const chosen of files) {
+    let parsed;
+    try {
+      parsed = readJsonFile(chosen.file);
+    } catch {
+      continue;
+    }
+    const servers = extractServers(parsed);
+    if (servers === null) {
+      continue;
+    }
+    return { servers, serverType: classifyServers(servers), relPath: chosen.relPath };
+  }
+  return null;
+}
+function resolveArtifacts(repoRoot, dirs, list, pluginRoot) {
+  const out = [];
+  const anchored = anchoredDirs(repoRoot, dirs, pluginRoot);
+  for (const kind of ARTIFACT_JSON_KINDS) {
+    const hit = resolveJsonFileArtifact(repoRoot, anchored, list, pluginRoot, kind);
+    if (hit !== null) {
+      out.push({ kind, relPath: hit });
+    }
+  }
+  for (const kind of ARTIFACT_DIR_FOLDERS) {
+    const hits = anchored.filter((d2) => dirContainsDir(list, d2, kind)).map((d2) => toRel(repoRoot, join9(d2, kind))).sort((a3, b6) => preferUnder(pluginRoot, a3, b6));
+    if (hits[0] !== undefined) {
+      out.push({ kind, relPath: hits[0] });
+    }
+  }
+  return out;
+}
+function resolveJsonFileArtifact(repoRoot, dirs, list, pluginRoot, kind) {
+  const fileName = `${kind}.json`;
+  const hits = dirs.filter((d2) => dirContainsDir(list, d2, kind) && dirContainsFile(list, join9(d2, kind), fileName)).map((d2) => toRel(repoRoot, join9(d2, kind, fileName))).sort((a3, b6) => preferUnder(pluginRoot, a3, b6));
+  return hits[0] ?? null;
+}
+function preferUnder(pluginRoot, a3, b6) {
+  if (pluginRoot !== null) {
+    const aUnder = a3.startsWith(`${pluginRoot.relPath}/`) ? 0 : 1;
+    const bUnder = b6.startsWith(`${pluginRoot.relPath}/`) ? 0 : 1;
+    if (aUnder !== bUnder) {
+      return aUnder - bUnder;
+    }
+  }
+  return shallowerThenCodeUnit(a3, b6);
+}
+function extractServers(parsed) {
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const obj = parsed;
+  const hasWrapper = obj["mcpServers"] !== undefined && obj["mcpServers"] !== null;
+  const raw = hasWrapper ? obj["mcpServers"] : obj;
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const servers = raw;
+  const entries = Object.values(servers);
+  if (entries.length === 0) {
+    return null;
+  }
+  if (!hasWrapper && !entries.every((e3) => e3 !== null && typeof e3 === "object")) {
+    return null;
+  }
+  return servers;
+}
+function classifyServers(servers) {
+  const types = Object.values(servers).map(classifyOne);
+  if (types.length === 0) {
+    return "unknown";
+  }
+  if (types.includes("repo-local")) {
+    return "repo-local";
+  }
+  if (types.every((t2) => t2 === "remote")) {
+    return "remote";
+  }
+  if (types.every((t2) => t2 === "remote" || t2 === "package")) {
+    return "package";
+  }
+  return "unknown";
+}
+var SCRIPT_EXT = /\.(?:js|mjs|cjs|ts|mts|cts|py|sh|rb)$/;
+function classifyOne(server) {
+  if (server === null || typeof server !== "object") {
+    return "unknown";
+  }
+  const s3 = server;
+  if (s3["type"] === "http" || s3["type"] === "sse" || typeof s3["url"] === "string") {
+    return "remote";
+  }
+  const cmd = s3["command"];
+  if (typeof cmd !== "string") {
+    return "unknown";
+  }
+  const args = Array.isArray(s3["args"]) ? s3["args"].filter((a3) => typeof a3 === "string") : [];
+  const refsLocal = (x4) => x4.startsWith("./") || x4.startsWith("../") || x4.startsWith("/") || x4.includes("${CLAUDE_PLUGIN_ROOT}") || x4.includes("/") && SCRIPT_EXT.test(x4);
+  if (refsLocal(cmd) || args.some(refsLocal)) {
+    return "repo-local";
+  }
+  return "package";
+}
+
+// src/detector/partition.ts
+import { basename as basename2 } from "node:path";
+
+// src/schemas/rawGroups.ts
+var RawGroupSchema = object({
+  slug: string(),
+  members: array(string())
+});
+var RawGroupsSchema = array(RawGroupSchema);
+
+// src/detector/partition.ts
+var CLUSTER_STRATEGIES = ["auto", "auto-llm", "llm", "metadata", "directory", "name-prefix"];
+var DEFAULT_STRATEGY = "auto";
+function strategyUsesLlm(strategy) {
+  return strategy === "llm" || strategy === "auto-llm";
+}
+var MIN_K = 2;
+var MAX_K = 12;
+var MAX_FRACTION = 0.7;
+var MIN_GROUP_SIZE = 3;
+var MISC = "misc";
+var LANGUAGES = new Set([
+  "curl",
+  "go",
+  "golang",
+  "java",
+  "javascript",
+  "js",
+  "node",
+  "nodejs",
+  "typescript",
+  "ts",
+  "python",
+  "py",
+  "ruby",
+  "rb",
+  "php",
+  "csharp",
+  "dotnet",
+  "cs",
+  "rust",
+  "rs",
+  "kotlin",
+  "swift",
+  "bash",
+  "shell",
+  "sh",
+  "cpp",
+  "c"
+]);
+function partitionByMetadata(skills) {
+  if (!skills.some((s3) => s3.product !== undefined)) {
+    return null;
+  }
+  const byKey = groupByKey(skills, (s3) => s3.product ?? MISC);
+  return normalizeAndGate(byKey, skills.length);
+}
+function partitionByNamePrefix(skills) {
+  const keyOf = strippedKeyResolver(skills, (name) => dropTrailingLanguage(name));
+  return normalizeAndGate(groupByKey(skills, keyOf), skills.length);
+}
+function partitionByDirectory(skills) {
+  const keyOf = strippedKeyResolver(skills, (name) => name.split("-")[0] ?? name);
+  return normalizeAndGate(groupByKey(skills, keyOf), skills.length);
+}
+var strippedCache = new WeakMap;
+function strippedKeyResolver(skills, keyFromStripped) {
+  let stripped = strippedCache.get(skills);
+  if (stripped === undefined) {
+    stripped = stripCommonPrefix(skills.map((s3) => s3.dir));
+    strippedCache.set(skills, stripped);
+  }
+  const keyByDir = new Map;
+  skills.forEach((s3, i3) => {
+    const name = stripped[i3] ?? s3.dir;
+    const key = keyFromStripped(name);
+    keyByDir.set(s3.dir, key === "" ? name : key);
+  });
+  return (s3) => keyByDir.get(s3.dir) ?? s3.dir;
+}
+function dropTrailingLanguage(name) {
+  const parts = name.split("-");
+  if (parts.length > 1 && LANGUAGES.has(parts[parts.length - 1] ?? "")) {
+    parts.pop();
+  }
+  return parts.join("-");
+}
+function groupByKey(skills, keyOf) {
+  const m2 = new Map;
+  for (const s3 of skills) {
+    const k3 = keyOf(s3);
+    const list = m2.get(k3) ?? [];
+    list.push(s3);
+    m2.set(k3, list);
+  }
+  return m2;
+}
+function passesGateBounds(groups, total) {
+  return groups.length >= MIN_K && groups.length <= MAX_K && !groups.some((g) => g.skills.length > MAX_FRACTION * total);
+}
+function normalizeAndGate(rawByKey, total) {
+  let groups = [...rawByKey].map(([key, skills]) => ({ key, skills }));
+  if (groups.length === 0) {
+    return null;
+  }
+  groups = collapseToFit(groups, MAX_K);
+  groups = coalesceTiny(groups, MIN_GROUP_SIZE);
+  if (!passesGateBounds(groups, total)) {
+    return null;
+  }
+  return finalizeGroups(groups.map((g) => ({ slug: slugify(g.key), skills: g.skills })));
+}
+function collapseToFit(groups, maxK) {
+  if (groups.length <= maxK) {
+    return groups;
+  }
+  const collapsed = collapseByLeadingSegment(groups);
+  if (collapsed.length <= maxK) {
+    return collapsed;
+  }
+  return mergeSmallestIntoMisc(collapsed, maxK);
+}
+function collapseByLeadingSegment(groups) {
+  const m2 = new Map;
+  for (const g of groups) {
+    const lead = g.key.split("-")[0] ?? g.key;
+    const list = m2.get(lead) ?? [];
+    list.push(...g.skills);
+    m2.set(lead, list);
+  }
+  return [...m2].map(([key, skills]) => ({ key, skills }));
+}
+function appendToMisc(keep, extra) {
+  const existingMisc = keep.find((g) => g.key === MISC);
+  if (existingMisc !== undefined) {
+    existingMisc.skills.push(...extra);
+    return [...keep];
+  }
+  return [...keep, { key: MISC, skills: extra }];
+}
+function mergeSmallestIntoMisc(groups, maxK) {
+  const sorted = [...groups].sort((a3, b6) => a3.skills.length - b6.skills.length || byCodeUnit(a3.key, b6.key));
+  const removeCount = groups.length - maxK + 1;
+  const toMerge = sorted.slice(0, removeCount);
+  const keep = sorted.slice(removeCount);
+  return appendToMisc(keep, toMerge.flatMap((g) => g.skills));
+}
+function coalesceTiny(groups, minSize) {
+  const tiny = groups.filter((g) => g.skills.length < minSize);
+  if (tiny.length === 0) {
+    return [...groups];
+  }
+  const big = groups.filter((g) => g.skills.length >= minSize);
+  return appendToMisc(big, tiny.flatMap((g) => g.skills));
+}
+function finalizeGroups(groups) {
+  const slugs = uniqueSlugs(groups.map((g) => g.slug));
+  return groups.map((g, i3) => ({
+    slug: slugs[i3] ?? g.slug,
+    skills: [...g.skills].sort((a3, b6) => byCodeUnit(a3.dir, b6.dir))
+  })).sort((a3, b6) => byCodeUnit(a3.slug, b6.slug));
+}
+function acceptRawGroups(groups, total) {
+  if (!passesGateBounds(groups, total)) {
+    return null;
+  }
+  const covered = groups.flatMap((g) => g.skills.map((s3) => s3.dir));
+  if (new Set(covered).size !== covered.length) {
+    return null;
+  }
+  if (covered.length !== total) {
+    return null;
+  }
+  return finalizeGroups(groups);
+}
+function mapRawGroups(skills, raw) {
+  const byDir = new Map(skills.map((s3) => [s3.dir, s3]));
+  const out = [];
+  for (const item of raw) {
+    const gs = item.members.map((m2) => byDir.get(m2)).filter((s3) => s3 !== undefined);
+    if (gs.length > 0) {
+      out.push({ slug: slugify(item.slug), skills: gs });
+    }
+  }
+  return out;
+}
+function validRawItems(raw) {
+  return raw.filter((g) => safeParse(RawGroupSchema, g).success);
+}
+function gateRaw(skills, raw) {
+  return acceptRawGroups(mapRawGroups(skills, raw), skills.length);
+}
+function matchMarkerGroups(skills, markerGroups) {
+  const byPath = new Map(skills.map((s3) => [normalizePath2(s3.path), s3]));
+  const byDir = new Map(skills.map((s3) => [s3.dir, s3]));
+  const assigned = new Set;
+  const out = [];
+  const unmatched = [];
+  const duplicates = [];
+  const fuzzyMatched = [];
+  for (const mg of markerGroups) {
+    const gs = [];
+    for (const p2 of mg.skills) {
+      const norm = normalizePath2(p2);
+      const exact = byPath.get(norm);
+      const s3 = exact ?? byDir.get(basename2(norm));
+      if (s3 === undefined) {
+        unmatched.push(p2);
+        continue;
+      }
+      if (exact === undefined) {
+        fuzzyMatched.push(p2);
+      }
+      if (assigned.has(s3.dir)) {
+        duplicates.push(p2);
+        continue;
+      }
+      gs.push(s3);
+      assigned.add(s3.dir);
+    }
+    if (gs.length > 0) {
+      out.push({ slug: slugify(mg.slug), skills: gs });
+    }
+  }
+  return { groups: out, unmatched, duplicates, fuzzyMatched, leftover: skills.filter((s3) => !assigned.has(s3.dir)) };
+}
+function preview(items) {
+  return items.slice(0, 3).join(", ") + (items.length > 3 ? ", …" : "");
+}
+function normalizePath2(p2) {
+  return p2.endsWith("/") ? p2 : `${p2}/`;
+}
+var deterministicFns = {
+  metadata: partitionByMetadata,
+  directory: partitionByDirectory,
+  "name-prefix": partitionByNamePrefix
+};
+function deterministicCascade(skills) {
+  for (const name of ["metadata", "directory", "name-prefix"]) {
+    const groups = deterministicFns[name](skills);
+    if (groups !== null) {
+      return { strategy: name, groups };
+    }
+  }
+  return null;
+}
+async function partitionSkills(skills, options = {}) {
+  const strategy = options.strategy ?? DEFAULT_STRATEGY;
+  const warnings = [];
+  let llmFailure;
+  const deterministic = (d2) => d2 === null ? { groups: null, provenance: { kind: "none", ...llmFailure !== undefined ? { llmFailure } : {} }, warnings } : {
+    groups: d2.groups,
+    provenance: { kind: "deterministic", strategy: d2.strategy, ...llmFailure !== undefined ? { llmFailure } : {} },
+    warnings
+  };
+  if (options.markerGroups !== undefined && options.markerGroups.length > 0) {
+    const { groups: matched, unmatched, duplicates, fuzzyMatched, leftover } = matchMarkerGroups(skills, options.markerGroups);
+    if (matched.length === 0) {
+      warnings.push(`no path in .ccpluginizer.json "groups" matched a skill directory (expected paths like "./<skill-dir>/"); ignoring the frozen split — re-run scan --write-marker to refresh it.`);
+      if (options.markerMandatory === true) {
+        return { groups: null, provenance: { kind: "none" }, warnings };
+      }
+    } else {
+      if (unmatched.length > 0) {
+        warnings.push(`${String(unmatched.length)} path(s) in .ccpluginizer.json "groups" match no skill directory (${preview(unmatched)}); re-run scan --write-marker to refresh the frozen split.`);
+      }
+      if (fuzzyMatched.length > 0) {
+        warnings.push(`${String(fuzzyMatched.length)} path(s) in .ccpluginizer.json "groups" matched a skill by directory name only (${preview(fuzzyMatched)}); update the marker paths or re-run scan --write-marker.`);
+      }
+      if (duplicates.length > 0) {
+        warnings.push(`${String(duplicates.length)} path(s) in .ccpluginizer.json "groups" appear in more than one group; the first occurrence wins (${preview(duplicates)}) — fix the marker or re-run scan --write-marker.`);
+      }
+      let groups2 = matched;
+      if (leftover.length > 0) {
+        warnings.push(`${String(leftover.length)} skill(s) not listed in .ccpluginizer.json "groups" were placed in a "${MISC}" slice; re-run scan --write-marker to refresh the frozen split.`);
+        groups2 = [...matched, { slug: MISC, skills: leftover }];
+      }
+      return { groups: finalizeGroups(groups2), provenance: { kind: "marker" }, warnings };
+    }
+  }
+  const runLlm = async () => {
+    if (options.group === undefined) {
+      llmFailure = { step: "no-backend" };
+      return null;
+    }
+    let run;
+    try {
+      run = await options.group(skills);
+    } catch {
+      llmFailure = { step: "errored" };
+      return null;
+    }
+    if (run === null) {
+      llmFailure = { step: "no-backend" };
+      return null;
+    }
+    const raw = validRawItems(run.groups);
+    if (raw.length === 0) {
+      llmFailure = { step: "no-output", backend: run.kind };
+      return null;
+    }
+    const gated = gateRaw(skills, raw);
+    if (gated === null) {
+      llmFailure = { step: "gate-rejected", backend: run.kind };
+      return null;
+    }
+    run.commit?.();
+    return { backend: run.kind, groups: gated };
+  };
+  if (strategy === "auto") {
+    return deterministic(deterministicCascade(skills));
+  }
+  if (strategy === "llm") {
+    const won = await runLlm();
+    if (won !== null) {
+      return { groups: won.groups, provenance: { kind: "llm", backend: won.backend }, warnings };
+    }
+    return deterministic(deterministicCascade(skills));
+  }
+  if (strategy === "auto-llm") {
+    const d2 = deterministicCascade(skills);
+    if (d2 !== null) {
+      return deterministic(d2);
+    }
+    const won = await runLlm();
+    if (won !== null) {
+      return { groups: won.groups, provenance: { kind: "llm", backend: won.backend }, warnings };
+    }
+    return deterministic(null);
+  }
+  const groups = deterministicFns[strategy](skills);
+  return deterministic(groups === null ? null : { strategy, groups });
+}
+
 // src/detector/synthesize.ts
-function synthesizeEntry(input) {
+var DEFAULT_MIN_SKILLS_TO_SPLIT = 25;
+var SKIPPED = { kind: "skipped" };
+async function synthesizeEntries(input) {
+  const wantSplit = input.split ?? true;
+  const marker = input.existingMarker !== undefined ? input.existingMarker : detectMarkerFile(input.repoRoot);
+  const caches = input.caches ?? makeScanCaches();
+  const skippedPaths = caches.skippedPaths ?? [];
+  const skipWarnings = () => skippedPaths.length > 0 ? [
+    `${String(skippedPaths.length)} unreadable path(s) were skipped during detection (permission denied), e.g. "${skippedPaths[0] ?? ""}" — the emitted entries may be incomplete.`
+  ] : [];
+  const attempt = wantSplit && (marker === null || !markerSuppressesSplit(marker)) ? await attemptSplit(input, marker, caches, skipWarnings) : null;
+  if (attempt !== null && attempt.fulfilled !== null) {
+    return attempt.fulfilled;
+  }
   checkMarketplaceGuard(input.repoRoot);
-  const marker = detectMarkerFile(input.repoRoot);
+  const entries = [synthesizeEntryWithMarker(input, marker, caches)];
+  return {
+    entries,
+    split: null,
+    provenance: attempt?.provenance ?? SKIPPED,
+    marker: null,
+    existingMarker: marker,
+    warnings: [...attempt?.warnings ?? [], ...skipWarnings()],
+    caches
+  };
+}
+async function attemptSplit(input, marker, caches, skipWarnings) {
+  const minSkills = input.minSkillsToSplit ?? DEFAULT_MIN_SKILLS_TO_SPLIT;
+  const resolver = createLayoutResolver(input.repoRoot, caches);
+  const none = (provenance2, warnings) => ({
+    fulfilled: null,
+    provenance: provenance2,
+    warnings: [...resolver.warnings, ...warnings]
+  });
+  const frozen = marker !== null;
+  if (resolver.skillsContainer === null) {
+    return none(SKIPPED, frozen ? [".ccpluginizer.json freezes a split, but no skills container was found; ignoring the frozen groups and emitting a single entry."] : []);
+  }
+  const skills = enumerateSkills(resolver.skillsContainer.absDir, resolver.list, resolver.readFrontmatter);
+  if (!frozen && skills.length < minSkills) {
+    return none(SKIPPED, []);
+  }
+  const unparsed = countSkillMdDirs(resolver.skillsContainer.absDir, resolver.list) - skills.length;
+  const unparsedWarnings = unparsed > 0 ? [
+    `${String(unparsed)} skill ${unparsed === 1 ? "directory" : "directories"} inside "${resolver.skillsContainer.relPath}" ${unparsed === 1 ? "has" : "have"} missing or invalid SKILL.md frontmatter and ${unparsed === 1 ? "is" : "are"} not covered by any emitted slice; fix the frontmatter so they are detected.`
+  ] : [];
+  const recuration = isAlreadyMarketplace(input.repoRoot);
+  const recurationWarnings = recuration ? [
+    "this repo already publishes a marketplace (.claude-plugin/marketplace.json); the split re-curates it deterministically (the LLM step is never consulted here). Install via `/plugin marketplace add` instead if you just want the existing catalog."
+  ] : [];
+  const markerMandatory = frozen && skills.length < minSkills;
+  const { groups, provenance, warnings: partitionWarnings } = await partitionSkills(skills, {
+    strategy: input.strategy ?? DEFAULT_STRATEGY,
+    ...frozen ? { markerGroups: marker.groups ?? [] } : {},
+    ...input.group !== undefined && !recuration ? { group: input.group } : {},
+    ...markerMandatory ? { markerMandatory: true } : {}
+  });
+  if (groups === null) {
+    return none(markerMandatory ? SKIPPED : provenance, [...partitionWarnings, ...unparsedWarnings]);
+  }
+  const layout = resolver.full();
+  const markerDrives = provenance.kind === "marker";
+  const componentCurationWarnings = markerDrives && marker !== null && hasComponentCuration(marker) ? [
+    "the component fields in .ccpluginizer.json (skills/agents/mcpServers/...) apply only to the single-entry path; the split derives its core from the repo layout."
+  ] : [];
+  const { entries, marker: markerDraft, agentsDropped, coreEmitted } = buildSplitEntries(groups, layout, resolver.skillsContainer, input.sourceRepo, {
+    umbrella: (input.umbrella ?? false) || markerDrives && (marker?.umbrella ?? false),
+    emitCore: markerDrives ? marker?.core ?? true : true,
+    ...markerDrives && marker?.name !== undefined ? { markerName: marker.name } : {}
+  });
+  return {
+    fulfilled: {
+      entries,
+      split: { groupCount: groups.length, coreEmitted, umbrellaEmitted: markerDraft.umbrella },
+      provenance,
+      marker: markerDraft,
+      existingMarker: marker,
+      warnings: [
+        ...resolver.warnings,
+        ...partitionWarnings,
+        ...unparsedWarnings,
+        ...componentCurationWarnings,
+        ...recurationWarnings,
+        ...collectSplitWarnings(layout, input.sourceRepo, coreEmitted, markerDraft.umbrella, agentsDropped),
+        ...skipWarnings()
+      ],
+      caches
+    }
+  };
+}
+function collectSplitWarnings(layout, sourceRepo, coreEmitted, umbrellaEmitted, agentsDropped) {
+  const warnings = [];
+  if (layout.mcp !== null) {
+    if (coreEmitted && layout.mcp.serverType === "repo-local") {
+      warnings.push(`The MCP server in "${layout.mcp.relPath}" references repo-local files; inlined into core it may not resolve at install time. Review its command/args paths, or keep the MCP via --umbrella.`);
+    } else if (!coreEmitted && !umbrellaEmitted) {
+      warnings.push(`The MCP server in "${layout.mcp.relPath}" is not carried by any emitted entry (no core entry was emitted and no umbrella was requested); it will be dropped. Use --umbrella, or a marker with "core": true, to retain it.`);
+    }
+  }
+  const umbrellaRootForAgents = layout.pluginRoot?.relPath ?? ".";
+  const umbrellaCarriesAgents = umbrellaEmitted && layout.agentsContainer !== null && (umbrellaRootForAgents === "." || layout.agentsContainer.relPath === umbrellaRootForAgents || layout.agentsContainer.relPath.startsWith(`${umbrellaRootForAgents}/`));
+  if (layout.agentsContainer !== null && !umbrellaCarriesAgents) {
+    if (agentsDropped) {
+      warnings.push(`The agents in "${layout.agentsContainer.relPath}" are not carried by the core entry (no safe core root exists — rooting it would auto-load a skills/ tree always-on); they will be dropped. Use --umbrella to retain them.`);
+    } else if (!coreEmitted) {
+      warnings.push(`The agents in "${layout.agentsContainer.relPath}" are not carried by any emitted entry (no core entry was emitted and no umbrella was requested); they will be dropped. Use --umbrella, or a marker with "core": true, to retain them.`);
+    }
+  }
+  const umbrellaRoot = layout.pluginRoot?.relPath ?? ".";
+  const underUmbrella = (rel) => umbrellaRoot === "." || rel === umbrellaRoot || rel.startsWith(`${umbrellaRoot}/`);
+  const carriable = layout.artifacts.filter((a3) => underUmbrella(a3.relPath));
+  const outside = layout.artifacts.filter((a3) => !underUmbrella(a3.relPath));
+  if (!umbrellaEmitted && carriable.length > 0) {
+    warnings.push(`Split entries do not carry these non-skill artifacts: ${carriable.map((a3) => a3.kind).join(", ")}. Use --umbrella to retain them, or --no-split for a single entry.`);
+  }
+  if (outside.length > 0) {
+    warnings.push(`These non-skill artifacts sit outside the plugin root, so no emitted entry (umbrella included) carries them: ${outside.map((a3) => a3.kind).join(", ")}. Use --no-split for a single entry.`);
+  }
+  if (layout.skillDirsOutsideContainer > 0 && layout.skillsContainer !== null) {
+    const n2 = layout.skillDirsOutsideContainer;
+    warnings.push(`${String(n2)} skill ${n2 === 1 ? "directory" : "directories"} outside "${layout.skillsContainer.relPath}" ${n2 === 1 ? "is" : "are"} not covered by the split; use --no-split for a single entry that detects the whole repo.`);
+  }
+  if (sourceRepo.startsWith("local/")) {
+    warnings.push(`Source is a local path; emitted git-subdir URLs are placeholders ("https://github.com/${sourceRepo}.git"). Set the real repository before publishing.`);
+  }
+  return warnings;
+}
+function synthesizeEntryWithMarker(input, marker, caches) {
   if (marker !== null) {
+    if (isFreezeOnlyMarker(marker)) {
+      return {
+        ...synthesizeEntryFromDetection(input, caches),
+        name: marker.name,
+        ...markerIdentity(marker)
+      };
+    }
     return buildEntryFromMarker(marker, input.sourceRepo, input.repoRoot);
   }
-  const conventionFindings = detectConventions(input.repoRoot);
+  return synthesizeEntryFromDetection(input, caches);
+}
+function markerIdentity(marker) {
+  return {
+    ...marker.description !== undefined ? { description: marker.description } : {},
+    ...marker.license !== undefined ? { license: marker.license } : {},
+    ...marker.homepage !== undefined ? { homepage: marker.homepage } : {},
+    ...marker.repository !== undefined ? { repository: marker.repository } : {}
+  };
+}
+function synthesizeEntryFromDetection(input, caches) {
+  const conventionFindings = detectConventions(input.repoRoot, caches);
   const manifestResult = detectNonStandardManifest(input.repoRoot);
-  const sniffFindings = detectContentSniff(input.repoRoot);
+  const sniffFindings = detectContentSniff(input.repoRoot, caches);
   const findings = [...conventionFindings];
   const manifestKindsWithFindings = new Set;
   if (manifestResult !== null) {
     addManifestFindings(findings, manifestResult.manifest, manifestKindsWithFindings);
   }
-  let mergedFindings = findings.filter((f) => {
-    if (f.source === "convention" && manifestKindsWithFindings.has(f.kind)) {
+  let mergedFindings = findings.filter((f2) => {
+    if (f2.source === "convention" && manifestKindsWithFindings.has(f2.kind)) {
       return false;
     }
     return true;
@@ -2086,10 +3946,7 @@ function buildEntryFromMarker(marker, sourceRepo, repoRoot) {
     name: marker.name,
     source: makeGithubSource(sourceRepo),
     strict: false,
-    ...marker.description !== undefined ? { description: marker.description } : {},
-    ...marker.license !== undefined ? { license: marker.license } : {},
-    ...marker.homepage !== undefined ? { homepage: marker.homepage } : {},
-    ...marker.repository !== undefined ? { repository: marker.repository } : {},
+    ...markerIdentity(marker),
     ...skills !== undefined ? { skills } : {},
     ...agents !== undefined ? { agents } : {},
     ...commands !== undefined ? { commands } : {},
@@ -2104,7 +3961,7 @@ function buildEntryFromFindings(findings, repoRoot, sourceRepo) {
   const byKind = groupByKind(findings);
   const componentEntries = {};
   for (const [kind, kindFindings] of byKind) {
-    const allPaths = kindFindings.flatMap((f) => f.paths);
+    const allPaths = kindFindings.flatMap((f2) => f2.paths);
     const { kept } = normalizePathsAgainstRepo(repoRoot, allPaths);
     if (kept.length > 0) {
       componentEntries[kind] = kept;
@@ -2118,8 +3975,8 @@ function buildEntryFromFindings(findings, repoRoot, sourceRepo) {
   };
 }
 function hasKind(findings, kind) {
-  for (const f of findings) {
-    if (f.kind === kind) {
+  for (const f2 of findings) {
+    if (f2.kind === kind) {
       return true;
     }
   }
@@ -2127,95 +3984,828 @@ function hasKind(findings, kind) {
 }
 function groupByKind(findings) {
   const map = new Map;
-  for (const f of findings) {
-    const list = map.get(f.kind) ?? [];
-    list.push(f);
-    map.set(f.kind, list);
+  for (const f2 of findings) {
+    const list = map.get(f2.kind) ?? [];
+    list.push(f2);
+    map.set(f2.kind, list);
   }
   return map;
 }
+function sourceRepoUrl(repo) {
+  return `https://github.com/${repo}.git`;
+}
 function makeGithubSource(repo) {
-  return { source: "url", url: `https://github.com/${repo}.git` };
+  return { source: "url", url: sourceRepoUrl(repo) };
+}
+function makeGitSubdirSource(repo, path) {
+  return { source: "git-subdir", url: sourceRepoUrl(repo), path };
 }
 function defaultEntryName(sourceRepo) {
-  return sourceRepo.replace("/", "-").toLowerCase();
+  return slugify(sourceRepo);
+}
+function serializeMarkerDraft(draft, existing) {
+  const draftOwned = new Set(Object.keys(draft));
+  const preserved = {};
+  if (existing !== null) {
+    for (const [key, value] of Object.entries(existing)) {
+      if (!draftOwned.has(key) && value !== undefined) {
+        preserved[key] = value;
+      }
+    }
+  }
+  const merged = {
+    ...draft,
+    ...draft.umbrella ? {} : { umbrella: undefined },
+    ...preserved
+  };
+  parse(MarkerFileSchema, JSON.parse(JSON.stringify(merged)));
+  return merged;
+}
+function buildSplitEntries(groups, layout, skillsContainer, sourceRepo, options) {
+  const base = slugify(options.markerName ?? defaultEntryName(sourceRepo));
+  const entries = [];
+  if (options.umbrella) {
+    entries.push(buildUmbrellaEntry(base, groups, layout, skillsContainer, sourceRepo));
+  }
+  const core = options.emitCore ? buildCoreEntry(`${base}-core`, layout, skillsContainer, sourceRepo) : { entry: null, agentsDropped: false };
+  if (core.entry !== null) {
+    entries.push(core.entry);
+  }
+  const reservedSlugs = core.entry !== null ? ["core"] : [];
+  const slugs = uniqueSlugs([...reservedSlugs, ...groups.map((g) => g.slug)]).slice(reservedSlugs.length);
+  const markerGroups = [];
+  groups.forEach((group, i3) => {
+    const slug = slugs[i3] ?? group.slug;
+    const skills = group.skills.map((s3) => s3.path);
+    markerGroups.push({ slug, skills });
+    entries.push({
+      name: `${base}-${slug}`,
+      source: makeGitSubdirSource(sourceRepo, skillsContainer.relPath),
+      strict: false,
+      skills,
+      ...core.entry !== null ? { dependencies: [core.entry.name] } : {}
+    });
+  });
+  return {
+    entries,
+    marker: { name: base, core: options.emitCore, umbrella: options.umbrella, groups: markerGroups },
+    agentsDropped: core.agentsDropped,
+    coreEmitted: core.entry !== null
+  };
+}
+function buildUmbrellaEntry(base, groups, layout, skillsContainer, sourceRepo) {
+  const root = layout.pluginRoot?.relPath;
+  const rootContainsSkills = root !== undefined && (root === "." || skillsContainer.relPath === root || skillsContainer.relPath.startsWith(`${root}/`));
+  if (root !== undefined && rootContainsSkills) {
+    return {
+      name: base,
+      source: makeGitSubdirSource(sourceRepo, root),
+      strict: true
+    };
+  }
+  const artifact = (kind) => layout.artifacts.find((a3) => a3.kind === kind)?.relPath;
+  const skills = groups.flatMap((g) => g.skills).map((s3) => repoRelPath(skillsContainer.relPath, s3.path)).sort(byCodeUnit);
+  const agents = layout.agentsContainer;
+  const hooks = artifact("hooks");
+  const commands = artifact("commands");
+  const outputStyles = artifact("output-styles");
+  const themes = artifact("themes");
+  const monitors = artifact("monitors");
+  return {
+    name: base,
+    source: makeGitSubdirSource(sourceRepo, "."),
+    strict: false,
+    ...skills.length > 0 ? { skills } : {},
+    ...agents !== null ? { agents: agents.files.map((f2) => repoRelPath(agents.relPath, f2)) } : {},
+    ...layout.mcp !== null ? { mcpServers: layout.mcp.servers } : {},
+    ...hooks !== undefined ? { hooks: `./${hooks}` } : {},
+    ...commands !== undefined ? { commands: [`./${commands}/`] } : {},
+    ...outputStyles !== undefined ? { outputStyles: [`./${outputStyles}/`] } : {},
+    ...themes !== undefined ? { themes: [`./${themes}/`] } : {},
+    ...monitors !== undefined ? { monitors: `./${monitors}` } : {}
+  };
+}
+function repoRelPath(containerRel, p2) {
+  const inner = p2.startsWith("./") ? p2.slice(2) : p2;
+  return containerRel === "." ? `./${inner}` : `./${containerRel}/${inner}`;
+}
+function buildCoreEntry(name, layout, skillsContainer, sourceRepo) {
+  const agents = layout.agentsContainer;
+  const mcp = layout.mcp;
+  if (agents === null && mcp === null) {
+    return { entry: null, agentsDropped: false };
+  }
+  const carriesAgents = agents !== null && !agents.hasSkillsChild;
+  const rootPath = carriesAgents ? agents.relPath : skillsContainer.hasSkillsChild ? null : skillsContainer.relPath;
+  if (rootPath === null || !carriesAgents && mcp === null) {
+    return { entry: null, agentsDropped: agents !== null };
+  }
+  return {
+    entry: {
+      name,
+      source: makeGitSubdirSource(sourceRepo, rootPath),
+      strict: false,
+      ...carriesAgents ? { agents: agents.files.map((f2) => `./${f2}`) } : {},
+      ...mcp !== null ? { mcpServers: mcp.servers } : {}
+    },
+    agentsDropped: agents !== null && !carriesAgents
+  };
+}
+
+// src/detector/validateEntries.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import { basename as basename3, join as join10 } from "node:path";
+function validateEntries(items, sources) {
+  const errors = [];
+  const entries = [];
+  const nameSource = new Map;
+  const label = (i3) => sources?.[i3] ?? `entry[${String(i3)}]`;
+  items.forEach((item, i3) => {
+    const result = safeParse(MarketplaceEntrySchema, item);
+    if (!result.success) {
+      const detail = result.issues.map((issue) => {
+        const path = getDotPath(issue);
+        return path === null ? issue.message : `${path}: ${issue.message}`;
+      }).join("; ");
+      errors.push(`${label(i3)}: ${detail}`);
+      return;
+    }
+    const name = result.output.name;
+    const firstSource = nameSource.get(name);
+    if (firstSource !== undefined) {
+      errors.push(`duplicate entry name: ${name} (${label(i3)} also declared in ${firstSource})`);
+      return;
+    }
+    nameSource.set(name, label(i3));
+    entries.push(result.output);
+  });
+  return { ok: errors.length === 0, errors, entries };
+}
+function collectEntries(path, options = {}) {
+  if (!existsSync5(path)) {
+    throw new Error(`No such file or directory: ${path}`);
+  }
+  const items = [];
+  const sources = [];
+  const add = (parsed, fileLabel) => {
+    const list = toEntryList(parsed);
+    if (list.length === 0) {
+      throw new Error(`No entries found in: ${fileLabel}`);
+    }
+    list.forEach((item, i3) => {
+      items.push(item);
+      sources.push(list.length > 1 ? `${fileLabel}[${String(i3)}]` : fileLabel);
+    });
+  };
+  if (statSync3(path).isDirectory()) {
+    const files = readdirSync3(path).filter((f2) => f2.endsWith(".json")).sort();
+    if (files.length === 0 && options.allowEmptyDir !== true) {
+      throw new Error(`No entry JSON files (*.json) found in directory: ${path}`);
+    }
+    for (const f2 of files) {
+      add(readJsonFile(join10(path, f2)), f2);
+    }
+  } else {
+    add(readJsonFile(path), basename3(path));
+  }
+  return { items, sources };
+}
+function toEntryList(parsed) {
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+
+// src/commands/llmGrouper.ts
+import { spawn, spawnSync as spawnSync2 } from "node:child_process";
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import { mkdirSync, statSync as statSync4, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join11 } from "node:path";
+var MAX_BUFFER_BYTES = 32 * 1024 * 1024;
+function buildClusterPrompt(skills) {
+  const lines = skills.map((s3) => {
+    const product = s3.product !== undefined ? ` [product=${s3.product}]` : "";
+    const desc = s3.description.replace(/\s+/g, " ").trim().slice(0, 140);
+    return `- ${s3.dir}${product}: ${desc}`;
+  });
+  return [
+    "You are grouping Claude Code skills into a small number of coherent product domains.",
+    "",
+    "Rules:",
+    `- Produce between ${String(MIN_K)} and ${String(MAX_K)} groups.`,
+    "- Every skill must appear in exactly one group (disjoint, total cover).",
+    `- No group may contain more than ~${String(Math.round(MAX_FRACTION * 100))}% of all skills.`,
+    "- Group by product/domain meaning, not by programming language.",
+    '- Each group needs a short kebab-case "slug" (e.g. "messaging", "voice").',
+    "",
+    "Skills:",
+    ...lines,
+    "",
+    'Respond with ONLY a JSON array, no prose: [{"slug":"...","members":["<skill-dir>",...]}, ...]'
+  ].join(`
+`);
+}
+var MAX_ARRAY_CANDIDATES = 50;
+function parseClusterResponse(text, validDirs) {
+  let candidates = 0;
+  for (let start = text.indexOf("[");start !== -1; start = text.indexOf("[", start + 1)) {
+    if (++candidates > MAX_ARRAY_CANDIDATES) {
+      break;
+    }
+    const end = balancedArrayEnd(text, start);
+    if (end === -1) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text.slice(start, end + 1));
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(parsed)) {
+      continue;
+    }
+    const groups = [];
+    for (const item of parsed) {
+      const r2 = safeParse(RawGroupSchema, item);
+      if (!r2.success) {
+        continue;
+      }
+      const members = r2.output.members.filter((m2) => validDirs.has(m2));
+      if (members.length > 0) {
+        groups.push({ slug: r2.output.slug, members });
+      }
+    }
+    if (groups.length > 0) {
+      return groups;
+    }
+  }
+  return null;
+}
+function balancedArrayEnd(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i3 = start;i3 < text.length; i3++) {
+    const ch = text[i3];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "[" || ch === "{") {
+      depth++;
+    } else if (ch === "]" || ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return ch === "]" ? i3 : -1;
+      }
+      if (depth < 0) {
+        return -1;
+      }
+    }
+  }
+  return -1;
+}
+function validateRawGroups(parsed) {
+  const r2 = safeParse(RawGroupsSchema, parsed);
+  return r2.success ? r2.output : null;
+}
+function spawnGroupRun(command, args, options) {
+  return new Promise((resolve2) => {
+    const win = process.platform === "win32";
+    let child;
+    try {
+      child = spawn(command, [...args], {
+        stdio: ["pipe", "pipe", "inherit"],
+        detached: !win,
+        windowsVerbatimArguments: win
+      });
+    } catch (e3) {
+      resolve2({ error: e3 instanceof Error ? e3 : new Error(String(e3)), signal: null, status: null, stdout: null });
+      return;
+    }
+    let stdout = "";
+    let stdoutBytes = 0;
+    let timedOut = false;
+    let overflowed = false;
+    let settled = false;
+    const timers = [];
+    const killTree = (sig) => {
+      try {
+        if (!win && child.pid !== undefined) {
+          process.kill(-child.pid, sig);
+        } else if (win && child.pid !== undefined) {
+          spawnSync2("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+        } else {
+          child.kill(sig);
+        }
+      } catch {
+        try {
+          child.kill(sig);
+        } catch {}
+      }
+    };
+    const forward = (sig) => () => {
+      killTree(sig);
+      cleanupSignalForwarders();
+      process.kill(process.pid, sig);
+    };
+    const onSigint = forward("SIGINT");
+    const onSighup = forward("SIGHUP");
+    const onSigterm = forward("SIGTERM");
+    const onExit = () => {
+      killTree("SIGKILL");
+    };
+    const cleanupSignalForwarders = () => {
+      process.removeListener("SIGINT", onSigint);
+      process.removeListener("SIGHUP", onSighup);
+      process.removeListener("SIGTERM", onSigterm);
+    };
+    const cleanupForwarders = () => {
+      cleanupSignalForwarders();
+      process.removeListener("exit", onExit);
+    };
+    process.once("SIGINT", onSigint);
+    process.once("SIGHUP", onSighup);
+    process.once("SIGTERM", onSigterm);
+    process.on("exit", onExit);
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      for (const t2 of timers) {
+        clearTimeout(t2);
+      }
+      if (!win || timedOut || overflowed || viaExitGrace || result.error !== undefined) {
+        killTree("SIGKILL");
+      }
+      child.stdout?.destroy();
+      cleanupForwarders();
+      resolve2(result);
+    };
+    const schedule = (fn, ms) => {
+      const t2 = setTimeout(fn, ms);
+      t2.unref();
+      timers.push(t2);
+    };
+    schedule(() => {
+      timedOut = true;
+      killTree("SIGTERM");
+      schedule(() => {
+        killTree("SIGKILL");
+      }, 2000);
+    }, options.timeout);
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+      stdoutBytes += Buffer.byteLength(chunk, "utf8");
+      if (!overflowed && stdoutBytes > options.maxBuffer) {
+        overflowed = true;
+        killTree("SIGKILL");
+      }
+    });
+    let viaExitGrace = false;
+    const outcome = (status, signal) => ({
+      ...timedOut ? { error: new Error("ETIMEDOUT: LLM backend timed out") } : overflowed ? { error: new Error("LLM backend exceeded the output cap") } : {},
+      signal,
+      status,
+      stdout
+    });
+    child.on("error", (error) => {
+      finish({ error, signal: null, status: null, stdout: null });
+    });
+    child.on("close", (status, signal) => {
+      finish(outcome(status, signal));
+    });
+    child.on("exit", (status, signal) => {
+      schedule(() => {
+        viaExitGrace = true;
+        finish(outcome(status, signal));
+      }, 1000);
+    });
+    child.stdin?.on("error", () => {
+      return;
+    });
+    if (options.input !== undefined) {
+      child.stdin?.write(options.input);
+    }
+    child.stdin?.end();
+  });
+}
+function resolveGrouper(opts, deps = {}) {
+  const run = deps.run ?? spawnGroupRun;
+  const whichFn = deps.which ?? which;
+  const cacheDirFn = deps.cacheDir ?? defaultCacheDir;
+  if (opts.cmd !== undefined) {
+    const cmd = opts.cmd;
+    const [shell, shellArgs] = process.platform === "win32" ? ["cmd", ["/d", "/s", "/c", `"${cmd}"`]] : ["sh", ["-c", cmd]];
+    let noticeShown = false;
+    const renderEnvNotice = deps.onEnvCmdRun ?? ((c3) => {
+      console.error(`ccpluginizer: running LLM grouper from CCPLUGINIZER_LLM_CMD: ${c3}`);
+    });
+    const onRun = opts.cmdFromEnv ? () => {
+      if (!noticeShown) {
+        noticeShown = true;
+        renderEnvNotice(cmd);
+      }
+    } : undefined;
+    return {
+      fn: makeCachedGrouper("subprocess", `cmd:${cmd}`, cacheDirFn, (prompt) => run(shell, shellArgs, {
+        input: prompt,
+        maxBuffer: MAX_BUFFER_BYTES,
+        timeout: opts.timeoutMs
+      }), onRun),
+      backendId: cmd,
+      kind: "subprocess"
+    };
+  }
+  const claude = whichFn("claude");
+  if (claude !== null) {
+    const winShim = process.platform === "win32" && /\.(?:cmd|bat)$/i.test(claude);
+    const [cmd, cmdArgs] = winShim ? ["cmd", ["/d", "/s", "/c", `""${claude}" -p"`]] : [claude, ["-p"]];
+    return {
+      fn: makeCachedGrouper("claude", "claude-cli", cacheDirFn, (prompt) => run(cmd, cmdArgs, {
+        input: prompt,
+        maxBuffer: MAX_BUFFER_BYTES,
+        timeout: opts.timeoutMs
+      })),
+      backendId: "claude",
+      kind: "claude"
+    };
+  }
+  return null;
+}
+function makeCachedGrouper(kind, cacheId, cacheDir, invoke, onRun) {
+  return async (skills) => {
+    const dir = ensureCacheDir(cacheDir);
+    const cacheKey = hashSkills(skills, cacheId);
+    const cached = dir === null ? null : readCacheFile(join11(dir, `${cacheKey}.json`));
+    if (cached !== null) {
+      return { kind, groups: cached };
+    }
+    onRun?.();
+    const result = await invoke(buildClusterPrompt(skills));
+    const stdout = result.stdout;
+    if (isSpawnFailure(result) || stdout === null) {
+      return { kind, groups: [] };
+    }
+    const validDirs = new Set(skills.map((s3) => s3.dir));
+    const groups = parseClusterResponse(stdout, validDirs) ?? [];
+    if (groups.length === 0 || dir === null) {
+      return { kind, groups };
+    }
+    return {
+      kind,
+      groups,
+      commit: () => {
+        writeCacheFile(join11(dir, `${cacheKey}.json`), groups);
+      }
+    };
+  };
+}
+function isSpawnFailure(result) {
+  return result.error !== undefined || result.signal !== null || result.status !== null && result.status !== 0;
+}
+function which(cmd) {
+  if (typeof Bun !== "undefined") {
+    return Bun.which(cmd);
+  }
+  const finder = process.platform === "win32" ? "where" : "which";
+  const r2 = spawnSync2(finder, [cmd], { encoding: "utf8" });
+  const out = typeof r2.stdout === "string" ? (r2.stdout.split(`
+`)[0] ?? "").trim() : "";
+  return r2.status === 0 && out !== "" ? out : null;
+}
+function hashSkills(skills, backendId) {
+  const material = JSON.stringify([
+    backendId,
+    skills.map((s3) => JSON.stringify([s3.dir, s3.product ?? "", s3.description])).sort(byCodeUnit)
+  ]);
+  return createHash("sha256").update(material).digest("hex").slice(0, 32);
+}
+function defaultCacheDir() {
+  return join11(homedir(), ".cache", "ccpluginizer");
+}
+function ensureCacheDir(dirFn) {
+  const dir = dirFn();
+  try {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  } catch {
+    return null;
+  }
+  let st;
+  try {
+    st = statSync4(dir);
+  } catch {
+    return null;
+  }
+  if (!st.isDirectory()) {
+    return null;
+  }
+  const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+  if (uid !== undefined && (st.uid !== uid || (st.mode & 63) !== 0)) {
+    return null;
+  }
+  return dir;
+}
+function readCacheFile(file) {
+  try {
+    return validateRawGroups(readJsonFile(file));
+  } catch {
+    return null;
+  }
+}
+function writeCacheFile(file, groups) {
+  try {
+    writeFileSync(file, JSON.stringify(groups), "utf8");
+  } catch {}
 }
 
 // src/commands/scan.ts
-var scanCommand = new R2("scan").meta({ description: "Scan a non-plugin repo and emit a marketplace entry" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo, URL, or local path" }]).flags({
-  output: { type: "string", short: "o", description: "Write entry JSON to file" }
+var scanCommand = new R2("scan").meta({ description: "Scan a non-plugin repo and emit a marketplace entry (auto-splits bloated plugins)" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo, URL, or local path" }]).flags({
+  output: { type: "string", short: "o", description: "Write the entry/entries JSON to a single file" },
+  outDir: { type: "string", aliases: ["out-dir"], description: "Write one JSON file per entry into this directory" },
+  split: { type: "boolean", default: true, description: "Auto-split bloated plugins (use --no-split to force one entry)" },
+  umbrella: { type: "boolean", default: false, description: "Also emit the everything-in-one umbrella entry" },
+  cluster: { type: "string", default: DEFAULT_STRATEGY, description: "Clustering strategy: auto (deterministic, default) | auto-llm (deterministic, then BYO LLM on no clean partition) | llm (opt-in BYO subprocess/claude) | metadata | directory | name-prefix" },
+  llmCmd: { type: "string", aliases: ["llm-cmd"], description: "BYO LLM grouper command (prompt on stdin, JSON groups on stdout); used by --cluster=llm/auto-llm" },
+  llmTimeout: { type: "number", aliases: ["llm-timeout"], description: "LLM backend timeout in seconds (default 120)" },
+  writeMarker: { type: "boolean", default: false, aliases: ["write-marker"], description: "Freeze the grouping into .ccpluginizer.json" },
+  interactive: { type: "boolean", default: false, description: "Review the proposed split before emitting" },
+  minSkills: { type: "number", default: DEFAULT_MIN_SKILLS_TO_SPLIT, aliases: ["min-skills"], description: "Minimum skill count to attempt a split" }
 }).run(async ({ args, flags }) => {
+  const requestedCluster = normalizeStrategy(flags.cluster);
+  const wantSplit = flags.split;
+  if (!wantSplit && flags.umbrella) {
+    console.error("ccpluginizer: --umbrella is ignored with --no-split (the umbrella only exists on the split path).");
+  }
+  const minSkills = Number.isFinite(flags.minSkills) && flags.minSkills >= 0 ? flags.minSkills : DEFAULT_MIN_SKILLS_TO_SPLIT;
+  if (minSkills !== flags.minSkills) {
+    console.error(`ccpluginizer: invalid --min-skills ${String(flags.minSkills)}; using ${String(DEFAULT_MIN_SKILLS_TO_SPLIT)}.`);
+  }
+  const llmConfig = resolveLlmConfig({
+    ...flags.llmCmd !== undefined ? { llmCmd: flags.llmCmd } : {},
+    ...flags.llmTimeout !== undefined ? { llmTimeout: flags.llmTimeout } : {}
+  });
+  const outputFlags = {
+    output: trimOrUndefined(flags.output),
+    outDir: trimOrUndefined(flags.outDir)
+  };
+  if (outputFlags.outDir !== undefined) {
+    let target = null;
+    try {
+      target = statSync5(outputFlags.outDir);
+    } catch {
+      try {
+        lstatSync(outputFlags.outDir);
+        throw new Error(`--out-dir "${outputFlags.outDir}" is a dangling symlink`);
+      } catch (e3) {
+        if (e3 instanceof Error && e3.message.includes("dangling symlink")) {
+          throw e3;
+        }
+      }
+    }
+    if (target !== null && !target.isDirectory()) {
+      throw new Error(`--out-dir "${outputFlags.outDir}" exists and is not a directory`);
+    }
+  }
   const repoPath = await resolveSource(args.repo);
   const sourceRepo = inferSourceRepo(args.repo);
-  const entry = synthesizeEntry({ repoRoot: repoPath, sourceRepo });
-  const json = JSON.stringify(entry, null, 2);
+  const group = wantSplit && strategyUsesLlm(requestedCluster) ? makeLazyGrouper(llmConfig) : null;
+  let result = await synthesizeEntries({
+    repoRoot: repoPath,
+    sourceRepo,
+    split: wantSplit,
+    umbrella: flags.umbrella,
+    strategy: requestedCluster,
+    minSkillsToSplit: minSkills,
+    ...group !== null ? { group } : {}
+  });
+  const splitCouldHaveUsedLlm = result.provenance.kind !== "skipped" && result.provenance.kind !== "marker";
+  if (wantSplit && !strategyUsesLlm(requestedCluster) && llmConfig.cmd !== undefined && splitCouldHaveUsedLlm) {
+    const source = llmConfig.cmdFromEnv ? "CCPLUGINIZER_LLM_CMD" : "--llm-cmd";
+    console.error(`ccpluginizer: an LLM is configured (${source}) but --cluster=${requestedCluster} is deterministic-only; pass --cluster=llm or --cluster=auto-llm to use it.`);
+  }
+  if (wantSplit && result.existingMarker !== null && markerSuppressesSplit(result.existingMarker) && (requestedCluster !== DEFAULT_STRATEGY || llmConfig.cmd !== undefined)) {
+    console.error('ccpluginizer: the committed .ccpluginizer.json curates a single entry, so --cluster/--llm-cmd were not consulted; remove the marker (or give it "groups") to re-enable splitting.');
+  }
+  const printedWarnings = new Set;
+  const printWarnings = (warnings) => {
+    for (const warning of warnings) {
+      if (!printedWarnings.has(warning)) {
+        printedWarnings.add(warning);
+        console.error(`ccpluginizer: warning: ${warning}`);
+      }
+    }
+  };
+  if (flags.interactive && result.split !== null) {
+    printWarnings(result.warnings);
+    result = await reviewSplit(result, { repoPath, sourceRepo });
+  }
+  if (result.split !== null) {
+    printSplitNotice(result);
+  } else if (result.provenance.kind === "none") {
+    if (result.provenance.llmFailure !== undefined || requestedCluster !== DEFAULT_STRATEGY) {
+      printNoSplitNotice(requestedCluster, result.provenance.llmFailure);
+    }
+  }
+  printWarnings(result.warnings);
+  if (flags.writeMarker) {
+    if (result.marker === null) {
+      console.error("ccpluginizer: --write-marker ignored — no split was emitted, so there is no grouping to freeze.");
+    } else if (parseSourceInput(args.repo).kind !== "local") {
+      console.error("ccpluginizer: --write-marker only works on a local path; a github/URL source is cloned to a temp dir that is discarded. Clone the repo locally, re-run `scan <path> --write-marker`, then commit .ccpluginizer.json.");
+    } else {
+      const markerPath = join12(repoPath, ".ccpluginizer.json");
+      const merged = serializeMarkerDraft(result.marker, result.existingMarker);
+      writeFileSync2(markerPath, JSON.stringify(merged, null, 2) + `
+`, "utf8");
+      console.error(`ccpluginizer: wrote frozen split to ${markerPath}`);
+    }
+  }
+  emitOutput(result.entries, outputFlags, sourceRepo, result.split !== null);
+});
+function normalizeStrategy(value) {
+  if (CLUSTER_STRATEGIES.includes(value)) {
+    return value;
+  }
+  throw new Error(`unknown --cluster "${value}"; expected one of: ${CLUSTER_STRATEGIES.join(", ")}`);
+}
+var DEFAULT_TIMEOUT_SECONDS = 120;
+function trimOrUndefined(value) {
+  if (value === undefined) {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? undefined : trimmed;
+}
+function resolveLlmConfig(flags, env = process.env) {
+  const flagCmd = trimOrUndefined(flags.llmCmd);
+  const envCmd = trimOrUndefined(env["CCPLUGINIZER_LLM_CMD"]);
+  const cmd = flagCmd ?? envCmd;
+  const cmdFromEnv = flagCmd === undefined && envCmd !== undefined;
+  const envTimeout = trimOrUndefined(env["CCPLUGINIZER_LLM_TIMEOUT"]);
+  const resolvedSeconds = flags.llmTimeout ?? (envTimeout !== undefined ? Number(envTimeout) : undefined) ?? DEFAULT_TIMEOUT_SECONDS;
+  const MAX_TIMEOUT_SECONDS = 2147483;
+  const valid = Number.isFinite(resolvedSeconds) && resolvedSeconds > 0;
+  if (!valid && (flags.llmTimeout !== undefined || envTimeout !== undefined)) {
+    console.error(`ccpluginizer: invalid LLM timeout ${String(resolvedSeconds)}; using ${String(DEFAULT_TIMEOUT_SECONDS)}s.`);
+  }
+  const safeSeconds = valid ? Math.min(resolvedSeconds, MAX_TIMEOUT_SECONDS) : DEFAULT_TIMEOUT_SECONDS;
+  return {
+    ...cmd !== undefined ? { cmd } : {},
+    cmdFromEnv,
+    timeoutMs: Math.round(safeSeconds * 1000)
+  };
+}
+function makeLazyGrouper(config, resolve2 = resolveGrouper) {
+  let backend;
+  return async (skills) => {
+    if (backend === undefined) {
+      backend = resolve2(config);
+    }
+    return backend === null ? null : backend.fn(skills);
+  };
+}
+function describeProvenance(provenance) {
+  if (provenance.kind === "marker") {
+    return "via committed marker (.ccpluginizer.json)";
+  }
+  if (provenance.kind === "llm") {
+    return `via ${provenance.backend} clustering`;
+  }
+  return provenance.llmFailure !== undefined ? `via ${provenance.strategy} clustering (${llmFailureReason(provenance.llmFailure)})` : `via ${provenance.strategy} clustering`;
+}
+function llmFailureReason(failure) {
+  if (failure.step === "gate-rejected") {
+    return "the LLM grouping was rejected by the acceptance gate";
+  }
+  if (failure.step === "no-output") {
+    return "the LLM backend was unreachable or produced no usable output";
+  }
+  if (failure.step === "errored") {
+    return "the LLM grouper threw an error";
+  }
+  return "no LLM backend found; set --llm-cmd or install the `claude` CLI";
+}
+function printSplitNotice(result) {
+  if (result.split === null || result.provenance.kind === "none" || result.provenance.kind === "skipped") {
+    return;
+  }
+  const slices = result.split.groupCount;
+  const parts = [`${String(slices)} skill slice${slices === 1 ? "" : "s"}`];
+  if (result.split.coreEmitted) {
+    parts.push("1 core");
+  }
+  if (result.split.umbrellaEmitted) {
+    parts.push("1 umbrella");
+  }
+  const entryCount = result.entries.length;
+  const via = describeProvenance(result.provenance);
+  console.error(`ccpluginizer: split into ${String(entryCount)} ${entryCount === 1 ? "entry" : "entries"} (${parts.join(" + ")}) ${via}. Use --no-split for a single entry.`);
+}
+function printNoSplitNotice(requestedCluster, llmFailure) {
+  const reason = llmFailure !== undefined ? `${llmFailureReason(llmFailure)}, and no clean deterministic partition` : "no clean deterministic partition";
+  console.error(`ccpluginizer: --cluster=${requestedCluster} produced no split — ${reason}; emitting a single entry.`);
+}
+async function reviewSplit(result, ctx, confirmFn = (opts) => wJ(opts)) {
+  if (result.split === null || result.provenance.kind === "none" || result.provenance.kind === "skipped") {
+    return result;
+  }
+  console.error(`ccpluginizer: proposed split — ${describeProvenance(result.provenance)}`);
+  for (const g of result.marker?.groups ?? []) {
+    console.error(`  ${g.slug}: ${String(g.skills.length)} skills`);
+  }
+  const proceed = await confirmFn({
+    message: `Emit this ${String(result.split.groupCount)}-way split?`,
+    default: true
+  });
+  if (proceed) {
+    return result;
+  }
+  const single = await synthesizeEntries({
+    repoRoot: ctx.repoPath,
+    sourceRepo: ctx.sourceRepo,
+    split: false,
+    existingMarker: result.existingMarker,
+    caches: result.caches
+  });
+  console.error("ccpluginizer: split declined; emitting a single entry.");
+  return single;
+}
+function emitOutput(entries, flags, sourceRepo, splitFired) {
+  if (flags.outDir !== undefined) {
+    if (flags.output !== undefined) {
+      console.error("ccpluginizer: both --out-dir and --output given; --output is ignored (writing one file per entry into the directory).");
+    }
+    mkdirSync2(flags.outDir, { recursive: true });
+    for (const entry of entries) {
+      writeFileSync2(join12(flags.outDir, `${entry.name}.json`), JSON.stringify(entry, null, 2) + `
+`, "utf8");
+    }
+    warnAboutStaleEntries(entries, flags.outDir, sourceRepo);
+    console.error(`ccpluginizer: wrote ${String(entries.length)} entr${entries.length === 1 ? "y" : "ies"} to ${flags.outDir}`);
+    return;
+  }
+  const payload = !splitFired && entries.length === 1 ? entries[0] : entries;
+  const json = JSON.stringify(payload, null, 2);
   if (flags.output !== undefined) {
-    writeFileSync(flags.output, json + `
+    writeFileSync2(flags.output, json + `
 `, "utf8");
   } else {
     console.log(json);
   }
-});
-
-// src/commands/validate.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-
-// src/schemas/marketplaceEntry.ts
-var PathString = pipe(string(), startsWith("./"));
-var GithubSourceSchema = strictObject({
-  source: literal("github"),
-  repo: pipe(string(), regex(/^[\w.-]+\/[\w.-]+$/)),
-  ref: optional(string()),
-  sha: optional(string())
-});
-var UrlSourceSchema = strictObject({
-  source: literal("url"),
-  url: string(),
-  ref: optional(string()),
-  sha: optional(string())
-});
-var GitSubdirSourceSchema = strictObject({
-  source: literal("git-subdir"),
-  url: string(),
-  path: string(),
-  ref: optional(string()),
-  sha: optional(string())
-});
-var SourceSchema = union([GithubSourceSchema, UrlSourceSchema, GitSubdirSourceSchema]);
-var MarketplaceEntrySchema = object({
-  name: pipe(string(), regex(/^[a-z0-9][a-z0-9-]*$/)),
-  source: SourceSchema,
-  strict: optional(boolean()),
-  description: optional(string()),
-  version: optional(string()),
-  author: optional(union([string(), object({ name: string() })])),
-  homepage: optional(string()),
-  repository: optional(string()),
-  license: optional(string()),
-  keywords: optional(array(string())),
-  skills: optional(array(PathString)),
-  agents: optional(array(PathString)),
-  commands: optional(array(PathString)),
-  hooks: optional(union([PathString, record(string(), unknown())])),
-  mcpServers: optional(union([PathString, record(string(), unknown())])),
-  outputStyles: optional(array(PathString)),
-  themes: optional(array(PathString)),
-  monitors: optional(PathString)
-});
+}
+function warnAboutStaleEntries(entries, outDir, sourceRepo) {
+  if (sourceRepo.startsWith("local/")) {
+    return;
+  }
+  const current = new Set(entries.map((e3) => `${e3.name}.json`));
+  const expectedUrl = sourceRepoUrl(sourceRepo);
+  const stale = readdirSync4(outDir).filter((f2) => f2.endsWith(".json") && !current.has(f2)).filter((f2) => {
+    try {
+      return entryReferencesUrl(readJsonFile(join12(outDir, f2)), expectedUrl);
+    } catch {
+      return false;
+    }
+  }).sort();
+  if (stale.length > 0) {
+    console.error(`ccpluginizer: warning: ${String(stale.length)} entry file(s) from a previous scan of this repo remain in ${outDir}: ${stale.join(", ")}. Delete them if this regrouping replaced them.`);
+  }
+}
+function entryReferencesUrl(parsed, url) {
+  return toEntryList(parsed).some((item) => {
+    if (item === null || typeof item !== "object") {
+      return false;
+    }
+    const source = item.source;
+    return source !== null && typeof source === "object" && source.url === url;
+  });
+}
 
 // src/commands/validate.ts
-var validateCommand = new R2("validate").meta({ description: "Validate a marketplace entry JSON file against the schema" }).args([{ name: "entryFile", type: "string", required: true, description: "Path to entry JSON file" }]).run(({ args }) => {
-  const raw = readFileSync4(args.entryFile, "utf8");
-  const parsed = JSON.parse(raw);
-  const result = safeParse(MarketplaceEntrySchema, parsed);
-  if (!result.success) {
+var validateCommand = new R2("validate").meta({ description: "Validate marketplace entries against the schema (file, JSON array, or directory)" }).args([
+  { name: "entryFile", type: "string", required: true, description: "Path to an entry JSON file, a JSON array, or a directory of entries" }
+]).run(({ args }) => {
+  const { items, sources } = collectEntries(args.entryFile);
+  const result = validateEntries(items, sources);
+  if (!result.ok) {
     console.error("Validation failed:");
-    for (const issue of result.issues) {
-      console.error(JSON.stringify(issue));
+    for (const error of result.errors) {
+      console.error(`  - ${error}`);
     }
     process.exit(1);
   }
-  console.log("OK");
+  console.log(`OK (${String(items.length)} ${items.length === 1 ? "entry" : "entries"})`);
 });
 
 // src/index.ts