@csark0812/skeleton 3.0.1 → 4.0.1

package/dist/cli.js

@@ -3036,7 +3036,25 @@ var require_utils = __commonJS((exports, module) => {
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
   var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
   var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-  var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+  var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+  var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+  var BYTE_HEX = new Array(256);
+  {
+    const HEX_DIGITS = "0123456789ABCDEF";
+    for (let i = 0;i < 256; i++) {
+      BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+    }
+  }
+  function percentEncodeNonAscii(cp) {
+    if (cp < 2048) {
+      return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+    }
+    if (cp < 65536) {
+      return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
+    return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+  }
   function stringArrayToHexStripped(input) {
     let acc = "";
     let code = 0;
@@ -3061,91 +3079,122 @@ var require_utils = __commonJS((exports, module) => {
     }
     return acc;
   }
+  var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+  var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+  var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
   var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
-    return true;
-  }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex = stringArrayToHexStripped(buffer);
-      if (hex !== "") {
-        address.push(hex);
-      } else {
-        output.error = true;
-        return false;
+  function isZoneIdentifier(zone) {
+    if (zone.length === 0)
+      return false;
+    for (let i = 0;i < zone.length; i++) {
+      if (isZoneCharacter(zone[i]))
+        continue;
+      if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+        i += 2;
+        continue;
       }
-      buffer.length = 0;
+      return false;
     }
     return true;
   }
-  function getIPV6(input) {
-    let tokenCount = 0;
-    const output = { error: false, address: "", zone: "" };
-    const address = [];
-    const buffer = [];
-    let endipv6Encountered = false;
-    let endIpv6 = false;
-    let consume = consumeHextets;
-    for (let i = 0;i < input.length; i++) {
-      const cursor = input[i];
-      if (cursor === "[" || cursor === "]") {
-        continue;
-      }
-      if (cursor === ":") {
-        if (endipv6Encountered === true) {
-          endIpv6 = true;
-        }
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        if (++tokenCount > 7) {
-          output.error = true;
-          break;
+  function compressIPv6ZeroRun(hextets) {
+    let bestStart = -1;
+    let bestLength = 0;
+    let runStart = -1;
+    let runLength = 0;
+    for (let i = 0;i < hextets.length; i++) {
+      if (hextets[i] === "0") {
+        if (runStart === -1)
+          runStart = i;
+        runLength++;
+        if (runLength > bestLength) {
+          bestLength = runLength;
+          bestStart = runStart;
         }
-        if (i > 0 && input[i - 1] === ":") {
-          endipv6Encountered = true;
-        }
-        address.push(":");
-        continue;
-      } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        consume = consumeIsZone;
       } else {
-        buffer.push(cursor);
-        continue;
+        runStart = -1;
+        runLength = 0;
       }
     }
-    if (buffer.length) {
-      if (consume === consumeIsZone) {
-        output.zone = buffer.join("");
-      } else if (endIpv6) {
-        address.push(buffer.join(""));
-      } else {
-        address.push(stringArrayToHexStripped(buffer));
+    if (bestLength < 2)
+      return hextets.join(":");
+    const head = hextets.slice(0, bestStart).join(":");
+    const tail = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail;
+  }
+  function normalizeIPv6Address(input) {
+    const compression = input.indexOf("::");
+    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1)
+      return;
+    const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+    const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+    if (compression !== -1) {
+      if (left.length === 1 && left[0] === "")
+        left.length = 0;
+      if (right.length === 1 && right[0] === "")
+        right.length = 0;
+    }
+    const parts = left.concat(right);
+    let hextetCount = 0;
+    for (let i = 0;i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "")
+        return;
+      if (part.indexOf(".") !== -1) {
+        if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part))
+          return;
+        hextetCount += 2;
+        continue;
       }
+      if (!isHextet(part))
+        return;
+      parts[i] = parseInt(part, 16).toString(16);
+      hextetCount++;
     }
-    output.address = address.join("");
-    return output;
+    if (compression === -1) {
+      if (hextetCount !== 8)
+        return;
+      return compressIPv6ZeroRun(parts);
+    }
+    if (hextetCount >= 8)
+      return;
+    const expanded = parts.slice(0, left.length);
+    for (let i = hextetCount;i < 8; i++)
+      expanded.push("0");
+    for (let i = left.length;i < parts.length; i++)
+      expanded.push(parts[i]);
+    return compressIPv6ZeroRun(expanded);
   }
   function normalizeIPv6(host) {
-    if (findToken(host, ":") < 2) {
-      return { host, isIPV6: false };
-    }
-    const ipv6 = getIPV6(host);
-    if (!ipv6.error) {
-      let newHost = ipv6.address;
-      let escapedHost = ipv6.address;
-      if (ipv6.zone) {
-        newHost += "%" + ipv6.zone;
-        escapedHost += "%25" + ipv6.zone;
-      }
-      return { host: newHost, isIPV6: true, escapedHost };
-    } else {
-      return { host, isIPV6: false };
-    }
+    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+    const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+    if (hasBracket && !bracketed)
+      return { host, isIPV6: false, error: true };
+    let input = bracketed ? host.slice(1, -1) : host;
+    if (bracketed && isIPvFuture(input)) {
+      input = input.toLowerCase();
+      return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+    }
+    if (findToken(input, ":") < 2) {
+      return { host, isIPV6: false, error: bracketed };
+    }
+    let zoneIdentifier = "";
+    const zoneSeparator = input.indexOf("%");
+    if (zoneSeparator !== -1) {
+      const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+      if (!isZoneIdentifier(zoneIdentifier))
+        return { host, isIPV6: false, error: true };
+      input = input.slice(0, zoneSeparator);
+    }
+    const address = normalizeIPv6Address(input);
+    if (address === undefined)
+      return { host, isIPV6: false, error: true };
+    return {
+      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+      isIPV6: true
+    };
   }
   function findToken(str, token) {
     let ind = 0;
@@ -3265,7 +3314,8 @@ var require_utils = __commonJS((exports, module) => {
   function normalizePathEncoding(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
-      if (input[i] === "%" && i + 2 < input.length) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
         const hex = input.slice(i + 1, i + 3);
         if (isHexPair(hex)) {
           const normalizedHex = hex.toUpperCase();
@@ -3279,10 +3329,152 @@ var require_utils = __commonJS((exports, module) => {
           continue;
         }
       }
-      if (isPathCharacter(input[i])) {
-        output += input[i];
+      if (isPathCharacter(ch)) {
+        output += ch;
       } else {
-        output += escape(input[i]);
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function serializePathEncoding(input, pathNoScheme = false) {
+    let output = "";
+    let firstSegment = pathNoScheme && input[0] !== "/";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "/") {
+        firstSegment = false;
+      }
+      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeComponent(input, isAllowed) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (isAllowed(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeUserinfo(input) {
+    return encodeComponent(input, isUserinfoCharacter);
+  }
+  function encodeQuery(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function encodeFragment(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function isEscapeSafe(cp) {
+    return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+  }
+  function normalizeQueryFragmentEncoding(input) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          const normalizedHex = hex.toUpperCase();
+          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+          if (isUnreserved(decoded)) {
+            output += decoded;
+          } else {
+            output += "%" + normalizedHex;
+          }
+          i += 2;
+          continue;
+        }
+      }
+      if (isQueryFragmentCharacter(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
       }
     }
     return output;
@@ -3305,14 +3497,18 @@ var require_utils = __commonJS((exports, module) => {
   function recomposeAuthority(component) {
     const uriTokens = [];
     if (component.userinfo !== undefined) {
-      uriTokens.push(component.userinfo);
+      uriTokens.push(encodeUserinfo(component.userinfo));
       uriTokens.push("@");
     }
     if (component.host !== undefined) {
-      let host = unescape(component.host);
+      let host = component.host;
       if (!isIPv4(host)) {
-        const ipV6res = normalizeIPv6(host);
-        if (ipV6res.isIPV6 === true) {
+        let ipV6res = normalizeIPv6(host);
+        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+          host = normalizePercentEncoding(host, true);
+          ipV6res = normalizeIPv6(host);
+        }
+        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
           host = reescapeHostDelimiters(host, false);
@@ -3332,6 +3528,11 @@ var require_utils = __commonJS((exports, module) => {
     reescapeHostDelimiters,
     normalizePercentEncoding,
     normalizePathEncoding,
+    serializePathEncoding,
+    normalizeQueryFragmentEncoding,
+    encodeUserinfo,
+    encodeQuery,
+    encodeFragment,
     escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
@@ -3344,7 +3545,7 @@ var require_utils = __commonJS((exports, module) => {
 // node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS((exports, module) => {
   var { isUUID } = require_utils();
-  var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+  var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
   var supportedSchemeNames = [
     "http",
     "https",
@@ -3399,9 +3600,10 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path, query] = wsComponent.resourceName.split("?");
+      const queryIndex = wsComponent.resourceName.indexOf("?");
+      const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
       wsComponent.path = path && path !== "/" ? path : undefined;
-      wsComponent.query = query;
+      wsComponent.query = queryIndex === -1 ? undefined : wsComponent.resourceName.slice(queryIndex + 1);
       wsComponent.resourceName = undefined;
     }
     wsComponent.fragment = undefined;
@@ -3413,7 +3615,7 @@ var require_schemes = __commonJS((exports, module) => {
       return urnComponent;
     }
     const matches = urnComponent.path.match(URN_REG);
-    if (matches) {
+    if (matches && matches[0] === urnComponent.path) {
       const scheme = options.scheme || urnComponent.scheme || "urn";
       urnComponent.nid = matches[1].toLowerCase();
       urnComponent.nss = matches[2];
@@ -3517,8 +3719,17 @@ var require_schemes = __commonJS((exports, module) => {
 
 // node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS((exports, module) => {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
   var { SCHEMES, getSchemeHandler } = require_schemes();
+  var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+  var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+  function decodeValidScheme(scheme) {
+    const decodedScheme = unescape(String(scheme));
+    if (!VALID_SCHEME.test(decodedScheme)) {
+      throw new TypeError(MALFORMED_SCHEME_ERROR);
+    }
+    return decodedScheme;
+  }
   function normalize(uri, options) {
     if (typeof uri === "string") {
       uri = normalizeString(uri, options);
@@ -3529,12 +3740,34 @@ var require_fast_uri = __commonJS((exports, module) => {
   }
   function resolve(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-    const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-    if (baseMalformed || relativeMalformed) {
+    const {
+      parsed: baseParsed,
+      malformedAuthorityOrPort: baseMalformed,
+      malformedPercentEncoding: baseMalformedPercentEncoding,
+      malformedSchemeSpecific: baseMalformedSchemeSpecific,
+      malformedHost: baseMalformedHost,
+      malformedScheme: baseMalformedScheme
+    } = parseWithStatus(baseURI, schemelessOptions);
+    const {
+      parsed: relativeParsed,
+      malformedAuthorityOrPort: relativeMalformed,
+      malformedPercentEncoding: relativeMalformedPercentEncoding,
+      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+      malformedHost: relativeMalformedHost,
+      malformedScheme: relativeMalformedScheme
+    } = parseWithStatus(relativeURI, schemelessOptions);
+    if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
       throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
     }
     const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+    const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+    const resolvedHost = resolved.host;
+    const resolvedHostIsIP = resolvedHost !== undefined && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+    canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+    const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+    if (resolved.error && !encodedASCIIHost) {
+      throw new Error(resolved.error);
+    }
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
@@ -3594,7 +3827,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   function equal(uriA, uriB, options) {
     const normalizedA = normalizeComparableURI(uriA, options);
     const normalizedB = normalizeComparableURI(uriB, options);
-    return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+    return normalizedA !== undefined && normalizedB !== undefined && normalizedA === normalizedB;
   }
   function serialize(cmpts, opts) {
     const component = {
@@ -3615,20 +3848,23 @@ var require_fast_uri = __commonJS((exports, module) => {
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
+    if (component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
+    }
     const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
     if (schemeHandler && schemeHandler.serialize)
       schemeHandler.serialize(component, options);
+    const hasAuthority = component.userinfo !== undefined || component.host !== undefined || component.port !== undefined;
+    const pathNoScheme = !options.skipEscape && component.scheme === undefined && !hasAuthority;
     if (component.path !== undefined) {
       if (!options.skipEscape) {
-        component.path = escapePreservingEscapes(component.path);
-        if (component.scheme !== undefined) {
-          component.path = component.path.split("%3A").join(":");
-        }
+        component.path = serializePathEncoding(component.path, pathNoScheme);
       } else {
         component.path = normalizePercentEncoding(component.path);
       }
     }
     if (options.reference !== "suffix" && component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
       uriTokens.push(component.scheme, ":");
     }
     const authority = recomposeAuthority(component);
@@ -3646,16 +3882,19 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
+      if (pathNoScheme) {
+        s = serializePathEncoding(s, true);
+      }
       if (authority === undefined && s[0] === "/" && s[1] === "/") {
         s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
     if (component.query !== undefined) {
-      uriTokens.push("?", component.query);
+      uriTokens.push("?", encodeQuery(component.query));
     }
     if (component.fragment !== undefined) {
-      uriTokens.push("#", component.fragment);
+      uriTokens.push("#", encodeFragment(component.fragment));
     }
     return uriTokens.join("");
   }
@@ -3671,6 +3910,33 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return;
   }
+  function hasMalformedPercentEncoding(component) {
+    if (component === undefined)
+      return false;
+    let percent = component.indexOf("%");
+    while (percent !== -1) {
+      if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+        return true;
+      }
+      percent = component.indexOf("%", percent + 3);
+    }
+    return false;
+  }
+  function hasMalformedComponentPercentEncoding(matches) {
+    const host = matches[4];
+    return hasMalformedPercentEncoding(matches[3]) || host !== undefined && !(host[0] === "[" && host[host.length - 1] === "]") && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+  }
+  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && parsed.host[0] !== "[" && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+      try {
+        parsed.host = new URL("http://" + parsed.host).hostname;
+      } catch (e) {
+        parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+        return true;
+      }
+    }
+    return false;
+  }
   function parseWithStatus(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
@@ -3683,6 +3949,11 @@ var require_fast_uri = __commonJS((exports, module) => {
       fragment: undefined
     };
     let malformedAuthorityOrPort = false;
+    let malformedPercentEncoding = false;
+    let malformedSchemeSpecific = false;
+    let malformedHost = false;
+    let malformedIPLiteral = false;
+    let malformedScheme = false;
     let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
@@ -3719,6 +3990,19 @@ var require_fast_uri = __commonJS((exports, module) => {
       parsed.path = matches[6] || "";
       parsed.query = matches[7];
       parsed.fragment = matches[8];
+      if (parsed.scheme !== undefined) {
+        const decodedScheme = unescape(parsed.scheme);
+        if (VALID_SCHEME.test(decodedScheme)) {
+          parsed.scheme = decodedScheme.toLowerCase();
+        } else {
+          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+          malformedScheme = true;
+        }
+      }
+      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+      if (malformedPercentEncoding) {
+        parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+      }
       if (isNaN(parsed.port)) {
         parsed.port = matches[5];
       }
@@ -3730,9 +4014,15 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (parsed.host) {
         const ipv4result = isIPv4(parsed.host);
         if (ipv4result === false) {
+          const bracketedIPLiteral = parsed.host[0] === "[" && parsed.host[parsed.host.length - 1] === "]";
           const ipv6result = normalizeIPv6(parsed.host);
-          parsed.host = ipv6result.host.toLowerCase();
-          isIP = ipv6result.isIPV6;
+          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+          malformedIPLiteral = bracketedIPLiteral && ipv6result.error === true;
+          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+          if (malformedIPLiteral) {
+            parsed.error = parsed.error || "URI host is malformed.";
+            malformedAuthorityOrPort = true;
+          }
         } else {
           isIP = true;
         }
@@ -3750,42 +4040,34 @@ var require_fast_uri = __commonJS((exports, module) => {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
       const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-          try {
-            parsed.host = new URL("http://" + parsed.host).hostname;
-          } catch (e) {
-            parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-          }
-        }
-      }
+      malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
         if (uri.indexOf("%") !== -1) {
-          if (parsed.scheme !== undefined) {
-            parsed.scheme = unescape(parsed.scheme);
-          }
-          if (parsed.host !== undefined) {
-            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+          if (parsed.host !== undefined && !malformedIPLiteral) {
+            const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+            parsed.host = reescapeHostDelimiters(host, isIP);
           }
         }
         if (parsed.path) {
           parsed.path = normalizePathEncoding(parsed.path);
         }
+        if (parsed.query) {
+          parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+        }
         if (parsed.fragment) {
-          try {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-          } catch {
-            parsed.error = parsed.error || "URI malformed";
-          }
+          parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
         }
       }
       if (schemeHandler && schemeHandler.parse) {
         schemeHandler.parse(parsed, options);
+        if (schemeHandler === SCHEMES.urn && parsed.nid === undefined) {
+          malformedSchemeSpecific = true;
+        }
       }
     } else {
       parsed.error = parsed.error || "URI can not be parsed.";
     }
-    return { parsed, malformedAuthorityOrPort };
+    return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
   }
   function parse(uri, opts) {
     return parseWithStatus(uri, opts).parsed;
@@ -3794,20 +4076,28 @@ var require_fast_uri = __commonJS((exports, module) => {
     return normalizeStringWithStatus(uri, opts).normalized;
   }
   function normalizeStringWithStatus(uri, opts) {
-    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
     return {
-      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-      malformedAuthorityOrPort
+      normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort,
+      malformedPercentEncoding,
+      malformedSchemeSpecific,
+      malformedHost,
+      malformedScheme
     };
   }
   function normalizeComparableURI(uri, opts) {
-    if (typeof uri === "string") {
-      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-      return malformedAuthorityOrPort ? undefined : normalized;
+    if (typeof uri !== "string" && typeof uri !== "object") {
+      return;
     }
-    if (typeof uri === "object") {
-      return serialize(uri, opts);
+    let value;
+    try {
+      value = typeof uri === "string" ? uri : serialize(uri, opts);
+    } catch {
+      return;
     }
+    const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+    return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? undefined : normalized;
   }
   var fastUri = {
     SCHEMES,
@@ -15678,8 +15968,8 @@ var require_extend = __commonJS((exports, module) => {
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync25 } from "node:fs";
-import process9 from "node:process";
+import { readFileSync as readFileSync22 } from "node:fs";
+import process7 from "node:process";
 
 // src/audit/config/load.ts
 var import_ajv = __toESM(require_ajv(), 1);
@@ -30993,287 +31283,6 @@ function runReviewProofRule(ctx) {
 }
 var reviewProofRule = { id: "review-proof", run: runReviewProofRule };
 
-// src/references/check.ts
-import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync13 } from "node:fs";
-import { join as join12, relative as relative8 } from "node:path";
-
-// src/references/constants.ts
-var CANONICAL_REFS_DIR = ".skeleton/references";
-var GENERATED_MARKER_START = "<!-- skeleton: generated-reference";
-var GENERATED_MARKER_RE = /<!-- skeleton: generated-reference\s*\nsource: ([^\n]+)\s*\nredundancy: intentional\s*\n-->\s*\n?/;
-var SHARED_REF_LINK_RE = /\((?:\.\.\/)+references\/([^)]+)\)/g;
-function formatGeneratedHeader(sourceRelPath) {
-  return `${GENERATED_MARKER_START}
-source: ${sourceRelPath}
-redundancy: intentional
--->
-
-`;
-}
-function stripGeneratedHeader(content3) {
-  return content3.replace(GENERATED_MARKER_RE, "");
-}
-function isGeneratedReference(content3) {
-  return content3.startsWith(GENERATED_MARKER_START);
-}
-
-// src/references/discover.ts
-import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync12 } from "node:fs";
-import { join as join11, relative as relative7 } from "node:path";
-function walkMarkdownFiles(dir, root2) {
-  const files = [];
-  if (!existsSync14(dir))
-    return files;
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith("."))
-      continue;
-    const fullPath = join11(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...walkMarkdownFiles(fullPath, root2));
-      continue;
-    }
-    if (entry.name.endsWith(".md")) {
-      files.push(normalizeRelPath(relative7(root2, fullPath)));
-    }
-  }
-  return files;
-}
-function canonicalExists(root2, refPath) {
-  return existsSync14(join11(root2, CANONICAL_REFS_DIR, refPath));
-}
-function findSharedRefLinks(content3, sourceFile) {
-  const links = [];
-  for (const match of content3.matchAll(SHARED_REF_LINK_RE)) {
-    const refPath = match[1];
-    if (!refPath)
-      continue;
-    links.push({ refPath: normalizeRelPath(refPath), sourceFile });
-  }
-  return links;
-}
-function findSiblingRefLinks(root2, content3, sourceFile) {
-  const links = [];
-  if (!/\/references\//.test(sourceFile))
-    return links;
-  const refsIdx = sourceFile.lastIndexOf("/references/");
-  const withinRefs = sourceFile.slice(refsIdx + "/references/".length);
-  const withinDir = withinRefs.includes("/") ? withinRefs.slice(0, withinRefs.lastIndexOf("/")) : "";
-  const siblingRe = /\((?!https?:|#|\.\.\/)([a-z0-9./_-]+\.md)\)/gi;
-  for (const match of content3.matchAll(siblingRe)) {
-    const raw = normalizeRelPath(match[1] ?? "");
-    if (!raw)
-      continue;
-    const refPath = withinDir ? normalizeRelPath(join11(withinDir, raw)) : raw;
-    if (!canonicalExists(root2, refPath))
-      continue;
-    links.push({ refPath, sourceFile });
-  }
-  return links;
-}
-function findLocalCanonicalLinks(root2, content3, sourceFile) {
-  const links = [];
-  const localRefRe = /\((?:\.\/)?references\/([^)]+)\)/g;
-  for (const match of content3.matchAll(localRefRe)) {
-    const refPath = normalizeRelPath(match[1] ?? "");
-    if (!(refPath && canonicalExists(root2, refPath)))
-      continue;
-    links.push({ refPath, sourceFile });
-  }
-  links.push(...findSiblingRefLinks(root2, content3, sourceFile));
-  return links;
-}
-function collectLinksForFile(root2, relFile) {
-  const content3 = readFileSync12(join11(root2, relFile), "utf8");
-  if (isGeneratedReference(content3))
-    return [];
-  return [
-    ...findSharedRefLinks(content3, relFile),
-    ...findLocalCanonicalLinks(root2, content3, relFile)
-  ];
-}
-function expandTransitiveRefs(input) {
-  const { root: root2, skillDir, refPaths, links } = input;
-  const queue = [...refPaths];
-  while (queue.length > 0) {
-    const refPath = queue.pop();
-    if (!(refPath && canonicalExists(root2, refPath)))
-      continue;
-    const canonicalContent = readFileSync12(join11(root2, CANONICAL_REFS_DIR, refPath), "utf8");
-    const syntheticSource = generatedRefPath(skillDir, refPath);
-    for (const link2 of findLocalCanonicalLinks(root2, canonicalContent, syntheticSource)) {
-      if (refPaths.has(link2.refPath))
-        continue;
-      refPaths.add(link2.refPath);
-      links.push(link2);
-      queue.push(link2.refPath);
-    }
-  }
-}
-function planForSkill(root2, slug2, skillDir) {
-  const absSkillDir = join11(root2, skillDir);
-  if (!existsSync14(join11(absSkillDir, "SKILL.md")))
-    return null;
-  const refPaths = new Set;
-  const links = [];
-  for (const relFile of walkMarkdownFiles(absSkillDir, root2)) {
-    for (const link2 of collectLinksForFile(root2, relFile)) {
-      refPaths.add(link2.refPath);
-      links.push(link2);
-    }
-  }
-  expandTransitiveRefs({ root: root2, skillDir, refPaths, links });
-  return refPaths.size > 0 ? { skill: slug2, skillDir, refPaths, links } : null;
-}
-function concreteSkillDirs(root2, index2, slug2) {
-  const dirs = [];
-  for (const skillRoot of index2.roots) {
-    const rel = normalizeRelPath(skillRoot.kind === "nested" ? join11(skillRoot.relPath, slug2) : slug2);
-    if (existsSync14(join11(root2, rel, "SKILL.md")))
-      dirs.push(rel);
-  }
-  return [...new Set(dirs)];
-}
-function discoverSkillReferencePlans(root2, ownership) {
-  const index2 = buildSkillIndex(root2, ownership);
-  const plans = [];
-  for (const slug2 of index2.ownedSlugs) {
-    for (const skillDir of concreteSkillDirs(root2, index2, slug2)) {
-      const plan = planForSkill(root2, slug2, skillDir);
-      if (plan)
-        plans.push(plan);
-    }
-  }
-  return plans.sort((a, b) => a.skillDir.localeCompare(b.skillDir));
-}
-function generatedRefPath(skillDir, refPath) {
-  return normalizeRelPath(join11(skillDir, "references", refPath));
-}
-function rewriteSharedRefTarget(sourceFile, skillDir, refPath) {
-  const sourceDir = sourceFile.slice(0, sourceFile.lastIndexOf("/"));
-  const target = generatedRefPath(skillDir, refPath);
-  if (!sourceDir)
-    return target;
-  const fromParts = sourceDir.split("/");
-  const toParts = target.split("/");
-  let i = 0;
-  while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
-    i++;
-  }
-  const ups = fromParts.length - i;
-  const down = toParts.slice(i);
-  const rel = [...Array(ups).fill(".."), ...down].join("/");
-  return rel || (toParts.at(-1) ?? refPath);
-}
-function rewriteSharedRefLinks(content3, sourceFile, skillDir) {
-  return content3.replace(SHARED_REF_LINK_RE, (_match, refPath) => {
-    const rewritten = rewriteSharedRefTarget(sourceFile, skillDir, normalizeRelPath(refPath));
-    return `(${rewritten})`;
-  });
-}
-
-// src/references/check.ts
-function walkMarkdown(dir, onFile) {
-  if (!existsSync15(dir))
-    return;
-  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith("."))
-      continue;
-    const fullPath = join12(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkMarkdown(fullPath, onFile);
-      continue;
-    }
-    if (!entry.name.endsWith(".md"))
-      continue;
-    onFile(fullPath);
-  }
-}
-function listAllGeneratedFiles(root2) {
-  const files = [];
-  walkMarkdown(root2, (fullPath) => {
-    const content3 = readFileSync13(fullPath, "utf8");
-    if (isGeneratedReference(content3)) {
-      files.push(normalizeRelPath(relative8(root2, fullPath)));
-    }
-  });
-  return files;
-}
-function checkNeededCopy(root2, targetRel) {
-  const targetPath = join12(root2, targetRel);
-  if (!existsSync15(targetPath)) {
-    return issue("generated-references", targetRel, "missing generated copy — run skeleton references sync");
-  }
-  const generated = readFileSync13(targetPath, "utf8");
-  if (!isGeneratedReference(generated)) {
-    return issue("generated-references", targetRel, "expected generated-reference provenance header");
-  }
-  const body = stripGeneratedHeader(generated);
-  const sourceRel = normalizeRelPath(generated.match(/source: ([^\n]+)/)?.[1] ?? join12(CANONICAL_REFS_DIR, targetRel.split("/references/")[1] ?? ""));
-  const canonicalPath = join12(root2, sourceRel);
-  if (!existsSync15(canonicalPath)) {
-    return issue("generated-references", targetRel, `canonical source missing: ${sourceRel}`);
-  }
-  const canonical = readFileSync13(canonicalPath, "utf8");
-  if (body !== canonical) {
-    return issue("generated-references", targetRel, "stale generated copy — run skeleton references sync");
-  }
-  return null;
-}
-function checkOrphanedCopies(root2, needed, skillIndex) {
-  const issues = [];
-  for (const generatedRel of listAllGeneratedFiles(root2)) {
-    if (isForeignSkillPath(generatedRel, skillIndex))
-      continue;
-    if (!needed.has(generatedRel)) {
-      issues.push(issue("generated-references", generatedRel, "orphaned generated copy — run skeleton references sync"));
-    }
-  }
-  return issues;
-}
-function checkStaleSharedLinks(root2, skillDir) {
-  const issues = [];
-  walkMarkdown(skillDir, (fullPath) => {
-    const relFile = normalizeRelPath(relative8(root2, fullPath));
-    const content3 = readFileSync13(fullPath, "utf8");
-    if (!content3.match(SHARED_REF_LINK_RE))
-      return;
-    issues.push(issue("generated-references", relFile, "still links to shared root references/ — run skeleton references sync"));
-  });
-  return issues;
-}
-function runGeneratedReferencesCheck(root2, ownership) {
-  const issues = [];
-  const canonicalDir = join12(root2, CANONICAL_REFS_DIR);
-  if (!existsSync15(canonicalDir))
-    return issues;
-  const skillIndex = buildSkillIndex(root2, ownership);
-  const plans = discoverSkillReferencePlans(root2, ownership);
-  const needed = new Set;
-  for (const plan of plans) {
-    for (const refPath of plan.refPaths) {
-      needed.add(generatedRefPath(plan.skillDir, refPath));
-    }
-  }
-  for (const targetRel of needed) {
-    const found = checkNeededCopy(root2, targetRel);
-    if (found)
-      issues.push(found);
-  }
-  issues.push(...checkOrphanedCopies(root2, needed, skillIndex));
-  for (const plan of plans) {
-    issues.push(...checkStaleSharedLinks(root2, join12(root2, plan.skillDir)));
-  }
-  return issues;
-}
-function runGeneratedReferencesRule(ctx) {
-  return runGeneratedReferencesCheck(ctx.root, ctx.config.skillOwnership);
-}
-var generatedReferencesRule = {
-  id: "generated-references",
-  global: true,
-  run: runGeneratedReferencesRule
-};
-
 // src/audit/rules/banned.ts
 function runBannedRule(ctx) {
   const issues = [];
@@ -31286,8 +31295,8 @@ function runBannedRule(ctx) {
 var bannedRule = { id: "banned", run: runBannedRule };
 
 // src/audit/rules/doc-meta.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
+import { join as join11 } from "node:path";
 function checkDocMetaBanner(relPath2, content3) {
   if (DOC_META_RE.test(content3))
     return null;
@@ -31342,10 +31351,10 @@ function runDocMetaRule(ctx) {
   const issues = [];
   const today = new Date;
   for (const relPath2 of ctx.docMetaPaths) {
-    const abs = join13(ctx.root, relPath2);
-    if (!existsSync16(abs))
+    const abs = join11(ctx.root, relPath2);
+    if (!existsSync14(abs))
       continue;
-    const content3 = readFileSync14(abs, "utf8");
+    const content3 = readFileSync12(abs, "utf8");
     const banner = checkDocMetaBanner(relPath2, content3);
     if (banner) {
       issues.push(banner);
@@ -31373,7 +31382,7 @@ function runDocMetaRule(ctx) {
 var docMetaRule = { id: "doc-meta", run: runDocMetaRule };
 
 // src/audit/rules/links.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
 import { dirname as dirname9, resolve as resolve5 } from "node:path";
 function resolveLink2(sourceFile, target) {
   const withoutAnchor = target.split("#")[0]?.split("?")[0] ?? "";
@@ -31397,13 +31406,13 @@ function checkAgentFile(input, resolved, relSource) {
     return null;
   }
   const agentPath = resolved.endsWith(".md") ? resolved : `${resolved}.md`;
-  if (existsSync17(agentPath))
+  if (existsSync15(agentPath))
     return null;
   return issue("links", relSource, { message: "missing agent file", link: input.linkLabel });
 }
 function checkBrokenPath(ctx) {
   const { input, pathPart, resolved, relSource, relTarget } = ctx;
-  if (!(pathPart && !existsSync17(resolved)))
+  if (!(pathPart && !existsSync15(resolved)))
     return null;
   return issue("links", relSource, {
     message: `broken link → ${relTarget}`,
@@ -31412,9 +31421,9 @@ function checkBrokenPath(ctx) {
 }
 function checkBrokenAnchor(ctx) {
   const { input, anchor, resolved, relSource, relTarget } = ctx;
-  if (!(anchor && existsSync17(resolved)))
+  if (!(anchor && existsSync15(resolved)))
     return null;
-  const targetContent = readFileSync15(resolved, "utf8");
+  const targetContent = readFileSync13(resolved, "utf8");
   const slugs = extractHeadingSlugs(targetContent, resolved);
   const anchorSlug = slugifyAnchor(anchor);
   if (slugs.has(anchorSlug))
@@ -31466,8 +31475,8 @@ function runLinksRule(ctx) {
 var linksRule = { id: "links", run: runLinksRule };
 
 // src/audit/rules/near-duplicate.ts
-import { readFileSync as readFileSync16 } from "node:fs";
-import { join as join14 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/audit/core/ssot-fit.ts
 var DEFAULT_SSOT_OVERLAP_MIN = 0.35;
@@ -31755,7 +31764,7 @@ function runNearDuplicateRule(ctx) {
   const ignored = ignoredPairSet(ctx);
   const entries = eligibleEntries(ctx);
   const fingerprints = entries.map((e) => {
-    const content3 = readFileSync16(join14(ctx.root, e.path), "utf8");
+    const content3 = readFileSync14(join12(ctx.root, e.path), "utf8");
     const tokens = tokenize2(bodyWithoutSsotNoise(content3));
     return {
       path: e.path,
@@ -31851,11 +31860,11 @@ function runProsePolicyRule(ctx) {
 var prosePolicyRule = { id: "prose-policy", run: runProsePolicyRule };
 
 // src/audit/rules/review-deps.ts
-import { relative as relative9 } from "node:path";
+import { relative as relative7 } from "node:path";
 function runReviewDepsRule(ctx) {
   const issues = [];
   for (const abs of collectScanFiles(ctx.config, ctx.root, ctx.skillIndex)) {
-    const path3 = normalizeRelPath(relative9(ctx.root, abs));
+    const path3 = normalizeRelPath(relative7(ctx.root, abs));
     for (const marker of parseReviewDepsMarkers(readFileContent(abs))) {
       issues.push(...validateMarker(ctx.root, path3, marker.paths));
     }
@@ -31916,16 +31925,16 @@ function runScanRootsRule(ctx) {
 var scanRootsRule = { id: "scan-roots", run: runScanRootsRule };
 
 // src/audit/rules/skill-index.ts
-import { existsSync as existsSync18, readdirSync as readdirSync4, readFileSync as readFileSync17 } from "node:fs";
-import { join as join15, relative as relative10 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync2, readFileSync as readFileSync15 } from "node:fs";
+import { join as join13, relative as relative8 } from "node:path";
 function walkSkillMarkdown(dir) {
   const files = [];
-  if (!existsSync18(dir))
+  if (!existsSync16(dir))
     return files;
-  for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join15(dir, entry.name);
+    const fullPath = join13(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkSkillMarkdown(fullPath));
       continue;
@@ -31951,10 +31960,8 @@ function parseReadmeTaxonomySlugs(content3) {
 }
 function scanFileForSkillLinks(ctx, filePath, index2) {
   const issues = [];
-  const rel = relative10(ctx.root, filePath).replace(/\\/g, "/");
-  const content3 = readFileSync17(filePath, "utf8");
-  if (isGeneratedReference(content3))
-    return issues;
+  const rel = relative8(ctx.root, filePath).replace(/\\/g, "/");
+  const content3 = readFileSync15(filePath, "utf8");
   for (const match of content3.matchAll(SKILL_LINK_RE)) {
     const slug2 = match[1];
     if (!slug2)
@@ -31967,14 +31974,14 @@ function scanFileForSkillLinks(ctx, filePath, index2) {
 }
 function taxonomyIssuesForReadme(input) {
   const { ctx, index: index2, skillRoot, diskSlugs, nonPublic } = input;
-  const readmePath = join15(ctx.root, skillRoot.relPath, "README.md");
-  if (!existsSync18(readmePath))
+  const readmePath = join13(ctx.root, skillRoot.relPath, "README.md");
+  if (!existsSync16(readmePath))
     return [];
-  const readme = readFileSync17(readmePath, "utf8");
+  const readme = readFileSync15(readmePath, "utf8");
   if (!readme.includes("## Taxonomy"))
     return [];
   const taxonomySlugs = parseReadmeTaxonomySlugs(readme);
-  const nestedSlugs = diskSlugs.filter((slug2) => existsSync18(join15(ctx.root, skillRoot.relPath, slug2, "SKILL.md")));
+  const nestedSlugs = diskSlugs.filter((slug2) => existsSync16(join13(ctx.root, skillRoot.relPath, slug2, "SKILL.md")));
   const foreign = new Set(index2.foreignSlugs);
   const publicSlugs = nestedSlugs.filter((slug2) => !(nonPublic.has(slug2) || foreign.has(slug2)));
   const relReadme = `${skillRoot.relPath}/README.md`;
@@ -32007,10 +32014,10 @@ function slugsForRoot(skillRoot, index2, owned) {
 function auditSkillRoot(input) {
   const { ctx, index: index2, skillRoot, owned } = input;
   const issues = [];
-  const base = skillRoot.kind === "nested" ? join15(ctx.root, skillRoot.relPath) : ctx.root;
+  const base = skillRoot.kind === "nested" ? join13(ctx.root, skillRoot.relPath) : ctx.root;
   for (const slug2 of slugsForRoot(skillRoot, index2, owned)) {
-    const skillDir = join15(base, slug2);
-    if (!existsSync18(skillDir))
+    const skillDir = join13(base, slug2);
+    if (!existsSync16(skillDir))
       continue;
     for (const skillMd of walkSkillMarkdown(skillDir)) {
       issues.push(...scanFileForSkillLinks(ctx, skillMd, index2));
@@ -32060,8 +32067,8 @@ function runSsotRule(ctx) {
 var ssotRule = { id: "ssot", run: runSsotRule };
 
 // src/audit/rules/ssot-summary.ts
-import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join16 } from "node:path";
+import { readFileSync as readFileSync16 } from "node:fs";
+import { join as join14 } from "node:path";
 function runSsotSummaryRule(ctx) {
   const overlapMin = ctx.config.docsLint?.ssotOverlapMin ?? DEFAULT_SSOT_OVERLAP_MIN;
   const margin = ctx.config.docsLint?.ssotBetterMatchMargin ?? DEFAULT_BETTER_MATCH_MARGIN;
@@ -32069,7 +32076,7 @@ function runSsotSummaryRule(ctx) {
   const files = ctx.ssotEntries.map((entry) => ({
     path: entry.path,
     summary: entry.summary,
-    content: readFileSync18(join16(ctx.root, entry.path), "utf8")
+    content: readFileSync16(join14(ctx.root, entry.path), "utf8")
   }));
   return evaluateSsotFit(files, {
     overlapMin,
@@ -32099,7 +32106,6 @@ var docsRules = [
 ];
 var skillsRules = [
   { ...skillIndexRule, global: true },
-  { ...generatedReferencesRule, global: true },
   prosePolicyRule
 ];
 var allRules = [...docsRules, ...skillsRules];
@@ -32436,20 +32442,20 @@ async function runAudit(options) {
 }
 
 // src/customize/resolve.ts
-import { existsSync as existsSync19, readFileSync as readFileSync19 } from "node:fs";
-import { basename as basename3, join as join17, relative as relative11 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "node:fs";
+import { basename as basename3, join as join15, relative as relative9 } from "node:path";
 function customizeDir(root2) {
-  return join17(root2, REGISTRY_DIR_REL, "customize");
+  return join15(root2, REGISTRY_DIR_REL, "customize");
 }
 function customizePathForSlug(root2, slug2) {
-  return join17(customizeDir(root2), `${slug2}.md`);
+  return join15(customizeDir(root2), `${slug2}.md`);
 }
 function resolveSlugFile(root2, slug2) {
   const direct = customizePathForSlug(root2, slug2);
-  if (existsSync19(direct)) {
+  if (existsSync17(direct)) {
     return {
-      content: readFileSync19(direct, "utf8"),
-      path: normalizeRelPath(relative11(root2, direct))
+      content: readFileSync17(direct, "utf8"),
+      path: normalizeRelPath(relative9(root2, direct))
     };
   }
   return { content: null, path: null };
@@ -32470,11 +32476,11 @@ function readAlwaysInclude(root2, basenames, skipBasename) {
     const file = basename3(name);
     if (skipBasename && file === skipBasename)
       continue;
-    const abs = join17(dir, file);
-    if (!existsSync19(abs))
+    const abs = join15(dir, file);
+    if (!existsSync17(abs))
       continue;
-    parts.push(readFileSync19(abs, "utf8").trimEnd());
-    paths.push(normalizeRelPath(relative11(root2, abs)));
+    parts.push(readFileSync17(abs, "utf8").trimEnd());
+    paths.push(normalizeRelPath(relative9(root2, abs)));
   }
   return { parts, paths };
 }
@@ -32597,39 +32603,39 @@ Customize override for /${slug2} (from ${from}):
 
 // src/init/init.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { copyFileSync, existsSync as existsSync23, mkdirSync as mkdirSync4, readFileSync as readFileSync21 } from "node:fs";
-import { join as join21 } from "node:path";
+import { copyFileSync, existsSync as existsSync21, mkdirSync as mkdirSync4, readFileSync as readFileSync19 } from "node:fs";
+import { join as join19 } from "node:path";
 import process6 from "node:process";
 
 // src/init/merge-hooks.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync3, readFileSync as readFileSync20, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname12, join as join20 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync3, readFileSync as readFileSync18, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
 
 // src/init/package-paths.ts
-import { existsSync as existsSync20 } from "node:fs";
-import { dirname as dirname10, join as join18 } from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var MODULE_DIR = dirname10(fileURLToPath4(import.meta.url));
-var PACKAGE_ROOT_CANDIDATES = [join18(MODULE_DIR, "../.."), join18(MODULE_DIR, "..")];
+var PACKAGE_ROOT_CANDIDATES = [join16(MODULE_DIR, "../.."), join16(MODULE_DIR, "..")];
 function resolvePackageRoot() {
   for (const candidate of PACKAGE_ROOT_CANDIDATES) {
-    if (existsSync20(join18(candidate, "package.json")))
+    if (existsSync18(join16(candidate, "package.json")))
       return candidate;
   }
   throw new Error("Could not resolve @csark0812/skeleton package root");
 }
 function resolveTemplatesDir() {
-  const dir = join18(resolvePackageRoot(), "templates/skeleton-init");
-  if (!existsSync20(dir)) {
+  const dir = join16(resolvePackageRoot(), "templates/skeleton-init");
+  if (!existsSync18(dir)) {
     throw new Error("Missing templates/skeleton-init in package");
   }
   return dir;
 }
 
 // src/init/resolve-hook-command.ts
-import { existsSync as existsSync21, realpathSync as realpathSync5 } from "node:fs";
+import { existsSync as existsSync19, realpathSync as realpathSync5 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname11, join as join19, relative as relative12, resolve as resolve6 } from "node:path";
+import { dirname as dirname11, join as join17, relative as relative10, resolve as resolve6 } from "node:path";
 var PACKAGE_NAME = "@csark0812/skeleton";
 var CLI_DIST = "dist/cli.js";
 var PACKAGE_ROOT = resolvePackageRoot();
@@ -32643,12 +32649,12 @@ function safeRealpath2(path3) {
   }
 }
 function toRepoRelative(cwd, absPath) {
-  const rel = relative12(safeRealpath2(cwd), safeRealpath2(absPath)).replace(/\\/g, "/");
+  const rel = relative10(safeRealpath2(cwd), safeRealpath2(absPath)).replace(/\\/g, "/");
   return rel.startsWith("..") ? absPath.replace(/\\/g, "/") : rel;
 }
 function tryResolvePublishedCli(cwd) {
   try {
-    const req = createRequire3(join19(cwd, "package.json"));
+    const req = createRequire3(join17(cwd, "package.json"));
     return req.resolve(`${PACKAGE_NAME}/${CLI_DIST}`);
   } catch {
     return null;
@@ -32657,8 +32663,8 @@ function tryResolvePublishedCli(cwd) {
 function walkNodeModulesCli(cwd) {
   let dir = cwd;
   while (true) {
-    const candidate = join19(dir, "node_modules", PACKAGE_NAME, CLI_DIST);
-    if (existsSync21(candidate))
+    const candidate = join17(dir, "node_modules", PACKAGE_NAME, CLI_DIST);
+    if (existsSync19(candidate))
       return candidate;
     const parent = dirname11(dir);
     if (parent === dir)
@@ -32668,7 +32674,7 @@ function walkNodeModulesCli(cwd) {
   return null;
 }
 function isInsidePackageRoot(cwd) {
-  const rel = relative12(PACKAGE_ROOT, resolve6(cwd)).replace(/\\/g, "/");
+  const rel = relative10(PACKAGE_ROOT, resolve6(cwd)).replace(/\\/g, "/");
   return rel === "" || !(rel.startsWith("..") || rel.startsWith("/"));
 }
 function nodeCliHookCommand(cliPath) {
@@ -32699,14 +32705,14 @@ function identityKey(platform, event, matcher) {
   return `skeleton:customize:${platform}:${event}:${matcher}`;
 }
 function loadFragment(name, hookCommand) {
-  const raw = readFileSync20(join20(TEMPLATES_DIR, name), "utf8");
+  const raw = readFileSync18(join18(TEMPLATES_DIR, name), "utf8");
   return JSON.parse(raw.replaceAll("{{HOOK_COMMAND}}", hookCommand));
 }
 function readJson(path3) {
-  if (!existsSync22(path3))
+  if (!existsSync20(path3))
     return null;
   try {
-    return JSON.parse(readFileSync20(path3, "utf8"));
+    return JSON.parse(readFileSync18(path3, "utf8"));
   } catch (error) {
     throw new Error(`Invalid JSON in ${path3}: ${error}`);
   }
@@ -32866,10 +32872,10 @@ function mergeNestedHooks(args) {
 }
 function mergeHookConfigs(opts) {
   const results = [];
-  const cursorPath = join20(opts.cwd, ".cursor/hooks.json");
+  const cursorPath = join18(opts.cwd, ".cursor/hooks.json");
   const cursorFragment = loadFragment("cursor-hooks.fragment.json", opts.hookCommand);
   results.push(mergeCursorHooks(cursorPath, cursorFragment, opts));
-  const claudePath = join20(opts.cwd, ".claude/settings.json");
+  const claudePath = join18(opts.cwd, ".claude/settings.json");
   const claudeFragment = loadFragment("claude-settings.fragment.json", opts.hookCommand);
   results.push(mergeNestedHooks({
     platform: "claude",
@@ -32878,8 +32884,8 @@ function mergeHookConfigs(opts) {
     eventName: "PostToolUse",
     opts
   }));
-  const codexPath = join20(opts.cwd, ".codex/hooks.json");
-  if (existsSync22(join20(opts.cwd, ".codex"))) {
+  const codexPath = join18(opts.cwd, ".codex/hooks.json");
+  if (existsSync20(join18(opts.cwd, ".codex"))) {
     const codexFragment = loadFragment("codex-hooks.fragment.json", opts.hookCommand);
     results.push(mergeNestedHooks({
       platform: "codex",
@@ -32894,11 +32900,11 @@ function mergeHookConfigs(opts) {
   return results;
 }
 function mergePackageJsonScripts(cwd) {
-  const pkgPath = join20(cwd, "package.json");
-  if (!existsSync22(pkgPath))
+  const pkgPath = join18(cwd, "package.json");
+  if (!existsSync20(pkgPath))
     return "skipped";
-  const fragment = JSON.parse(readFileSync20(join20(TEMPLATES_DIR, "package.json.scripts.fragment.json"), "utf8"));
-  const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
+  const fragment = JSON.parse(readFileSync18(join18(TEMPLATES_DIR, "package.json.scripts.fragment.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
   pkg.scripts ??= {};
   let changed = false;
   for (const [key, value] of Object.entries(fragment)) {
@@ -32954,23 +32960,23 @@ function skillsAddArgs(options = {}) {
 // src/init/init.ts
 var TEMPLATES_DIR2 = resolveTemplatesDir();
 function writeScaffold(cwd) {
-  const skeletonDir2 = join21(cwd, ".skeleton");
+  const skeletonDir2 = join19(cwd, ".skeleton");
   mkdirSync4(skeletonDir2, { recursive: true });
   let created = false;
-  const tomlPath = join21(cwd, "skeleton.toml");
-  const legacyYaml = join21(skeletonDir2, "config.yaml");
-  if (!(existsSync23(tomlPath) || existsSync23(legacyYaml))) {
-    copyFileSync(join21(TEMPLATES_DIR2, "skeleton.toml"), tomlPath);
+  const tomlPath = join19(cwd, "skeleton.toml");
+  const legacyYaml = join19(skeletonDir2, "config.yaml");
+  if (!(existsSync21(tomlPath) || existsSync21(legacyYaml))) {
+    copyFileSync(join19(TEMPLATES_DIR2, "skeleton.toml"), tomlPath);
     created = true;
   }
-  mkdirSync4(join21(skeletonDir2, "customize"), { recursive: true });
+  mkdirSync4(join19(skeletonDir2, "customize"), { recursive: true });
   return created ? "created" : "skipped";
 }
 function assertPackageResolvable(cwd) {
-  const pkgPath = join21(cwd, "package.json");
-  if (!existsSync23(pkgPath))
+  const pkgPath = join19(cwd, "package.json");
+  if (!existsSync21(pkgPath))
     return;
-  const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
   const hasDep = pkg.devDependencies?.["@csark0812/skeleton"] || pkg.dependencies?.["@csark0812/skeleton"];
   if (!hasDep) {
     try {
@@ -33054,7 +33060,7 @@ function parseInitArgs(argv) {
 // src/plugins/build.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync20, writeFileSync as writeFileSync5 } from "node:fs";
 import { basename as basename4, dirname as dirname13, resolve as resolve7 } from "node:path";
 function parseBuildPluginArgs(argv) {
   let check = false;
@@ -33095,7 +33101,7 @@ function localImportPaths(tsAbs, content3) {
       candidates.push(resolve7(dir, spec), resolve7(dir, `${spec}.ts`), resolve7(dir, `${spec}.js`), resolve7(dir, spec, "index.ts"));
     }
     for (const candidate of candidates) {
-      if (existsSync24(candidate) && candidate.endsWith(".ts")) {
+      if (existsSync22(candidate) && candidate.endsWith(".ts")) {
         deps.push(candidate);
         break;
       }
@@ -33112,7 +33118,7 @@ function sourceFingerprint(tsAbs, seen = new Set) {
     if (seen.has(abs))
       return;
     seen.add(abs);
-    const content3 = readFileSync22(abs, "utf8");
+    const content3 = readFileSync20(abs, "utf8");
     hash2.update(basename4(abs));
     hash2.update("\x00");
     hash2.update(content3);
@@ -33130,7 +33136,7 @@ function writeStamp(tsAbs, mjsAbs) {
 }
 async function buildOne(tsAbs) {
   const mjsAbs = mjsPathForTs(tsAbs);
-  if (!existsSync24(tsAbs)) {
+  if (!existsSync22(tsAbs)) {
     throw new Error(`Plugin source not found: ${tsAbs}`);
   }
   const proc = spawnSync3("bun", ["build", tsAbs, "--target=node", "--format=esm", `--outfile=${mjsAbs}`, "--packages=external"], { encoding: "utf8" });
@@ -33150,17 +33156,17 @@ ${proc.stderr || proc.stdout || `exit ${proc.status}`}`);
 }
 function checkOne(tsAbs) {
   const mjsAbs = mjsPathForTs(tsAbs);
-  if (!existsSync24(mjsAbs)) {
+  if (!existsSync22(mjsAbs)) {
     throw new Error(`Plugin not built: ${tsAbs} (missing ${mjsAbs}). Run: skeleton build-plugin`);
   }
-  if (!existsSync24(tsAbs)) {
+  if (!existsSync22(tsAbs)) {
     throw new Error(`Plugin source not found: ${tsAbs}`);
   }
   const stampAbs = stampPathForMjs(mjsAbs);
-  if (!existsSync24(stampAbs)) {
+  if (!existsSync22(stampAbs)) {
     throw new Error(`Plugin stale: ${mjsAbs} has no fingerprint stamp. Run: skeleton build-plugin`);
   }
-  const expected = readFileSync22(stampAbs, "utf8").trim();
+  const expected = readFileSync20(stampAbs, "utf8").trim();
   const actual = sourceFingerprint(tsAbs);
   if (expected !== actual) {
     throw new Error(`Plugin stale: ${mjsAbs} does not match ${tsAbs} (or local imports). Run: skeleton build-plugin`);
@@ -33188,178 +33194,10 @@ async function runBuildPlugin(options = {}) {
   return { built, checked };
 }
 
-// src/references/run.ts
-import process8 from "node:process";
-
-// src/references/sync.ts
-import {
-  existsSync as existsSync25,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync23,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync6
-} from "node:fs";
-import { dirname as dirname14, join as join22, relative as relative13 } from "node:path";
-import process7 from "node:process";
-function resolveOwnership(root2, override) {
-  if (override !== undefined)
-    return override;
-  try {
-    return loadConfig(root2).skillOwnership;
-  } catch {}
-}
-function walkMarkdownFiles2(dir, root2) {
-  const files = [];
-  if (!existsSync25(dir))
-    return files;
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith("."))
-      continue;
-    const fullPath = join22(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...walkMarkdownFiles2(fullPath, root2));
-      continue;
-    }
-    if (entry.name.endsWith(".md")) {
-      files.push(normalizeRelPath(relative13(root2, fullPath)));
-    }
-  }
-  return files;
-}
-function collectGeneratedInDir(input) {
-  const { dir, refsDir, skillDir, files } = input;
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const fullPath = join22(dir, entry.name);
-    if (entry.isDirectory()) {
-      collectGeneratedInDir({ dir: fullPath, refsDir, skillDir, files });
-      continue;
-    }
-    if (!entry.name.endsWith(".md"))
-      continue;
-    const content3 = readFileSync23(fullPath, "utf8");
-    if (!isGeneratedReference(content3))
-      continue;
-    const refPath = normalizeRelPath(relative13(refsDir, fullPath));
-    files.push(generatedRefPath(skillDir, refPath));
-  }
-}
-function listGeneratedReferenceFiles(root2, skillDir) {
-  const refsDir = join22(root2, skillDir, "references");
-  if (!existsSync25(refsDir))
-    return [];
-  const files = [];
-  collectGeneratedInDir({ dir: refsDir, refsDir, skillDir, files });
-  return files;
-}
-function syncGeneratedCopy(ctx, refPath) {
-  const { root: root2, plan, options, result } = ctx;
-  const sourceRel = normalizeRelPath(join22(CANONICAL_REFS_DIR, refPath));
-  const canonicalPath = join22(root2, sourceRel);
-  if (!existsSync25(canonicalPath)) {
-    throw new Error(`canonical reference missing: ${sourceRel}`);
-  }
-  const targetRel = generatedRefPath(plan.skillDir, refPath);
-  const targetPath = join22(root2, targetRel);
-  const canonicalContent = readFileSync23(canonicalPath, "utf8");
-  const nextContent = formatGeneratedHeader(sourceRel) + canonicalContent;
-  if (!options.dryRun)
-    mkdirSync5(dirname14(targetPath), { recursive: true });
-  const existing = existsSync25(targetPath) ? readFileSync23(targetPath, "utf8") : null;
-  if (existing !== nextContent) {
-    if (!options.dryRun)
-      writeFileSync6(targetPath, nextContent, "utf8");
-    result.written.push(targetRel);
-  } else {
-    result.skipped.push(targetRel);
-  }
-}
-function rewritePlanLinks(ctx, skillDir) {
-  const { root: root2, plan, options, result } = ctx;
-  if (options.rewriteLinks === false)
-    return;
-  for (const relFile of walkMarkdownFiles2(skillDir, root2)) {
-    const filePath = join22(root2, relFile);
-    const content3 = readFileSync23(filePath, "utf8");
-    const next = rewriteSharedRefLinks(content3, relFile, plan.skillDir);
-    if (next === content3)
-      continue;
-    if (!options.dryRun)
-      writeFileSync6(filePath, next, "utf8");
-    result.rewritten.push(relFile);
-  }
-}
-function removeStaleGenerated(ctx) {
-  const { root: root2, plan, options, result } = ctx;
-  for (const generatedRel of listGeneratedReferenceFiles(root2, plan.skillDir)) {
-    const refPath = generatedRel.slice(`${plan.skillDir}/references/`.length);
-    if (plan.refPaths.has(refPath))
-      continue;
-    if (!options.dryRun)
-      unlinkSync2(join22(root2, generatedRel));
-    result.removed.push(generatedRel);
-  }
-}
-function syncPlan(ctx) {
-  const skillDir = join22(ctx.root, ctx.plan.skillDir);
-  for (const refPath of ctx.plan.refPaths) {
-    syncGeneratedCopy(ctx, refPath);
-  }
-  rewritePlanLinks(ctx, skillDir);
-  removeStaleGenerated(ctx);
-}
-function syncReferences(options = {}) {
-  const root2 = options.root ?? process7.cwd();
-  const canonicalDir = join22(root2, CANONICAL_REFS_DIR);
-  if (!existsSync25(canonicalDir)) {
-    throw new Error(`canonical references dir not found: ${CANONICAL_REFS_DIR}`);
-  }
-  const result = { written: [], rewritten: [], removed: [], skipped: [] };
-  const plans = discoverSkillReferencePlans(root2, resolveOwnership(root2, options.ownership));
-  for (const plan of plans)
-    syncPlan({ root: root2, plan, options, result });
-  return result;
-}
-
-// src/references/run.ts
-function runReferencesSync(options = {}) {
-  return syncReferences(options);
-}
-function runReferencesCheck(options = {}) {
-  const root2 = options.root ?? process8.cwd();
-  let ownership;
-  try {
-    ownership = loadConfig(root2).skillOwnership;
-  } catch {
-    ownership = undefined;
-  }
-  const issues = runGeneratedReferencesCheck(root2, ownership);
-  return printReport(issues, {
-    strict: options.strict,
-    json: options.json,
-    label: "References check"
-  });
-}
-function printSyncSection(label, files, prefix) {
-  if (files.length === 0)
-    return;
-  console.log(label);
-  for (const file of files)
-    console.log(`  ${prefix} ${file}`);
-}
-function printSyncResult(result) {
-  printSyncSection(`references sync: wrote ${result.written.length} file(s)`, result.written, "+");
-  printSyncSection(`references sync: rewrote links in ${result.rewritten.length} file(s)`, result.rewritten, "~");
-  printSyncSection(`references sync: removed ${result.removed.length} stale file(s)`, result.removed, "-");
-  if (result.written.length === 0 && result.rewritten.length === 0 && result.removed.length === 0) {
-    console.log(`references sync: up to date (${result.skipped.length} file(s) checked)`);
-  }
-}
-
 // src/validate/changed.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync24 } from "node:fs";
-import { basename as basename5, extname as extname2, join as join23 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "node:fs";
+import { basename as basename5, extname as extname2, join as join20 } from "node:path";
 
 // src/validate/git-diff.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
@@ -33477,25 +33315,25 @@ function validationIssue(code3, file, message) {
   return issue("validate-changed", file, { code: code3, message, severity: "error" });
 }
 function validateJson(relPath2, root2) {
-  const abs = join23(root2, relPath2);
+  const abs = join20(root2, relPath2);
   try {
-    parseJsonContent(readFileSync24(abs, "utf8"));
+    parseJsonContent(readFileSync21(abs, "utf8"));
     return null;
   } catch (error) {
     return validationIssue("invalid-json", relPath2, `invalid JSON: ${error}`);
   }
 }
 function validatePolicy(relPath2, root2) {
-  const abs = join23(root2, relPath2);
+  const abs = join20(root2, relPath2);
   try {
-    loadPolicyFile(abs, readFileSync24(abs, "utf8"));
+    loadPolicyFile(abs, readFileSync21(abs, "utf8"));
     return null;
   } catch (error) {
     return validationIssue("invalid-policy", relPath2, `invalid policy: ${error}`);
   }
 }
 function validateShell(relPath2, root2) {
-  const abs = join23(root2, relPath2);
+  const abs = join20(root2, relPath2);
   const shellcheck = spawnSync5("shellcheck", [abs], { encoding: "utf8" });
   if (shellcheck.status === 0)
     return null;
@@ -33519,11 +33357,11 @@ function resolvePaths(options) {
   };
 }
 function packageManagerFromPackageJson(root2) {
-  const pkgPath = join23(root2, "package.json");
-  if (!existsSync26(pkgPath))
+  const pkgPath = join20(root2, "package.json");
+  if (!existsSync23(pkgPath))
     return null;
   try {
-    const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
     const raw = pkg.packageManager?.split("@")[0];
     if (raw === "bun" || raw === "npm" || raw === "pnpm" || raw === "yarn")
       return raw;
@@ -33531,13 +33369,13 @@ function packageManagerFromPackageJson(root2) {
   return null;
 }
 function packageManagerFromLockfiles(root2) {
-  if (existsSync26(join23(root2, "bun.lock")) || existsSync26(join23(root2, "bun.lockb")))
+  if (existsSync23(join20(root2, "bun.lock")) || existsSync23(join20(root2, "bun.lockb")))
     return "bun";
-  if (existsSync26(join23(root2, "pnpm-lock.yaml")))
+  if (existsSync23(join20(root2, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync26(join23(root2, "yarn.lock")))
+  if (existsSync23(join20(root2, "yarn.lock")))
     return "yarn";
-  if (existsSync26(join23(root2, "package-lock.json")))
+  if (existsSync23(join20(root2, "package-lock.json")))
     return "npm";
   return null;
 }
@@ -33563,8 +33401,8 @@ function emptyBuckets() {
 function classifySinglePath(input) {
   const { relPath: relPath2, ctx, state, bucketCtx } = input;
   const normalized = normalizeRelPath(relPath2);
-  const abs = join23(ctx.root, normalized);
-  if (!existsSync26(abs)) {
+  const abs = join20(ctx.root, normalized);
+  if (!existsSync23(abs)) {
     state.missing.push(normalized);
     return;
   }
@@ -33636,7 +33474,7 @@ function discoverImpactedDocuments(input) {
 }
 function impactedDocumentForPath(abs, root2, changed) {
   const path3 = relPath(abs, root2);
-  const reviewDependencies = reviewDependencyPatterns(readFileSync24(abs, "utf8"));
+  const reviewDependencies = reviewDependencyPatterns(readFileSync21(abs, "utf8"));
   const reasons = impactReasons(path3, reviewDependencies, changed);
   return reasons.length > 0 ? { path: path3, reviewDependencies, reasons } : null;
 }
@@ -33660,7 +33498,7 @@ function dateModeImpactDiagnostics(input) {
   for (const impacted of input.impactedDocuments) {
     if (!impacted.reasons.some((reason) => reason.kind === "changed-review-dependency"))
       continue;
-    const content3 = readFileSync24(join23(input.root, impacted.path), "utf8");
+    const content3 = readFileSync21(join20(input.root, impacted.path), "utf8");
     if (changed.has(impacted.path) && docMetaLastReviewed(content3) === today)
       continue;
     diagnostics.push(validationIssue("impacted-document-review-required", impacted.path, "a linked review dependency changed; re-read the entire document, then attest it with --fix=doc-meta --confirm-reviewed and include the document in validation"));
@@ -33887,9 +33725,6 @@ Commands:
   catalog [--check] [--strict]  write or check .skeleton/catalog.md (gitignored)
   customize resolve <slug> [--json]
   hook customize            (reads a host hook payload on stdin)
-  references sync [--dry-run] [--no-rewrite-links]
-  references check [--json] [--strict]
-
 Note: \`register\` was removed — add a source-of-truth marker to the file and run \`skeleton catalog\`.`);
 }
 function parseValidateChangedArgs(rest) {
@@ -33964,7 +33799,7 @@ function handleCustomizeResolve(argv) {
   if (json) {
     console.log(JSON.stringify(result, null, 2));
   } else if (result.content) {
-    process9.stdout.write(result.content);
+    process7.stdout.write(result.content);
   }
   return 0;
 }
@@ -33973,31 +33808,13 @@ function handleHook(argv) {
     usage();
     return 1;
   }
-  process9.stdout.write(runCustomizeHook(readFileSync25(0, "utf8")));
+  process7.stdout.write(runCustomizeHook(readFileSync22(0, "utf8")));
   return 0;
 }
 function handleInit(argv) {
   runInit(parseInitArgs(argv));
   return 0;
 }
-function handleReferences(argv) {
-  const sub = argv[0];
-  if (sub === "sync") {
-    const dryRun = argv.includes("--dry-run");
-    const rewriteLinks = !argv.includes("--no-rewrite-links");
-    const result = runReferencesSync({ dryRun, rewriteLinks });
-    printSyncResult(result);
-    return 0;
-  }
-  if (sub === "check") {
-    return runReferencesCheck({
-      json: argv.includes("--json"),
-      strict: argv.includes("--strict")
-    });
-  }
-  usage();
-  return 1;
-}
 async function dispatchCommand(argv) {
   const command = argv[0];
   const rest = argv.slice(1);
@@ -34018,29 +33835,27 @@ async function dispatchCommand(argv) {
       return handleHook(rest);
     case "init":
       return handleInit(rest);
-    case "references":
-      return handleReferences(rest);
     default:
       return null;
   }
 }
 async function main() {
-  const argv = process9.argv.slice(2);
+  const argv = process7.argv.slice(2);
   const command = argv[0];
   if (!command || command === "--help" || command === "-h") {
     usage();
-    process9.exit(command ? 0 : 1);
+    process7.exit(command ? 0 : 1);
   }
   try {
     const exitCode = await dispatchCommand(argv);
     if (exitCode === null) {
       usage();
-      process9.exit(1);
+      process7.exit(1);
     }
-    process9.exit(exitCode);
+    process7.exit(exitCode);
   } catch (error) {
     console.error(String(error));
-    process9.exit(1);
+    process7.exit(1);
   }
 }
 main();