@skillrecordings/cli 0.4.0 → 0.5.0

package/dist/index.js

@@ -424,8 +424,8 @@ var require_url_state_machine = __commonJS({
     function countSymbols(str2) {
       return punycode.ucs2.decode(str2).length;
     }
-    function at(input2, idx) {
-      const c = input2[idx];
+    function at(input3, idx) {
+      const c = input3[idx];
       return isNaN(c) ? void 0 : String.fromCodePoint(c);
     }
     function isASCIIDigit(c) {
@@ -487,16 +487,16 @@ var require_url_state_machine = __commonJS({
       return str2;
     }
     function utf8PercentDecode(str2) {
-      const input2 = new Buffer(str2);
+      const input3 = new Buffer(str2);
       const output = [];
-      for (let i = 0; i < input2.length; ++i) {
-        if (input2[i] !== 37) {
-          output.push(input2[i]);
-        } else if (input2[i] === 37 && isASCIIHex(input2[i + 1]) && isASCIIHex(input2[i + 2])) {
-          output.push(parseInt(input2.slice(i + 1, i + 3).toString(), 16));
+      for (let i = 0; i < input3.length; ++i) {
+        if (input3[i] !== 37) {
+          output.push(input3[i]);
+        } else if (input3[i] === 37 && isASCIIHex(input3[i + 1]) && isASCIIHex(input3[i + 2])) {
+          output.push(parseInt(input3.slice(i + 1, i + 3).toString(), 16));
           i += 2;
         } else {
-          output.push(input2[i]);
+          output.push(input3[i]);
         }
       }
       return new Buffer(output).toString();
@@ -519,42 +519,42 @@ var require_url_state_machine = __commonJS({
       }
       return cStr;
     }
-    function parseIPv4Number(input2) {
+    function parseIPv4Number(input3) {
       let R = 10;
-      if (input2.length >= 2 && input2.charAt(0) === "0" && input2.charAt(1).toLowerCase() === "x") {
-        input2 = input2.substring(2);
+      if (input3.length >= 2 && input3.charAt(0) === "0" && input3.charAt(1).toLowerCase() === "x") {
+        input3 = input3.substring(2);
         R = 16;
-      } else if (input2.length >= 2 && input2.charAt(0) === "0") {
-        input2 = input2.substring(1);
+      } else if (input3.length >= 2 && input3.charAt(0) === "0") {
+        input3 = input3.substring(1);
         R = 8;
       }
-      if (input2 === "") {
+      if (input3 === "") {
         return 0;
       }
       const regex = R === 10 ? /[^0-9]/ : R === 16 ? /[^0-9A-Fa-f]/ : /[^0-7]/;
-      if (regex.test(input2)) {
+      if (regex.test(input3)) {
         return failure;
       }
-      return parseInt(input2, R);
+      return parseInt(input3, R);
     }
-    function parseIPv4(input2) {
-      const parts = input2.split(".");
+    function parseIPv4(input3) {
+      const parts = input3.split(".");
       if (parts[parts.length - 1] === "") {
         if (parts.length > 1) {
           parts.pop();
         }
       }
       if (parts.length > 4) {
-        return input2;
+        return input3;
       }
       const numbers = [];
       for (const part of parts) {
         if (part === "") {
-          return input2;
+          return input3;
         }
         const n = parseIPv4Number(part);
         if (n === failure) {
-          return input2;
+          return input3;
         }
         numbers.push(n);
       }
@@ -586,25 +586,25 @@ var require_url_state_machine = __commonJS({
       }
       return output;
     }
-    function parseIPv6(input2) {
+    function parseIPv6(input3) {
       const address = [0, 0, 0, 0, 0, 0, 0, 0];
       let pieceIndex = 0;
       let compress = null;
       let pointer = 0;
-      input2 = punycode.ucs2.decode(input2);
-      if (input2[pointer] === 58) {
-        if (input2[pointer + 1] !== 58) {
+      input3 = punycode.ucs2.decode(input3);
+      if (input3[pointer] === 58) {
+        if (input3[pointer + 1] !== 58) {
           return failure;
         }
         pointer += 2;
         ++pieceIndex;
         compress = pieceIndex;
       }
-      while (pointer < input2.length) {
+      while (pointer < input3.length) {
         if (pieceIndex === 8) {
           return failure;
         }
-        if (input2[pointer] === 58) {
+        if (input3[pointer] === 58) {
           if (compress !== null) {
             return failure;
           }
@@ -615,12 +615,12 @@ var require_url_state_machine = __commonJS({
         }
         let value = 0;
         let length = 0;
-        while (length < 4 && isASCIIHex(input2[pointer])) {
-          value = value * 16 + parseInt(at(input2, pointer), 16);
+        while (length < 4 && isASCIIHex(input3[pointer])) {
+          value = value * 16 + parseInt(at(input3, pointer), 16);
           ++pointer;
           ++length;
         }
-        if (input2[pointer] === 46) {
+        if (input3[pointer] === 46) {
           if (length === 0) {
             return failure;
           }
@@ -629,20 +629,20 @@ var require_url_state_machine = __commonJS({
             return failure;
           }
           let numbersSeen = 0;
-          while (input2[pointer] !== void 0) {
+          while (input3[pointer] !== void 0) {
             let ipv4Piece = null;
             if (numbersSeen > 0) {
-              if (input2[pointer] === 46 && numbersSeen < 4) {
+              if (input3[pointer] === 46 && numbersSeen < 4) {
                 ++pointer;
               } else {
                 return failure;
               }
             }
-            if (!isASCIIDigit(input2[pointer])) {
+            if (!isASCIIDigit(input3[pointer])) {
               return failure;
             }
-            while (isASCIIDigit(input2[pointer])) {
-              const number = parseInt(at(input2, pointer));
+            while (isASCIIDigit(input3[pointer])) {
+              const number = parseInt(at(input3, pointer));
               if (ipv4Piece === null) {
                 ipv4Piece = number;
               } else if (ipv4Piece === 0) {
@@ -665,12 +665,12 @@ var require_url_state_machine = __commonJS({
             return failure;
           }
           break;
-        } else if (input2[pointer] === 58) {
+        } else if (input3[pointer] === 58) {
           ++pointer;
-          if (input2[pointer] === void 0) {
+          if (input3[pointer] === void 0) {
             return failure;
           }
-        } else if (input2[pointer] !== void 0) {
+        } else if (input3[pointer] !== void 0) {
           return failure;
         }
         address[pieceIndex] = value;
@@ -715,17 +715,17 @@ var require_url_state_machine = __commonJS({
       }
       return output;
     }
-    function parseHost(input2, isSpecialArg) {
-      if (input2[0] === "[") {
-        if (input2[input2.length - 1] !== "]") {
+    function parseHost(input3, isSpecialArg) {
+      if (input3[0] === "[") {
+        if (input3[input3.length - 1] !== "]") {
           return failure;
         }
-        return parseIPv6(input2.substring(1, input2.length - 1));
+        return parseIPv6(input3.substring(1, input3.length - 1));
       }
       if (!isSpecialArg) {
-        return parseOpaqueHost(input2);
+        return parseOpaqueHost(input3);
       }
-      const domain = utf8PercentDecode(input2);
+      const domain = utf8PercentDecode(input3);
       const asciiDomain = tr46.toASCII(domain, false, tr46.PROCESSING_OPTIONS.NONTRANSITIONAL, false);
       if (asciiDomain === null) {
         return failure;
@@ -739,12 +739,12 @@ var require_url_state_machine = __commonJS({
       }
       return asciiDomain;
     }
-    function parseOpaqueHost(input2) {
-      if (containsForbiddenHostCodePointExcludingPercent(input2)) {
+    function parseOpaqueHost(input3) {
+      if (containsForbiddenHostCodePointExcludingPercent(input3)) {
         return failure;
       }
       let output = "";
-      const decoded = punycode.ucs2.decode(input2);
+      const decoded = punycode.ucs2.decode(input3);
       for (let i = 0; i < decoded.length; ++i) {
         output += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
       }
@@ -813,9 +813,9 @@ var require_url_state_machine = __commonJS({
     function isNormalizedWindowsDriveLetter(string) {
       return /^[A-Za-z]:$/.test(string);
     }
-    function URLStateMachine(input2, base, encodingOverride, url, stateOverride) {
+    function URLStateMachine(input3, base, encodingOverride, url, stateOverride) {
       this.pointer = 0;
-      this.input = input2;
+      this.input = input3;
       this.base = base || null;
       this.encodingOverride = encodingOverride || "utf-8";
       this.stateOverride = stateOverride;
@@ -1439,11 +1439,11 @@ var require_url_state_machine = __commonJS({
           return "null";
       }
     };
-    module.exports.basicURLParse = function(input2, options) {
+    module.exports.basicURLParse = function(input3, options) {
       if (options === void 0) {
         options = {};
       }
-      const usm = new URLStateMachine(input2, options.baseURL, options.encodingOverride, options.url, options.stateOverride);
+      const usm = new URLStateMachine(input3, options.baseURL, options.encodingOverride, options.url, options.stateOverride);
       if (usm.failure) {
         return "failure";
       }
@@ -1456,9 +1456,9 @@ var require_url_state_machine = __commonJS({
         url.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
       }
     };
-    module.exports.setThePassword = function(url, password) {
+    module.exports.setThePassword = function(url, password2) {
       url.password = "";
-      const decoded = punycode.ucs2.decode(password);
+      const decoded = punycode.ucs2.decode(password2);
       for (let i = 0; i < decoded.length; ++i) {
         url.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
       }
@@ -1468,11 +1468,11 @@ var require_url_state_machine = __commonJS({
     module.exports.serializeInteger = function(integer) {
       return String(integer);
     };
-    module.exports.parseURL = function(input2, options) {
+    module.exports.parseURL = function(input3, options) {
       if (options === void 0) {
         options = {};
       }
-      return module.exports.basicURLParse(input2, { baseURL: options.baseURL, encodingOverride: options.encodingOverride });
+      return module.exports.basicURLParse(input3, { baseURL: options.baseURL, encodingOverride: options.encodingOverride });
     };
   }
 });
@@ -1609,9 +1609,9 @@ var require_URL_impl = __commonJS({
           url.query = null;
           return;
         }
-        const input2 = v[0] === "?" ? v.substring(1) : v;
+        const input3 = v[0] === "?" ? v.substring(1) : v;
         url.query = "";
-        usm.basicURLParse(input2, { url, stateOverride: "query" });
+        usm.basicURLParse(input3, { url, stateOverride: "query" });
       }
       get hash() {
         if (this._url.fragment === null || this._url.fragment === "") {
@@ -1624,9 +1624,9 @@ var require_URL_impl = __commonJS({
           this._url.fragment = null;
           return;
         }
-        const input2 = v[0] === "#" ? v.substring(1) : v;
+        const input3 = v[0] === "#" ? v.substring(1) : v;
         this._url.fragment = "";
-        usm.basicURLParse(input2, { url: this._url, stateOverride: "fragment" });
+        usm.basicURLParse(input3, { url: this._url, stateOverride: "fragment" });
       }
       toJSON() {
         return this.href;
@@ -10860,23 +10860,23 @@ var require_infra = __commonJS({
     init_esm_shims();
     var assert = __require("assert");
     var { utf8DecodeBytes } = require_encoding2();
-    function collectASequenceOfCodePoints(condition, input2, position) {
+    function collectASequenceOfCodePoints(condition, input3, position) {
       let result = "";
-      while (position.position < input2.length && condition(input2[position.position])) {
-        result += input2[position.position];
+      while (position.position < input3.length && condition(input3[position.position])) {
+        result += input3[position.position];
         position.position++;
       }
       return result;
     }
-    function collectASequenceOfCodePointsFast(char, input2, position) {
-      const idx = input2.indexOf(char, position.position);
+    function collectASequenceOfCodePointsFast(char, input3, position) {
+      const idx = input3.indexOf(char, position.position);
       const start = position.position;
       if (idx === -1) {
-        position.position = input2.length;
-        return input2.slice(start);
+        position.position = input3.length;
+        return input3.slice(start);
       }
       position.position = idx;
-      return input2.slice(start, position.position);
+      return input3.slice(start, position.position);
     }
     var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g;
     function forgivingBase64(data2) {
@@ -10906,10 +10906,10 @@ var require_infra = __commonJS({
       char === 13 || // \r
       char === 32;
     }
-    function isomorphicDecode(input2) {
-      const length = input2.length;
+    function isomorphicDecode(input3) {
+      const length = input3.length;
       if ((2 << 15) - 1 > length) {
-        return String.fromCharCode.apply(null, input2);
+        return String.fromCharCode.apply(null, input3);
       }
       let result = "";
       let i = 0;
@@ -10918,14 +10918,14 @@ var require_infra = __commonJS({
         if (i + addition > length) {
           addition = length - i;
         }
-        result += String.fromCharCode.apply(null, input2.subarray(i, i += addition));
+        result += String.fromCharCode.apply(null, input3.subarray(i, i += addition));
       }
       return result;
     }
     var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/;
-    function isomorphicEncode(input2) {
-      assert(!invalidIsomorphicEncodeValueRegex.test(input2));
-      return input2;
+    function isomorphicEncode(input3) {
+      assert(!invalidIsomorphicEncodeValueRegex.test(input3));
+      return input3;
     }
     function parseJSONFromBytes(bytes) {
       return JSON.parse(utf8DecodeBytes(bytes));
@@ -10980,21 +10980,21 @@ var require_data_url = __commonJS({
     var HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/u;
     function dataURLProcessor(dataURL) {
       assert(dataURL.protocol === "data:");
-      let input2 = URLSerializer(dataURL, true);
-      input2 = input2.slice(5);
+      let input3 = URLSerializer(dataURL, true);
+      input3 = input3.slice(5);
       const position = { position: 0 };
       let mimeType = collectASequenceOfCodePointsFast(
         ",",
-        input2,
+        input3,
         position
       );
       const mimeTypeLength = mimeType.length;
       mimeType = removeASCIIWhitespace(mimeType, true, true);
-      if (position.position >= input2.length) {
+      if (position.position >= input3.length) {
         return "failure";
       }
       position.position++;
-      const encodedBody = input2.slice(mimeTypeLength + 1);
+      const encodedBody = input3.slice(mimeTypeLength + 1);
       let body = stringPercentDecode(encodedBody);
       if (/;(?:\u0020*)base64$/ui.test(mimeType)) {
         const stringBody = isomorphicDecode(body);
@@ -11027,8 +11027,8 @@ var require_data_url = __commonJS({
       }
       return serialized;
     }
-    function stringPercentDecode(input2) {
-      const bytes = encoder.encode(input2);
+    function stringPercentDecode(input3) {
+      const bytes = encoder.encode(input3);
       return percentDecode(bytes);
     }
     function isHexCharByte(byte) {
@@ -11040,43 +11040,43 @@ var require_data_url = __commonJS({
         byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55
       );
     }
-    function percentDecode(input2) {
-      const length = input2.length;
+    function percentDecode(input3) {
+      const length = input3.length;
       const output = new Uint8Array(length);
       let j = 0;
       let i = 0;
       while (i < length) {
-        const byte = input2[i];
+        const byte = input3[i];
         if (byte !== 37) {
           output[j++] = byte;
-        } else if (byte === 37 && !(isHexCharByte(input2[i + 1]) && isHexCharByte(input2[i + 2]))) {
+        } else if (byte === 37 && !(isHexCharByte(input3[i + 1]) && isHexCharByte(input3[i + 2]))) {
           output[j++] = 37;
         } else {
-          output[j++] = hexByteToNumber(input2[i + 1]) << 4 | hexByteToNumber(input2[i + 2]);
+          output[j++] = hexByteToNumber(input3[i + 1]) << 4 | hexByteToNumber(input3[i + 2]);
           i += 2;
         }
         ++i;
       }
       return length === j ? output : output.subarray(0, j);
     }
-    function parseMIMEType(input2) {
-      input2 = removeHTTPWhitespace(input2, true, true);
+    function parseMIMEType(input3) {
+      input3 = removeHTTPWhitespace(input3, true, true);
       const position = { position: 0 };
       const type = collectASequenceOfCodePointsFast(
         "/",
-        input2,
+        input3,
         position
       );
       if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
         return "failure";
       }
-      if (position.position >= input2.length) {
+      if (position.position >= input3.length) {
         return "failure";
       }
       position.position++;
       let subtype = collectASequenceOfCodePointsFast(
         ";",
-        input2,
+        input3,
         position
       );
       subtype = removeHTTPWhitespace(subtype, false, true);
@@ -11093,41 +11093,41 @@ var require_data_url = __commonJS({
         // https://mimesniff.spec.whatwg.org/#mime-type-essence
         essence: `${typeLowercase}/${subtypeLowercase}`
       };
-      while (position.position < input2.length) {
+      while (position.position < input3.length) {
         position.position++;
         collectASequenceOfCodePoints(
           // https://fetch.spec.whatwg.org/#http-whitespace
           (char) => HTTP_WHITESPACE_REGEX.test(char),
-          input2,
+          input3,
           position
         );
         let parameterName = collectASequenceOfCodePoints(
           (char) => char !== ";" && char !== "=",
-          input2,
+          input3,
           position
         );
         parameterName = parameterName.toLowerCase();
-        if (position.position < input2.length) {
-          if (input2[position.position] === ";") {
+        if (position.position < input3.length) {
+          if (input3[position.position] === ";") {
             continue;
           }
           position.position++;
         }
-        if (position.position >= input2.length) {
+        if (position.position >= input3.length) {
           break;
         }
         let parameterValue = null;
-        if (input2[position.position] === '"') {
-          parameterValue = collectAnHTTPQuotedString(input2, position, true);
+        if (input3[position.position] === '"') {
+          parameterValue = collectAnHTTPQuotedString(input3, position, true);
           collectASequenceOfCodePointsFast(
             ";",
-            input2,
+            input3,
             position
           );
         } else {
           parameterValue = collectASequenceOfCodePointsFast(
             ";",
-            input2,
+            input3,
             position
           );
           parameterValue = removeHTTPWhitespace(parameterValue, false, true);
@@ -11141,28 +11141,28 @@ var require_data_url = __commonJS({
       }
       return mimeType;
     }
-    function collectAnHTTPQuotedString(input2, position, extractValue = false) {
+    function collectAnHTTPQuotedString(input3, position, extractValue = false) {
       const positionStart = position.position;
       let value = "";
-      assert(input2[position.position] === '"');
+      assert(input3[position.position] === '"');
       position.position++;
       while (true) {
         value += collectASequenceOfCodePoints(
           (char) => char !== '"' && char !== "\\",
-          input2,
+          input3,
           position
         );
-        if (position.position >= input2.length) {
+        if (position.position >= input3.length) {
           break;
         }
-        const quoteOrBackslash = input2[position.position];
+        const quoteOrBackslash = input3[position.position];
         position.position++;
         if (quoteOrBackslash === "\\") {
-          if (position.position >= input2.length) {
+          if (position.position >= input3.length) {
             value += "\\";
             break;
           }
-          value += input2[position.position];
+          value += input3[position.position];
           position.position++;
         } else {
           assert(quoteOrBackslash === '"');
@@ -11172,7 +11172,7 @@ var require_data_url = __commonJS({
       if (extractValue) {
         return value;
       }
-      return input2.slice(positionStart, position.position);
+      return input3.slice(positionStart, position.position);
     }
     function serializeAMimeType(mimeType) {
       assert(mimeType !== "failure");
@@ -12609,27 +12609,27 @@ var require_util2 = __commonJS({
       return mimeType;
     }
     function gettingDecodingSplitting(value) {
-      const input2 = value;
+      const input3 = value;
       const position = { position: 0 };
       const values = [];
       let temporaryValue = "";
-      while (position.position < input2.length) {
+      while (position.position < input3.length) {
         temporaryValue += collectASequenceOfCodePoints(
           (char) => char !== '"' && char !== ",",
-          input2,
+          input3,
           position
         );
-        if (position.position < input2.length) {
-          if (input2.charCodeAt(position.position) === 34) {
+        if (position.position < input3.length) {
+          if (input3.charCodeAt(position.position) === 34) {
             temporaryValue += collectAnHTTPQuotedString(
-              input2,
+              input3,
               position
             );
-            if (position.position < input2.length) {
+            if (position.position < input3.length) {
               continue;
             }
           } else {
-            assert(input2.charCodeAt(position.position) === 44);
+            assert(input3.charCodeAt(position.position) === 44);
             position.position++;
           }
         }
@@ -12918,7 +12918,7 @@ var require_formdata_parser = __commonJS({
       }
       return true;
     }
-    function multipartFormDataParser(input2, mimeType) {
+    function multipartFormDataParser(input3, mimeType) {
       assert(mimeType !== "failure" && mimeType.essence === "multipart/form-data");
       const boundaryString = mimeType.parameters.get("boundary");
       if (boundaryString === void 0) {
@@ -12927,40 +12927,40 @@ var require_formdata_parser = __commonJS({
       const boundary = Buffer.from(`--${boundaryString}`, "utf8");
       const entryList = [];
       const position = { position: 0 };
-      const firstBoundaryIndex = input2.indexOf(boundary);
+      const firstBoundaryIndex = input3.indexOf(boundary);
       if (firstBoundaryIndex === -1) {
         throw parsingError("no boundary found in multipart body");
       }
       position.position = firstBoundaryIndex;
       while (true) {
-        if (input2.subarray(position.position, position.position + boundary.length).equals(boundary)) {
+        if (input3.subarray(position.position, position.position + boundary.length).equals(boundary)) {
           position.position += boundary.length;
         } else {
           throw parsingError("expected a value starting with -- and the boundary");
         }
-        if (bufferStartsWith(input2, dd, position)) {
+        if (bufferStartsWith(input3, dd, position)) {
           return entryList;
         }
-        if (input2[position.position] !== 13 || input2[position.position + 1] !== 10) {
+        if (input3[position.position] !== 13 || input3[position.position + 1] !== 10) {
           throw parsingError("expected CRLF");
         }
         position.position += 2;
-        const result = parseMultipartFormDataHeaders(input2, position);
+        const result = parseMultipartFormDataHeaders(input3, position);
         let { name, filename, contentType, encoding } = result;
         position.position += 2;
         let body;
         {
-          const boundaryIndex = input2.indexOf(boundary.subarray(2), position.position);
+          const boundaryIndex = input3.indexOf(boundary.subarray(2), position.position);
           if (boundaryIndex === -1) {
             throw parsingError("expected boundary after body");
           }
-          body = input2.subarray(position.position, boundaryIndex - 4);
+          body = input3.subarray(position.position, boundaryIndex - 4);
           position.position += body.length;
           if (encoding === "base64") {
             body = Buffer.from(body.toString(), "base64");
           }
         }
-        if (input2[position.position] !== 13 || input2[position.position + 1] !== 10) {
+        if (input3[position.position] !== 13 || input3[position.position + 1] !== 10) {
           throw parsingError("expected CRLF");
         } else {
           position.position += 2;
@@ -12980,36 +12980,36 @@ var require_formdata_parser = __commonJS({
         entryList.push(makeEntry(name, value, filename));
       }
     }
-    function parseContentDispositionAttribute(input2, position) {
-      if (input2[position.position] === 59) {
+    function parseContentDispositionAttribute(input3, position) {
+      if (input3[position.position] === 59) {
         position.position++;
       }
       collectASequenceOfBytes(
         (char) => char === 32 || char === 9,
-        input2,
+        input3,
         position
       );
       const attributeName = collectASequenceOfBytes(
         (char) => isToken(char) && char !== 61 && char !== 42,
         // not = or *
-        input2,
+        input3,
         position
       );
       if (attributeName.length === 0) {
         return null;
       }
       const attrNameStr = attributeName.toString("ascii").toLowerCase();
-      const isExtended = input2[position.position] === 42;
+      const isExtended = input3[position.position] === 42;
       if (isExtended) {
         position.position++;
       }
-      if (input2[position.position] !== 61) {
+      if (input3[position.position] !== 61) {
         return null;
       }
       position.position++;
       collectASequenceOfBytes(
         (char) => char === 32 || char === 9,
-        input2,
+        input3,
         position
       );
       let value;
@@ -13017,7 +13017,7 @@ var require_formdata_parser = __commonJS({
         const headerValue = collectASequenceOfBytes(
           (char) => char !== 32 && char !== 13 && char !== 10 && char !== 59,
           // not space, CRLF, or ;
-          input2,
+          input3,
           position
         );
         if (headerValue[0] !== 117 && headerValue[0] !== 85 || // u or U
@@ -13028,15 +13028,15 @@ var require_formdata_parser = __commonJS({
           throw parsingError("unknown encoding, expected utf-8''");
         }
         value = decodeURIComponent(decoder.decode(headerValue.subarray(7)));
-      } else if (input2[position.position] === 34) {
+      } else if (input3[position.position] === 34) {
         position.position++;
         const quotedValue = collectASequenceOfBytes(
           (char) => char !== 10 && char !== 13 && char !== 34,
           // not LF, CR, or "
-          input2,
+          input3,
           position
         );
-        if (input2[position.position] !== 34) {
+        if (input3[position.position] !== 34) {
           throw parsingError("Closing quote not found");
         }
         position.position++;
@@ -13045,20 +13045,20 @@ var require_formdata_parser = __commonJS({
         const tokenValue = collectASequenceOfBytes(
           (char) => isToken(char) && char !== 59,
           // not ;
-          input2,
+          input3,
           position
         );
         value = decoder.decode(tokenValue);
       }
       return { name: attrNameStr, value };
     }
-    function parseMultipartFormDataHeaders(input2, position) {
+    function parseMultipartFormDataHeaders(input3, position) {
       let name = null;
       let filename = null;
       let contentType = null;
       let encoding = null;
       while (true) {
-        if (input2[position.position] === 13 && input2[position.position + 1] === 10) {
+        if (input3[position.position] === 13 && input3[position.position + 1] === 10) {
           if (name === null) {
             throw parsingError("header name is null");
           }
@@ -13066,20 +13066,20 @@ var require_formdata_parser = __commonJS({
         }
         let headerName = collectASequenceOfBytes(
           (char) => char !== 10 && char !== 13 && char !== 58,
-          input2,
+          input3,
           position
         );
         headerName = removeChars(headerName, true, true, (char) => char === 9 || char === 32);
         if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) {
           throw parsingError("header name does not match the field-name token production");
         }
-        if (input2[position.position] !== 58) {
+        if (input3[position.position] !== 58) {
           throw parsingError("expected :");
         }
         position.position++;
         collectASequenceOfBytes(
           (char) => char === 32 || char === 9,
-          input2,
+          input3,
           position
         );
         switch (bufferToLowerCasedHeaderName(headerName)) {
@@ -13087,14 +13087,14 @@ var require_formdata_parser = __commonJS({
             name = filename = null;
             const dispositionType = collectASequenceOfBytes(
               (char) => isToken(char),
-              input2,
+              input3,
               position
             );
             if (dispositionType.toString("ascii").toLowerCase() !== "form-data") {
               throw parsingError("expected form-data for content-disposition header");
             }
-            while (position.position < input2.length && input2[position.position] !== 13 && input2[position.position + 1] !== 10) {
-              const attribute = parseContentDispositionAttribute(input2, position);
+            while (position.position < input3.length && input3[position.position] !== 13 && input3[position.position + 1] !== 10) {
+              const attribute = parseContentDispositionAttribute(input3, position);
               if (!attribute) {
                 break;
               }
@@ -13112,7 +13112,7 @@ var require_formdata_parser = __commonJS({
           case "content-type": {
             let headerValue = collectASequenceOfBytes(
               (char) => char !== 10 && char !== 13,
-              input2,
+              input3,
               position
             );
             headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32);
@@ -13122,7 +13122,7 @@ var require_formdata_parser = __commonJS({
           case "content-transfer-encoding": {
             let headerValue = collectASequenceOfBytes(
               (char) => char !== 10 && char !== 13,
-              input2,
+              input3,
               position
             );
             headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32);
@@ -13132,24 +13132,24 @@ var require_formdata_parser = __commonJS({
           default: {
             collectASequenceOfBytes(
               (char) => char !== 10 && char !== 13,
-              input2,
+              input3,
               position
             );
           }
         }
-        if (input2[position.position] !== 13 && input2[position.position + 1] !== 10) {
+        if (input3[position.position] !== 13 && input3[position.position + 1] !== 10) {
           throw parsingError("expected CRLF");
         } else {
           position.position += 2;
         }
       }
     }
-    function collectASequenceOfBytes(condition, input2, position) {
+    function collectASequenceOfBytes(condition, input3, position) {
       let start = position.position;
-      while (start < input2.length && condition(input2[start])) {
+      while (start < input3.length && condition(input3[start])) {
         ++start;
       }
-      return input2.subarray(position.position, position.position = start);
+      return input3.subarray(position.position, position.position = start);
     }
     function removeChars(buf, leading, trailing, predicate) {
       let lead = 0;
@@ -16713,7 +16713,7 @@ var require_proxy_agent = __commonJS({
         const { proxyTunnel = true } = opts;
         super();
         const url = this.#getUrl(opts);
-        const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url;
+        const { href, origin, port, protocol, username, password: password2, hostname: proxyHostname } = url;
         this[kProxy] = { uri: href, protocol };
         this[kRequestTls] = opts.requestTls;
         this[kProxyTls] = opts.proxyTls;
@@ -16725,8 +16725,8 @@ var require_proxy_agent = __commonJS({
           this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
         } else if (opts.token) {
           this[kProxyHeaders]["proxy-authorization"] = opts.token;
-        } else if (username && password) {
-          this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
+        } else if (username && password2) {
+          this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password2)}`).toString("base64")}`;
         }
         const connect = buildConnector({ ...opts.proxyTls });
         this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
@@ -24851,39 +24851,39 @@ var require_request2 = __commonJS({
       #headers;
       #state;
       // https://fetch.spec.whatwg.org/#dom-request
-      constructor(input2, init3 = void 0) {
+      constructor(input3, init3 = void 0) {
         webidl.util.markAsUncloneable(this);
-        if (input2 === kConstruct) {
+        if (input3 === kConstruct) {
           return;
         }
         const prefix = "Request constructor";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        input2 = webidl.converters.RequestInfo(input2);
+        input3 = webidl.converters.RequestInfo(input3);
         init3 = webidl.converters.RequestInit(init3);
         let request = null;
         let fallbackMode = null;
         const baseUrl = environmentSettingsObject.settingsObject.baseUrl;
         let signal = null;
-        if (typeof input2 === "string") {
+        if (typeof input3 === "string") {
           this.#dispatcher = init3.dispatcher;
           let parsedURL;
           try {
-            parsedURL = new URL(input2, baseUrl);
+            parsedURL = new URL(input3, baseUrl);
           } catch (err) {
-            throw new TypeError("Failed to parse URL from " + input2, { cause: err });
+            throw new TypeError("Failed to parse URL from " + input3, { cause: err });
           }
           if (parsedURL.username || parsedURL.password) {
             throw new TypeError(
-              "Request cannot be constructed from a URL that includes credentials: " + input2
+              "Request cannot be constructed from a URL that includes credentials: " + input3
             );
           }
           request = makeRequest({ urlList: [parsedURL] });
           fallbackMode = "cors";
         } else {
-          assert(webidl.is.Request(input2));
-          request = input2.#state;
-          signal = input2.#signal;
-          this.#dispatcher = init3.dispatcher || input2.#dispatcher;
+          assert(webidl.is.Request(input3));
+          request = input3.#state;
+          signal = input3.#signal;
+          this.#dispatcher = init3.dispatcher || input3.#dispatcher;
         }
         const origin = environmentSettingsObject.settingsObject.origin;
         let window2 = "client";
@@ -25075,7 +25075,7 @@ var require_request2 = __commonJS({
             fillHeaders(this.#headers, headers);
           }
         }
-        const inputBody = webidl.is.Request(input2) ? input2.#state.body : null;
+        const inputBody = webidl.is.Request(input3) ? input3.#state.body : null;
         if ((init3.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) {
           throw new TypeError("Request with GET/HEAD method cannot have body.");
         }
@@ -25104,7 +25104,7 @@ var require_request2 = __commonJS({
         }
         let finalBody = inputOrInitBody;
         if (initBody == null && inputBody != null) {
-          if (bodyUnusable(input2.#state)) {
+          if (bodyUnusable(input3.#state)) {
             throw new TypeError(
               "Cannot construct a Request with a Request object that has already been used."
             );
@@ -25780,12 +25780,12 @@ var require_fetch = __commonJS({
     function handleFetchDone(response) {
       finalizeAndReportTiming(response, "fetch");
     }
-    function fetch5(input2, init3 = void 0) {
+    function fetch5(input3, init3 = void 0) {
       webidl.argumentLengthCheck(arguments, 1, "globalThis.fetch");
       let p = createDeferredPromise();
       let requestObject;
       try {
-        requestObject = new Request3(input2, init3);
+        requestObject = new Request3(input3, init3);
       } catch (e) {
         p.reject(e);
         return p.promise;
@@ -26383,8 +26383,8 @@ var require_fetch = __commonJS({
           let authorizationValue = null;
           if (hasAuthenticationEntry(httpRequest) && (httpRequest.useURLCredentials === void 0 || !includesCredentials(requestCurrentURL(httpRequest)))) {
           } else if (includesCredentials(requestCurrentURL(httpRequest)) && isAuthenticationFetch) {
-            const { username, password } = requestCurrentURL(httpRequest);
-            authorizationValue = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+            const { username, password: password2 } = requestCurrentURL(httpRequest);
+            authorizationValue = `Basic ${Buffer.from(`${username}:${password2}`).toString("base64")}`;
           }
           if (authorizationValue !== null) {
             httpRequest.headersList.append("Authorization", authorizationValue, false);
@@ -30801,25 +30801,25 @@ var require_utils3 = __commonJS({
     exports.asciiLowercase = (string) => {
       return string.replace(/[A-Z]/ug, (l) => l.toLowerCase());
     };
-    exports.collectAnHTTPQuotedString = (input2, position) => {
+    exports.collectAnHTTPQuotedString = (input3, position) => {
       let value = "";
       position++;
       while (true) {
-        while (position < input2.length && input2[position] !== '"' && input2[position] !== "\\") {
-          value += input2[position];
+        while (position < input3.length && input3[position] !== '"' && input3[position] !== "\\") {
+          value += input3[position];
           ++position;
         }
-        if (position >= input2.length) {
+        if (position >= input3.length) {
           break;
         }
-        const quoteOrBackslash = input2[position];
+        const quoteOrBackslash = input3[position];
         ++position;
         if (quoteOrBackslash === "\\") {
-          if (position >= input2.length) {
+          if (position >= input3.length) {
             value += "\\";
             break;
           }
-          value += input2[position];
+          value += input3[position];
           ++position;
         } else {
           break;
@@ -30906,24 +30906,24 @@ var require_parser = __commonJS({
       asciiLowercase,
       collectAnHTTPQuotedString
     } = require_utils3();
-    module.exports = (input2) => {
-      input2 = removeLeadingAndTrailingHTTPWhitespace(input2);
+    module.exports = (input3) => {
+      input3 = removeLeadingAndTrailingHTTPWhitespace(input3);
       let position = 0;
       let type = "";
-      while (position < input2.length && input2[position] !== "/") {
-        type += input2[position];
+      while (position < input3.length && input3[position] !== "/") {
+        type += input3[position];
         ++position;
       }
       if (type.length === 0 || !solelyContainsHTTPTokenCodePoints(type)) {
         return null;
       }
-      if (position >= input2.length) {
+      if (position >= input3.length) {
         return null;
       }
       ++position;
       let subtype = "";
-      while (position < input2.length && input2[position] !== ";") {
-        subtype += input2[position];
+      while (position < input3.length && input3[position] !== ";") {
+        subtype += input3[position];
         ++position;
       }
       subtype = removeTrailingHTTPWhitespace(subtype);
@@ -30935,33 +30935,33 @@ var require_parser = __commonJS({
         subtype: asciiLowercase(subtype),
         parameters: /* @__PURE__ */ new Map()
       };
-      while (position < input2.length) {
+      while (position < input3.length) {
         ++position;
-        while (isHTTPWhitespaceChar(input2[position])) {
+        while (isHTTPWhitespaceChar(input3[position])) {
           ++position;
         }
         let parameterName = "";
-        while (position < input2.length && input2[position] !== ";" && input2[position] !== "=") {
-          parameterName += input2[position];
+        while (position < input3.length && input3[position] !== ";" && input3[position] !== "=") {
+          parameterName += input3[position];
           ++position;
         }
         parameterName = asciiLowercase(parameterName);
-        if (position < input2.length) {
-          if (input2[position] === ";") {
+        if (position < input3.length) {
+          if (input3[position] === ";") {
             continue;
           }
           ++position;
         }
         let parameterValue = null;
-        if (input2[position] === '"') {
-          [parameterValue, position] = collectAnHTTPQuotedString(input2, position);
-          while (position < input2.length && input2[position] !== ";") {
+        if (input3[position] === '"') {
+          [parameterValue, position] = collectAnHTTPQuotedString(input3, position);
+          while (position < input3.length && input3[position] !== ";") {
             ++position;
           }
         } else {
           parameterValue = "";
-          while (position < input2.length && input2[position] !== ";") {
-            parameterValue += input2[position];
+          while (position < input3.length && input3[position] !== ";") {
+            parameterValue += input3[position];
             ++position;
           }
           parameterValue = removeTrailingHTTPWhitespace(parameterValue);
@@ -35488,9 +35488,9 @@ var require_lib3 = __commonJS({
           return false;
       }
     }
-    function hasNewLine(input2, start, end2) {
+    function hasNewLine(input3, start, end2) {
       for (let i = start; i < end2; i++) {
-        if (isNewLine(input2.charCodeAt(i))) {
+        if (isNewLine(input3.charCodeAt(i))) {
           return true;
         }
       }
@@ -36478,7 +36478,7 @@ var require_lib3 = __commonJS({
       dec: (ch) => ch >= 48 && ch <= 57,
       hex: (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
     };
-    function readStringContents(type, input2, pos, lineStart, curLine, errors2) {
+    function readStringContents(type, input3, pos, lineStart, curLine, errors2) {
       const initialPos = pos;
       const initialLineStart = lineStart;
       const initialCurLine = curLine;
@@ -36487,21 +36487,21 @@ var require_lib3 = __commonJS({
       let chunkStart = pos;
       const {
         length
-      } = input2;
+      } = input3;
       for (; ; ) {
         if (pos >= length) {
           errors2.unterminated(initialPos, initialLineStart, initialCurLine);
-          out += input2.slice(chunkStart, pos);
+          out += input3.slice(chunkStart, pos);
           break;
         }
-        const ch = input2.charCodeAt(pos);
-        if (isStringEnd(type, ch, input2, pos)) {
-          out += input2.slice(chunkStart, pos);
+        const ch = input3.charCodeAt(pos);
+        if (isStringEnd(type, ch, input3, pos)) {
+          out += input3.slice(chunkStart, pos);
           break;
         }
         if (ch === 92) {
-          out += input2.slice(chunkStart, pos);
-          const res = readEscapedChar(input2, pos, lineStart, curLine, type === "template", errors2);
+          out += input3.slice(chunkStart, pos);
+          const res = readEscapedChar(input3, pos, lineStart, curLine, type === "template", errors2);
           if (res.ch === null && !firstInvalidLoc) {
             firstInvalidLoc = {
               pos,
@@ -36523,9 +36523,9 @@ var require_lib3 = __commonJS({
           lineStart = pos;
         } else if (ch === 10 || ch === 13) {
           if (type === "template") {
-            out += input2.slice(chunkStart, pos) + "\n";
+            out += input3.slice(chunkStart, pos) + "\n";
             ++pos;
-            if (ch === 13 && input2.charCodeAt(pos) === 10) {
+            if (ch === 13 && input3.charCodeAt(pos) === 10) {
               ++pos;
             }
             ++curLine;
@@ -36546,13 +36546,13 @@ var require_lib3 = __commonJS({
         containsInvalid: !!firstInvalidLoc
       };
     }
-    function isStringEnd(type, ch, input2, pos) {
+    function isStringEnd(type, ch, input3, pos) {
       if (type === "template") {
-        return ch === 96 || ch === 36 && input2.charCodeAt(pos + 1) === 123;
+        return ch === 96 || ch === 36 && input3.charCodeAt(pos + 1) === 123;
       }
       return ch === (type === "double" ? 34 : 39);
     }
-    function readEscapedChar(input2, pos, lineStart, curLine, inTemplate, errors2) {
+    function readEscapedChar(input3, pos, lineStart, curLine, inTemplate, errors2) {
       const throwOnInvalid = !inTemplate;
       pos++;
       const res = (ch2) => ({
@@ -36561,7 +36561,7 @@ var require_lib3 = __commonJS({
         lineStart,
         curLine
       });
-      const ch = input2.charCodeAt(pos++);
+      const ch = input3.charCodeAt(pos++);
       switch (ch) {
         case 110:
           return res("\n");
@@ -36572,7 +36572,7 @@ var require_lib3 = __commonJS({
           ({
             code: code2,
             pos
-          } = readHexChar(input2, pos, lineStart, curLine, 2, false, throwOnInvalid, errors2));
+          } = readHexChar(input3, pos, lineStart, curLine, 2, false, throwOnInvalid, errors2));
           return res(code2 === null ? null : String.fromCharCode(code2));
         }
         case 117: {
@@ -36580,7 +36580,7 @@ var require_lib3 = __commonJS({
           ({
             code: code2,
             pos
-          } = readCodePoint(input2, pos, lineStart, curLine, throwOnInvalid, errors2));
+          } = readCodePoint(input3, pos, lineStart, curLine, throwOnInvalid, errors2));
           return res(code2 === null ? null : String.fromCodePoint(code2));
         }
         case 116:
@@ -36592,7 +36592,7 @@ var require_lib3 = __commonJS({
         case 102:
           return res("\f");
         case 13:
-          if (input2.charCodeAt(pos) === 10) {
+          if (input3.charCodeAt(pos) === 10) {
             ++pos;
           }
         case 10:
@@ -36611,7 +36611,7 @@ var require_lib3 = __commonJS({
         default:
           if (ch >= 48 && ch <= 55) {
             const startPos = pos - 1;
-            const match = /^[0-7]+/.exec(input2.slice(startPos, pos + 2));
+            const match = /^[0-7]+/.exec(input3.slice(startPos, pos + 2));
             let octalStr = match[0];
             let octal = parseInt(octalStr, 8);
             if (octal > 255) {
@@ -36619,7 +36619,7 @@ var require_lib3 = __commonJS({
               octal = parseInt(octalStr, 8);
             }
             pos += octalStr.length - 1;
-            const next2 = input2.charCodeAt(pos);
+            const next2 = input3.charCodeAt(pos);
             if (octalStr !== "0" || next2 === 56 || next2 === 57) {
               if (inTemplate) {
                 return res(null);
@@ -36632,13 +36632,13 @@ var require_lib3 = __commonJS({
           return res(String.fromCharCode(ch));
       }
     }
-    function readHexChar(input2, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors2) {
+    function readHexChar(input3, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors2) {
       const initialPos = pos;
       let n;
       ({
         n,
         pos
-      } = readInt(input2, pos, lineStart, curLine, 16, len, forceLen, false, errors2, !throwOnInvalid));
+      } = readInt(input3, pos, lineStart, curLine, 16, len, forceLen, false, errors2, !throwOnInvalid));
       if (n === null) {
         if (throwOnInvalid) {
           errors2.invalidEscapeSequence(initialPos, lineStart, curLine);
@@ -36651,18 +36651,18 @@ var require_lib3 = __commonJS({
         pos
       };
     }
-    function readInt(input2, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors2, bailOnError) {
+    function readInt(input3, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors2, bailOnError) {
       const start = pos;
       const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
       const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
       let invalid = false;
       let total = 0;
       for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-        const code2 = input2.charCodeAt(pos);
+        const code2 = input3.charCodeAt(pos);
         let val2;
         if (code2 === 95 && allowNumSeparator !== "bail") {
-          const prev2 = input2.charCodeAt(pos - 1);
-          const next2 = input2.charCodeAt(pos + 1);
+          const prev2 = input3.charCodeAt(pos - 1);
+          const next2 = input3.charCodeAt(pos + 1);
           if (!allowNumSeparator) {
             if (bailOnError) return {
               n: null,
@@ -36717,15 +36717,15 @@ var require_lib3 = __commonJS({
         pos
       };
     }
-    function readCodePoint(input2, pos, lineStart, curLine, throwOnInvalid, errors2) {
-      const ch = input2.charCodeAt(pos);
+    function readCodePoint(input3, pos, lineStart, curLine, throwOnInvalid, errors2) {
+      const ch = input3.charCodeAt(pos);
       let code2;
       if (ch === 123) {
         ++pos;
         ({
           code: code2,
           pos
-        } = readHexChar(input2, pos, lineStart, curLine, input2.indexOf("}", pos) - pos, true, throwOnInvalid, errors2));
+        } = readHexChar(input3, pos, lineStart, curLine, input3.indexOf("}", pos) - pos, true, throwOnInvalid, errors2));
         ++pos;
         if (code2 !== null && code2 > 1114111) {
           if (throwOnInvalid) {
@@ -36741,7 +36741,7 @@ var require_lib3 = __commonJS({
         ({
           code: code2,
           pos
-        } = readHexChar(input2, pos, lineStart, curLine, 4, false, throwOnInvalid, errors2));
+        } = readHexChar(input3, pos, lineStart, curLine, 4, false, throwOnInvalid, errors2));
       }
       return {
         code: code2,
@@ -36763,7 +36763,7 @@ var require_lib3 = __commonJS({
       }
     };
     var Tokenizer3 = class extends CommentsParser {
-      constructor(options, input2) {
+      constructor(options, input3) {
         super();
         this.isLookahead = void 0;
         this.tokens = [];
@@ -36798,8 +36798,8 @@ var require_lib3 = __commonJS({
         });
         this.state = new State4();
         this.state.init(options);
-        this.input = input2;
-        this.length = input2.length;
+        this.input = input3;
+        this.length = input3.length;
         this.comments = [];
         this.isLookahead = false;
       }
@@ -43602,7 +43602,7 @@ var require_lib3 = __commonJS({
     };
     var loneSurrogate = /[\uD800-\uDFFF]/u;
     var keywordRelationalOperator = /in(?:stanceof)?/y;
-    function babel7CompatTokens(tokens, input2, startIndex) {
+    function babel7CompatTokens(tokens, input3, startIndex) {
       for (let i = 0; i < tokens.length; i++) {
         const token = tokens[i];
         const {
@@ -43646,7 +43646,7 @@ var require_lib3 = __commonJS({
             const backquoteEnd = start + 1;
             const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);
             let startToken;
-            if (input2.charCodeAt(start - startIndex) === 96) {
+            if (input3.charCodeAt(start - startIndex) === 96) {
               startToken = new Token({
                 type: getExportedToken(22),
                 value: "`",
@@ -45518,9 +45518,9 @@ var require_lib3 = __commonJS({
       }
     };
     var Parser3 = class extends StatementParser {
-      constructor(options, input2, pluginsMap) {
+      constructor(options, input3, pluginsMap) {
         const normalizedOptions = getOptions(options);
-        super(normalizedOptions, input2);
+        super(normalizedOptions, input3);
         this.options = normalizedOptions;
         this.initializeScopes();
         this.plugins = pluginsMap;
@@ -45586,13 +45586,13 @@ var require_lib3 = __commonJS({
         return result;
       }
     };
-    function parse7(input2, options) {
+    function parse7(input3, options) {
       var _options;
       if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
         options = Object.assign({}, options);
         try {
           options.sourceType = "module";
-          const parser2 = getParser(options, input2);
+          const parser2 = getParser(options, input3);
           const ast = parser2.parse();
           if (parser2.sawUnambiguousESM) {
             return ast;
@@ -45600,7 +45600,7 @@ var require_lib3 = __commonJS({
           if (parser2.ambiguousScriptDifferentAst) {
             try {
               options.sourceType = "script";
-              return getParser(options, input2).parse();
+              return getParser(options, input3).parse();
             } catch (_unused) {
             }
           } else {
@@ -45610,17 +45610,17 @@ var require_lib3 = __commonJS({
         } catch (moduleError) {
           try {
             options.sourceType = "script";
-            return getParser(options, input2).parse();
+            return getParser(options, input3).parse();
           } catch (_unused2) {
           }
           throw moduleError;
         }
       } else {
-        return getParser(options, input2).parse();
+        return getParser(options, input3).parse();
       }
     }
-    function parseExpression(input2, options) {
-      const parser2 = getParser(options, input2);
+    function parseExpression(input3, options) {
+      const parser2 = getParser(options, input3);
       if (parser2.options.strictMode) {
         parser2.state.strict = true;
       }
@@ -45634,7 +45634,7 @@ var require_lib3 = __commonJS({
       return tokenTypes2;
     }
     var tokTypes = generateExportedTokenTypes(tt);
-    function getParser(options, input2) {
+    function getParser(options, input3) {
       let cls = Parser3;
       const pluginsMap = /* @__PURE__ */ new Map();
       if (options != null && options.plugins) {
@@ -45652,7 +45652,7 @@ var require_lib3 = __commonJS({
         validatePlugins(pluginsMap);
         cls = getParserClass(pluginsMap);
       }
-      return new cls(options, input2, pluginsMap);
+      return new cls(options, input3, pluginsMap);
     }
     var parserClassCache = /* @__PURE__ */ new Map();
     function getParserClass(pluginsMap) {
@@ -49623,7 +49623,7 @@ var require_lib5 = __commonJS({
       dec: (ch) => ch >= 48 && ch <= 57,
       hex: (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
     };
-    function readStringContents(type, input2, pos, lineStart, curLine, errors2) {
+    function readStringContents(type, input3, pos, lineStart, curLine, errors2) {
       const initialPos = pos;
       const initialLineStart = lineStart;
       const initialCurLine = curLine;
@@ -49632,21 +49632,21 @@ var require_lib5 = __commonJS({
       let chunkStart = pos;
       const {
         length
-      } = input2;
+      } = input3;
       for (; ; ) {
         if (pos >= length) {
           errors2.unterminated(initialPos, initialLineStart, initialCurLine);
-          out += input2.slice(chunkStart, pos);
+          out += input3.slice(chunkStart, pos);
           break;
         }
-        const ch = input2.charCodeAt(pos);
-        if (isStringEnd(type, ch, input2, pos)) {
-          out += input2.slice(chunkStart, pos);
+        const ch = input3.charCodeAt(pos);
+        if (isStringEnd(type, ch, input3, pos)) {
+          out += input3.slice(chunkStart, pos);
           break;
         }
         if (ch === 92) {
-          out += input2.slice(chunkStart, pos);
-          const res = readEscapedChar(input2, pos, lineStart, curLine, type === "template", errors2);
+          out += input3.slice(chunkStart, pos);
+          const res = readEscapedChar(input3, pos, lineStart, curLine, type === "template", errors2);
           if (res.ch === null && !firstInvalidLoc) {
             firstInvalidLoc = {
               pos,
@@ -49668,9 +49668,9 @@ var require_lib5 = __commonJS({
           lineStart = pos;
         } else if (ch === 10 || ch === 13) {
           if (type === "template") {
-            out += input2.slice(chunkStart, pos) + "\n";
+            out += input3.slice(chunkStart, pos) + "\n";
             ++pos;
-            if (ch === 13 && input2.charCodeAt(pos) === 10) {
+            if (ch === 13 && input3.charCodeAt(pos) === 10) {
               ++pos;
             }
             ++curLine;
@@ -49691,13 +49691,13 @@ var require_lib5 = __commonJS({
         containsInvalid: !!firstInvalidLoc
       };
     }
-    function isStringEnd(type, ch, input2, pos) {
+    function isStringEnd(type, ch, input3, pos) {
       if (type === "template") {
-        return ch === 96 || ch === 36 && input2.charCodeAt(pos + 1) === 123;
+        return ch === 96 || ch === 36 && input3.charCodeAt(pos + 1) === 123;
       }
       return ch === (type === "double" ? 34 : 39);
     }
-    function readEscapedChar(input2, pos, lineStart, curLine, inTemplate, errors2) {
+    function readEscapedChar(input3, pos, lineStart, curLine, inTemplate, errors2) {
       const throwOnInvalid = !inTemplate;
       pos++;
       const res = (ch2) => ({
@@ -49706,7 +49706,7 @@ var require_lib5 = __commonJS({
         lineStart,
         curLine
       });
-      const ch = input2.charCodeAt(pos++);
+      const ch = input3.charCodeAt(pos++);
       switch (ch) {
         case 110:
           return res("\n");
@@ -49717,7 +49717,7 @@ var require_lib5 = __commonJS({
           ({
             code,
             pos
-          } = readHexChar(input2, pos, lineStart, curLine, 2, false, throwOnInvalid, errors2));
+          } = readHexChar(input3, pos, lineStart, curLine, 2, false, throwOnInvalid, errors2));
           return res(code === null ? null : String.fromCharCode(code));
         }
         case 117: {
@@ -49725,7 +49725,7 @@ var require_lib5 = __commonJS({
           ({
             code,
             pos
-          } = readCodePoint(input2, pos, lineStart, curLine, throwOnInvalid, errors2));
+          } = readCodePoint(input3, pos, lineStart, curLine, throwOnInvalid, errors2));
           return res(code === null ? null : String.fromCodePoint(code));
         }
         case 116:
@@ -49737,7 +49737,7 @@ var require_lib5 = __commonJS({
         case 102:
           return res("\f");
         case 13:
-          if (input2.charCodeAt(pos) === 10) {
+          if (input3.charCodeAt(pos) === 10) {
             ++pos;
           }
         case 10:
@@ -49756,7 +49756,7 @@ var require_lib5 = __commonJS({
         default:
           if (ch >= 48 && ch <= 55) {
             const startPos = pos - 1;
-            const match = /^[0-7]+/.exec(input2.slice(startPos, pos + 2));
+            const match = /^[0-7]+/.exec(input3.slice(startPos, pos + 2));
             let octalStr = match[0];
             let octal = parseInt(octalStr, 8);
             if (octal > 255) {
@@ -49764,7 +49764,7 @@ var require_lib5 = __commonJS({
               octal = parseInt(octalStr, 8);
             }
             pos += octalStr.length - 1;
-            const next2 = input2.charCodeAt(pos);
+            const next2 = input3.charCodeAt(pos);
             if (octalStr !== "0" || next2 === 56 || next2 === 57) {
               if (inTemplate) {
                 return res(null);
@@ -49777,13 +49777,13 @@ var require_lib5 = __commonJS({
           return res(String.fromCharCode(ch));
       }
     }
-    function readHexChar(input2, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors2) {
+    function readHexChar(input3, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors2) {
       const initialPos = pos;
       let n;
       ({
         n,
         pos
-      } = readInt(input2, pos, lineStart, curLine, 16, len, forceLen, false, errors2, !throwOnInvalid));
+      } = readInt(input3, pos, lineStart, curLine, 16, len, forceLen, false, errors2, !throwOnInvalid));
       if (n === null) {
         if (throwOnInvalid) {
           errors2.invalidEscapeSequence(initialPos, lineStart, curLine);
@@ -49796,18 +49796,18 @@ var require_lib5 = __commonJS({
         pos
       };
     }
-    function readInt(input2, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors2, bailOnError) {
+    function readInt(input3, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors2, bailOnError) {
       const start = pos;
       const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
       const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
       let invalid = false;
       let total = 0;
       for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-        const code = input2.charCodeAt(pos);
+        const code = input3.charCodeAt(pos);
         let val2;
         if (code === 95 && allowNumSeparator !== "bail") {
-          const prev2 = input2.charCodeAt(pos - 1);
-          const next2 = input2.charCodeAt(pos + 1);
+          const prev2 = input3.charCodeAt(pos - 1);
+          const next2 = input3.charCodeAt(pos + 1);
           if (!allowNumSeparator) {
             if (bailOnError) return {
               n: null,
@@ -49862,15 +49862,15 @@ var require_lib5 = __commonJS({
         pos
       };
     }
-    function readCodePoint(input2, pos, lineStart, curLine, throwOnInvalid, errors2) {
-      const ch = input2.charCodeAt(pos);
+    function readCodePoint(input3, pos, lineStart, curLine, throwOnInvalid, errors2) {
+      const ch = input3.charCodeAt(pos);
       let code;
       if (ch === 123) {
         ++pos;
         ({
           code,
           pos
-        } = readHexChar(input2, pos, lineStart, curLine, input2.indexOf("}", pos) - pos, true, throwOnInvalid, errors2));
+        } = readHexChar(input3, pos, lineStart, curLine, input3.indexOf("}", pos) - pos, true, throwOnInvalid, errors2));
         ++pos;
         if (code !== null && code > 1114111) {
           if (throwOnInvalid) {
@@ -49886,7 +49886,7 @@ var require_lib5 = __commonJS({
         ({
           code,
           pos
-        } = readHexChar(input2, pos, lineStart, curLine, 4, false, throwOnInvalid, errors2));
+        } = readHexChar(input3, pos, lineStart, curLine, 4, false, throwOnInvalid, errors2));
       }
       return {
         code,
@@ -58792,10 +58792,10 @@ var require_toIdentifier = __commonJS({
     exports.default = toIdentifier;
     var _isValidIdentifier = require_isValidIdentifier();
     var _helperValidatorIdentifier = require_lib4();
-    function toIdentifier(input2) {
-      input2 = input2 + "";
+    function toIdentifier(input3) {
+      input3 = input3 + "";
       let name = "";
-      for (const c of input2) {
+      for (const c of input3) {
         name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
       }
       name = name.replace(/^[-0-9]+/, "");
@@ -62524,9 +62524,9 @@ var require_sourcemap_codec_umd = __commonJS({
         }
       };
       var EMPTY = [];
-      function decodeOriginalScopes(input2) {
-        const { length } = input2;
-        const reader = new StringReader(input2);
+      function decodeOriginalScopes(input3) {
+        const { length } = input3;
+        const reader = new StringReader(input3);
         const scopes = [];
         const stack = [];
         let line = 0;
@@ -62590,9 +62590,9 @@ var require_sourcemap_codec_umd = __commonJS({
         encodeInteger(writer, endColumn, 0);
         return index2;
       }
-      function decodeGeneratedRanges(input2) {
-        const { length } = input2;
-        const reader = new StringReader(input2);
+      function decodeGeneratedRanges(input3) {
+        const { length } = input3;
+        const reader = new StringReader(input3);
         const ranges = [];
         const stack = [];
         let genLine = 0;
@@ -62853,27 +62853,27 @@ var require_resolve_uri_umd = __commonJS({
       const schemeRegex = /^[\w+.-]+:\/\//;
       const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
       const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
-      function isAbsoluteUrl(input2) {
-        return schemeRegex.test(input2);
+      function isAbsoluteUrl(input3) {
+        return schemeRegex.test(input3);
       }
-      function isSchemeRelativeUrl(input2) {
-        return input2.startsWith("//");
+      function isSchemeRelativeUrl(input3) {
+        return input3.startsWith("//");
       }
-      function isAbsolutePath(input2) {
-        return input2.startsWith("/");
+      function isAbsolutePath(input3) {
+        return input3.startsWith("/");
       }
-      function isFileUrl(input2) {
-        return input2.startsWith("file:");
+      function isFileUrl(input3) {
+        return input3.startsWith("file:");
       }
-      function isRelative(input2) {
-        return /^[.?#]/.test(input2);
+      function isRelative(input3) {
+        return /^[.?#]/.test(input3);
       }
-      function parseAbsoluteUrl(input2) {
-        const match = urlRegex.exec(input2);
+      function parseAbsoluteUrl(input3) {
+        const match = urlRegex.exec(input3);
         return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
       }
-      function parseFileUrl(input2) {
-        const match = fileRegex.exec(input2);
+      function parseFileUrl(input3) {
+        const match = fileRegex.exec(input3);
         const path2 = match[2];
         return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path2) ? path2 : "/" + path2, match[3] || "", match[4] || "");
       }
@@ -62889,28 +62889,28 @@ var require_resolve_uri_umd = __commonJS({
           type: 7
         };
       }
-      function parseUrl(input2) {
-        if (isSchemeRelativeUrl(input2)) {
-          const url2 = parseAbsoluteUrl("http:" + input2);
+      function parseUrl(input3) {
+        if (isSchemeRelativeUrl(input3)) {
+          const url2 = parseAbsoluteUrl("http:" + input3);
           url2.scheme = "";
           url2.type = 6;
           return url2;
         }
-        if (isAbsolutePath(input2)) {
-          const url2 = parseAbsoluteUrl("http://foo.com" + input2);
+        if (isAbsolutePath(input3)) {
+          const url2 = parseAbsoluteUrl("http://foo.com" + input3);
           url2.scheme = "";
           url2.host = "";
           url2.type = 5;
           return url2;
         }
-        if (isFileUrl(input2))
-          return parseFileUrl(input2);
-        if (isAbsoluteUrl(input2))
-          return parseAbsoluteUrl(input2);
-        const url = parseAbsoluteUrl("http://foo.com/" + input2);
+        if (isFileUrl(input3))
+          return parseFileUrl(input3);
+        if (isAbsoluteUrl(input3))
+          return parseAbsoluteUrl(input3);
+        const url = parseAbsoluteUrl("http://foo.com/" + input3);
         url.scheme = "";
         url.host = "";
-        url.type = input2 ? input2.startsWith("?") ? 3 : input2.startsWith("#") ? 2 : 4 : 1;
+        url.type = input3 ? input3.startsWith("?") ? 3 : input3.startsWith("#") ? 2 : 4 : 1;
         return url;
       }
       function stripPathFilename(path2) {
@@ -62964,10 +62964,10 @@ var require_resolve_uri_umd = __commonJS({
         }
         url.path = path2;
       }
-      function resolve4(input2, base) {
-        if (!input2 && !base)
+      function resolve4(input3, base) {
+        if (!input3 && !base)
           return "";
-        const url = parseUrl(input2);
+        const url = parseUrl(input3);
         let inputType = url.type;
         if (base && inputType !== 7) {
           const baseUrl = parseUrl(base);
@@ -63006,7 +63006,7 @@ var require_resolve_uri_umd = __commonJS({
             const path2 = url.path.slice(1);
             if (!path2)
               return queryHash || ".";
-            if (isRelative(base || input2) && !isRelative(path2)) {
+            if (isRelative(base || input3) && !isRelative(path2)) {
               return "./" + path2 + queryHash;
             }
             return path2 + queryHash;
@@ -63274,8 +63274,8 @@ var require_trace_mapping_umd = __commonJS({
         };
         return presortedDecodedMap(joined);
       };
-      function recurse(input2, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
-        const { sections } = input2;
+      function recurse(input3, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        const { sections } = input3;
         for (let i = 0; i < sections.length; i++) {
           const { map: map2, offset } = sections[i];
           let sl = stopLine;
@@ -63304,8 +63304,8 @@ var require_trace_mapping_umd = __commonJS({
           );
         }
       }
-      function addSection(input2, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
-        const parsed = parse7(input2);
+      function addSection(input3, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        const parsed = parse7(input3);
         if ("sections" in parsed) return recurse(...arguments);
         const map2 = new TraceMap(parsed, mapUrl);
         const sourcesOffset = sources.length;
@@ -63782,8 +63782,8 @@ var require_gen_mapping_umd = __commonJS({
           mappings: (0, import_sourcemap_codec.encode)(decoded.mappings)
         });
       }
-      function fromMap(input2) {
-        const map2 = new import_trace_mapping.TraceMap(input2);
+      function fromMap(input3) {
+        const map2 = new import_trace_mapping.TraceMap(input3);
         const gen = new GenMapping({ file: map2.file, sourceRoot: map2.sourceRoot });
         putAll(cast2(gen)._names, map2.names);
         putAll(cast2(gen)._sources, map2.sources);
@@ -70131,8 +70131,8 @@ var require_picocolors = __commonJS({
     var argv = p.argv || [];
     var env = p.env || {};
     var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-    var formatter = (open, close, replace = open) => (input2) => {
-      let string = "" + input2, index2 = string.indexOf(close, open.length);
+    var formatter = (open, close, replace = open) => (input3) => {
+      let string = "" + input3, index2 = string.indexOf(close, open.length);
       return ~index2 ? open + replaceClose(string, close, replace, index2) + close : open + string + close;
     };
     var replaceClose = (string, close, replace, index2) => {
@@ -74524,19 +74524,412 @@ import { Command as Command4 } from "commander";
 // src/commands/auth/index.ts
 init_esm_shims();
 
-// src/commands/auth/status.ts
+// src/commands/auth/setup.ts
 init_esm_shims();
-import fs from "fs/promises";
-import path from "path";
+import { execSync as execSync3 } from "child_process";
+import { appendFileSync, existsSync as existsSync2 } from "fs";
+import { confirm, input, password, select } from "@inquirer/prompts";
+
+// src/lib/keychain.ts
+init_esm_shims();
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function detectPlatform() {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "linux":
+      return "linux";
+    default:
+      return "unsupported";
+  }
+}
+function isKeychainAvailable() {
+  const platform = detectPlatform();
+  try {
+    if (platform === "macos") {
+      execSync("which security", { stdio: "pipe" });
+      return true;
+    }
+    if (platform === "linux") {
+      execSync("which secret-tool", { stdio: "pipe" });
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function storeInKeychain(key, value) {
+  const platform = detectPlatform();
+  if (platform === "macos") {
+    execSync(
+      `security add-generic-password -a "$USER" -s ${JSON.stringify(key)} -w ${JSON.stringify(value)} -U`,
+      { stdio: "pipe" }
+    );
+    return;
+  }
+  if (platform === "linux") {
+    execSync(
+      `echo -n ${JSON.stringify(value)} | secret-tool store --label ${JSON.stringify(key)} service skill-cli key ${JSON.stringify(key)}`,
+      { stdio: "pipe" }
+    );
+    return;
+  }
+  throw new Error(`Unsupported platform: ${process.platform}`);
+}
+function readFromKeychain(key) {
+  const platform = detectPlatform();
+  try {
+    if (platform === "macos") {
+      return execSync(
+        `security find-generic-password -a "$USER" -s ${JSON.stringify(key)} -w`,
+        { stdio: "pipe" }
+      ).toString().trim();
+    }
+    if (platform === "linux") {
+      return execSync(
+        `secret-tool lookup service skill-cli key ${JSON.stringify(key)}`,
+        { stdio: "pipe" }
+      ).toString().trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getShellProfileExportLine(key) {
+  const platform = detectPlatform();
+  if (platform === "macos") {
+    return `export ${key}=$(security find-generic-password -a "$USER" -s "${key}" -w 2>/dev/null)`;
+  }
+  if (platform === "linux") {
+    return `export ${key}=$(secret-tool lookup service skill-cli key "${key}" 2>/dev/null)`;
+  }
+  throw new Error(`Unsupported platform: ${process.platform}`);
+}
+function detectShellProfile() {
+  const shell = process.env.SHELL || "";
+  const home = homedir();
+  if (shell.includes("zsh")) {
+    return join(home, ".zshrc");
+  }
+  if (shell.includes("bash")) {
+    const bashrc = join(home, ".bashrc");
+    const bashProfile = join(home, ".bash_profile");
+    if (existsSync(bashrc)) return bashrc;
+    if (existsSync(bashProfile)) return bashProfile;
+    return bashrc;
+  }
+  return null;
+}
+function shellProfileHasExport(profilePath, key) {
+  try {
+    const content = readFileSync(profilePath, "utf-8");
+    return content.includes(`export ${key}=`);
+  } catch {
+    return false;
+  }
+}
 
 // src/lib/onepassword.ts
 init_esm_shims();
-import { execSync, spawn } from "child_process";
+import { execSync as execSync2, spawn } from "child_process";
+var OP_ACCOUNT = "egghead.1password.com";
+var OP_VAULT_ID = "u3ujzar6l3nahlahsuzfvg7vcq";
+var OP_AGE_KEY_ITEM_ID = "lxndka3exn475vqdiqq5heg2wm";
+var OP_AGE_KEY_LINK = `https://start.1password.com/open/i?a=GCTJE4MRGFHKRAYXCEXKZKCEFU&v=${OP_VAULT_ID}&i=${OP_AGE_KEY_ITEM_ID}&h=${OP_ACCOUNT}`;
+function isOpCliAvailable() {
+  try {
+    execSync2("which op", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isOpSignedIn() {
+  try {
+    execSync2(`op account get --account ${OP_ACCOUNT}`, {
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fetchFromOp(itemId, field) {
+  try {
+    const result = execSync2(
+      `op item get ${itemId} --vault ${OP_VAULT_ID} --account ${OP_ACCOUNT} --fields ${field} --reveal`,
+      { stdio: "pipe", timeout: 15e3 }
+    );
+    const value = result.toString().trim();
+    return value || null;
+  } catch {
+    return null;
+  }
+}
+function getOpInstallInstructions() {
+  switch (process.platform) {
+    case "darwin":
+      return "brew install 1password-cli";
+    case "linux":
+      return "https://developer.1password.com/docs/cli/get-started/#install";
+    default:
+      return "https://developer.1password.com/docs/cli/get-started/#install";
+  }
+}
 function isServiceAccountConfigured() {
   return Boolean(process.env.OP_SERVICE_ACCOUNT_TOKEN);
 }
 
+// src/commands/auth/setup.ts
+var KEY_NAME = "AGE_SECRET_KEY";
+var KEY_PREFIX = "AGE-SECRET-KEY-1";
+function validateAgeKey(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "Key cannot be empty";
+  if (!trimmed.startsWith(KEY_PREFIX)) {
+    return `Invalid format \u2014 must start with ${KEY_PREFIX}`;
+  }
+  return true;
+}
+function registerSetupCommand(auth) {
+  auth.command("setup").description("Store AGE_SECRET_KEY in OS keychain and configure shell").option("--json", "Output result as JSON").action(async (options) => {
+    try {
+      await runSetup(options);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      if (options.json) {
+        console.error(JSON.stringify({ success: false, error: message }));
+      } else {
+        console.error(`Error: ${message}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+async function runSetup(options) {
+  const platform = detectPlatform();
+  if (platform === "unsupported") {
+    throw new Error(
+      `Unsupported platform: ${process.platform}. Only macOS and Linux are supported.`
+    );
+  }
+  if (!isKeychainAvailable()) {
+    const tool5 = platform === "macos" ? "security" : "secret-tool";
+    throw new Error(
+      `Keychain CLI not found: ${tool5}. Install it before running setup.`
+    );
+  }
+  if (!process.stdin.isTTY && !options.json) {
+    throw new Error(
+      "Setup requires an interactive terminal. Use --json for non-interactive mode."
+    );
+  }
+  if (!options.json) {
+    console.log("\nSkill Recordings CLI \u2014 Auth Setup\n");
+  }
+  const existingEnv = process.env[KEY_NAME];
+  const existingKeychain = readFromKeychain(KEY_NAME);
+  if (existingEnv || existingKeychain) {
+    if (!options.json) {
+      if (existingEnv) {
+        console.log(`  ${KEY_NAME} is already set in your environment.`);
+      }
+      if (existingKeychain) {
+        console.log(`  ${KEY_NAME} is already stored in the keychain.`);
+      }
+    }
+    const overwrite = await confirm({
+      message: "Overwrite existing key?",
+      default: false
+    });
+    if (!overwrite) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, skipped: true }));
+      } else {
+        console.log("\nSetup cancelled.");
+      }
+      return;
+    }
+  }
+  const trimmedKey = await obtainKey(options);
+  if (!options.json) {
+    console.log(`  \u2713 Valid age key format`);
+  }
+  storeInKeychain(KEY_NAME, trimmedKey);
+  const stored = readFromKeychain(KEY_NAME);
+  if (stored !== trimmedKey) {
+    throw new Error(
+      "Keychain verification failed \u2014 stored value does not match"
+    );
+  }
+  const keychainLabel = platform === "macos" ? "macOS Keychain" : "Linux secret-tool";
+  if (!options.json) {
+    console.log(`  \u2713 Stored in ${keychainLabel}`);
+  }
+  let profilePath = detectShellProfile();
+  let profileUpdated = false;
+  if (!profilePath) {
+    if (!options.json) {
+      console.log(
+        `
+  Could not detect shell profile from $SHELL (${process.env.SHELL || "unset"}).`
+      );
+    }
+    profilePath = await input({
+      message: "Path to your shell profile (e.g., ~/.zshrc):",
+      validate: (v) => v.trim().length > 0 || "Path is required"
+    });
+    profilePath = profilePath.replace(/^~/, process.env.HOME || "");
+  }
+  if (profilePath && !shellProfileHasExport(profilePath, KEY_NAME)) {
+    const exportLine = getShellProfileExportLine(KEY_NAME);
+    const comment = platform === "macos" ? "# age encryption key (stored in macOS Keychain)" : "# age encryption key (stored in Linux secret-tool)";
+    appendFileSync(profilePath, `
+${comment}
+${exportLine}
+`);
+    profileUpdated = true;
+    if (!options.json) {
+      console.log(`  \u2713 Added export line to ${profilePath}`);
+    }
+  } else if (profilePath) {
+    if (!options.json) {
+      console.log(`  \u2713 Export line already in ${profilePath}`);
+    }
+  }
+  let decryptOk = null;
+  const cliDir = findCliDir();
+  if (cliDir) {
+    const encryptedPath = `${cliDir}/.env.encrypted`;
+    if (existsSync2(encryptedPath)) {
+      try {
+        process.env[KEY_NAME] = trimmedKey;
+        execSync3(`rage -d -i - ${JSON.stringify(encryptedPath)}`, {
+          input: trimmedKey,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        decryptOk = true;
+        if (!options.json) {
+          console.log(`  \u2713 Decryption test passed (.env.encrypted)`);
+        }
+      } catch {
+        decryptOk = false;
+        if (!options.json) {
+          console.log(
+            `  \u26A0 Decryption test failed \u2014 key may not match .env.encrypted`
+          );
+        }
+      }
+    }
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        success: true,
+        keychain: keychainLabel,
+        profilePath,
+        profileUpdated,
+        decryptOk
+      })
+    );
+  } else {
+    console.log(`
+Done! Restart your shell or run:`);
+    console.log(`  source ${profilePath}`);
+    console.log(`
+Then verify with:`);
+    console.log(`  skill auth status
+`);
+  }
+}
+async function obtainKey(options) {
+  const hasOp = isOpCliAvailable();
+  if (hasOp) {
+    if (!options.json) {
+      console.log("  Checking 1Password CLI...");
+    }
+    const signedIn = isOpSignedIn();
+    if (signedIn) {
+      const method = await select({
+        message: "How do you want to provide the key?",
+        choices: [
+          {
+            name: "Fetch from 1Password automatically",
+            value: "auto"
+          },
+          { name: "Paste manually", value: "manual" }
+        ]
+      });
+      if (method === "auto") {
+        if (!options.json) {
+          console.log("  Fetching AGE_SECRET_KEY from 1Password...");
+        }
+        const value = fetchFromOp(OP_AGE_KEY_ITEM_ID, "password");
+        if (value && validateAgeKey(value) === true) {
+          if (!options.json) {
+            console.log("  \u2713 Retrieved from 1Password");
+          }
+          return value;
+        }
+        const alt = fetchFromOp(OP_AGE_KEY_ITEM_ID, "credential");
+        if (alt && validateAgeKey(alt) === true) {
+          if (!options.json) {
+            console.log("  \u2713 Retrieved from 1Password");
+          }
+          return alt;
+        }
+        if (!options.json) {
+          console.log(
+            "  \u26A0 Could not auto-fetch key. Falling back to manual paste."
+          );
+        }
+      }
+    } else if (!options.json) {
+      console.log("  1Password CLI found but not signed in to egghead account.");
+      console.log("  Sign in with: op signin --account egghead.1password.com");
+      console.log("");
+    }
+  } else if (!options.json) {
+    console.log("  1Password CLI not installed.");
+    console.log(`  Install it: ${getOpInstallInstructions()}`);
+    console.log("  (optional \u2014 you can paste the key manually below)\n");
+  }
+  if (!options.json) {
+    console.log(`  Get the key from 1Password:`);
+    console.log(`  ${OP_AGE_KEY_LINK}
+`);
+  }
+  const key = await password({
+    message: `Paste your ${KEY_NAME}:`,
+    mask: "*",
+    validate: validateAgeKey
+  });
+  return key.trim();
+}
+function findCliDir() {
+  const candidates = [
+    process.cwd(),
+    new URL("../../..", import.meta.url).pathname
+  ];
+  for (const dir of candidates) {
+    if (existsSync2(`${dir}/.env.encrypted`)) {
+      return dir;
+    }
+  }
+  return null;
+}
+
 // src/commands/auth/status.ts
+init_esm_shims();
+import fs from "fs/promises";
+import path from "path";
+var KEY_NAME2 = "AGE_SECRET_KEY";
 async function fileExists(filePath) {
   try {
     await fs.access(filePath);
@@ -74554,86 +74947,128 @@ function maskAgeKey(key) {
   return `${prefix}...${suffix}`;
 }
 function determineEnvSource(localExists, encryptedExists, ageKeyConfigured) {
-  if (localExists) {
-    return "local";
-  }
-  if (encryptedExists && ageKeyConfigured) {
-    return "encrypted";
-  }
+  if (localExists) return "local";
+  if (encryptedExists && ageKeyConfigured) return "encrypted";
   return "none";
 }
-async function statusAction(options) {
+function registerStatusCommand(auth) {
+  auth.command("status").description("Show auth configuration status").option("--json", "Output as JSON").action(async (options) => {
+    const status = await getAuthStatus();
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    printStatus(status);
+  });
+}
+async function getAuthStatus() {
+  const platform = detectPlatform();
   const cliDir = path.resolve(import.meta.dirname, "../../..");
   const envLocalPath = path.join(cliDir, ".env.local");
   const envLocalExists = await fileExists(envLocalPath);
   const envEncryptedPath = path.join(cliDir, ".env.encrypted");
   const envEncryptedExists = await fileExists(envEncryptedPath);
-  const ageSecretKey = process.env.AGE_SECRET_KEY;
+  const ageSecretKey = process.env[KEY_NAME2];
   const ageKeyConfigured = Boolean(ageSecretKey);
-  const opConfigured = isServiceAccountConfigured();
+  const keychainAvailable = isKeychainAvailable();
+  const keychainValue = keychainAvailable ? readFromKeychain(KEY_NAME2) : null;
+  const opInstalled = isOpCliAvailable();
+  const profilePath = detectShellProfile();
   const envSource = determineEnvSource(
     envLocalExists,
     envEncryptedExists,
     ageKeyConfigured
   );
-  const status = {
-    envLocal: {
-      exists: envLocalExists,
-      path: envLocalPath
-    },
-    envEncrypted: {
-      exists: envEncryptedExists,
-      path: envEncryptedPath
-    },
+  return {
+    envLocal: { exists: envLocalExists, path: envLocalPath },
+    envEncrypted: { exists: envEncryptedExists, path: envEncryptedPath },
     ageSecretKey: {
       configured: ageKeyConfigured,
       masked: ageKeyConfigured && ageSecretKey ? maskAgeKey(ageSecretKey) : void 0
     },
-    opServiceAccountToken: {
-      configured: opConfigured
+    keychain: {
+      available: keychainAvailable,
+      platform: platform === "macos" ? "macOS Keychain" : platform === "linux" ? "Linux secret-tool" : "unsupported",
+      stored: !!keychainValue
+    },
+    onepassword: {
+      cliInstalled: opInstalled,
+      signedIn: opInstalled ? isOpSignedIn() : false,
+      serviceAccountConfigured: isServiceAccountConfigured()
+    },
+    shellProfile: {
+      path: profilePath,
+      hasExport: profilePath ? shellProfileHasExport(profilePath, KEY_NAME2) : false
     },
     envSource
   };
-  if (options.json) {
-    console.log(JSON.stringify(status, null, 2));
-    return;
-  }
-  console.log("Auth Configuration Status\n");
-  console.log("Environment Files:");
+}
+function printStatus(status) {
+  console.log("\nAuth Status:\n");
+  console.log("  Environment Files:");
   console.log(
-    `  .env.local:     ${envLocalExists ? "\u2713" : "\u2717"} ${envLocalExists ? "(exists)" : "(not found)"}`
+    `    .env.local:      ${status.envLocal.exists ? "\u2713 (exists)" : "\u2717 (not found)"}`
   );
-  console.log(`    Path: ${envLocalPath}`);
   console.log(
-    `  .env.encrypted: ${envEncryptedExists ? "\u2713" : "\u2717"} ${envEncryptedExists ? "(exists)" : "(not found)"}`
+    `    .env.encrypted:  ${status.envEncrypted.exists ? "\u2713 (exists)" : "\u2717 (not found)"}`
   );
-  console.log(`    Path: ${envEncryptedPath}`);
-  console.log("\nEnvironment Variables:");
+  console.log("\n  AGE_SECRET_KEY:");
+  const envIcon = status.ageSecretKey.configured ? "\u2713" : "\u2717";
   console.log(
-    `  AGE_SECRET_KEY:           ${ageKeyConfigured ? "\u2713" : "\u2717"} ${ageKeyConfigured ? `(${status.ageSecretKey.masked})` : "(not set)"}`
+    `    env:       ${envIcon} ${status.ageSecretKey.configured ? `(${status.ageSecretKey.masked})` : "not set"}`
   );
+  console.log(`
+  Keychain (${status.keychain.platform}):`);
+  if (!status.keychain.available) {
+    console.log(`    ${KEY_NAME2}:  \u2717 (keychain CLI not available)`);
+  } else {
+    const kcIcon = status.keychain.stored ? "\u2713" : "\u2717";
+    console.log(
+      `    ${KEY_NAME2}:  ${kcIcon} ${status.keychain.stored ? "(stored)" : "not found"}`
+    );
+  }
+  console.log("\n  1Password:");
+  if (!status.onepassword.cliInstalled) {
+    console.log(`    op CLI:           \u2717 not installed (${getOpInstallInstructions()})`);
+  } else {
+    const signedInIcon = status.onepassword.signedIn ? "\u2713" : "\u2717";
+    console.log(
+      `    op CLI:           \u2713 installed, ${signedInIcon} ${status.onepassword.signedIn ? "signed in" : "not signed in"}`
+    );
+  }
   console.log(
-    `  OP_SERVICE_ACCOUNT_TOKEN: ${opConfigured ? "\u2713" : "\u2717"} ${opConfigured ? "(configured)" : "(not set)"}`
+    `    service account:  ${status.onepassword.serviceAccountConfigured ? "\u2713 configured" : "\u2717 not set"}`
   );
-  console.log("\nEnv Source Priority:");
-  if (envSource === "local") {
-    console.log("  \u2192 Using local .env.local file");
-  } else if (envSource === "encrypted") {
-    console.log("  \u2192 Using encrypted .env.encrypted file");
+  console.log("\n  Shell Profile:");
+  if (status.shellProfile.path) {
+    const spIcon = status.shellProfile.hasExport ? "\u2713" : "\u2717";
+    console.log(
+      `    ${status.shellProfile.path}:  ${spIcon} ${status.shellProfile.hasExport ? "export configured" : "no export line"}`
+    );
+  } else {
+    console.log("    Could not detect shell profile");
+  }
+  console.log("\n  Env Source:");
+  if (status.envSource === "local") {
+    console.log("    \u2192 Using .env.local");
+  } else if (status.envSource === "encrypted") {
+    console.log("    \u2192 Using .env.encrypted");
   } else {
-    console.log("  \u2192 No env source available");
-    console.log("\n\u26A0 No environment configuration found.");
-    console.log("\nOptions:");
-    console.log("  1. Create .env.local with your secrets");
-    console.log("  2. Use encrypted .env.encrypted (requires AGE_SECRET_KEY)");
-    console.log("\nSee docs/ENV.md for setup instructions.");
+    console.log("    \u2192 No env source available");
+  }
+  const allGood = status.ageSecretKey.configured && status.keychain.stored && status.shellProfile.hasExport;
+  if (allGood) {
+    console.log("\n  Everything looks good.\n");
+  } else if (!status.keychain.stored) {
+    console.log("\n  Run 'skill auth setup' to configure.\n");
   }
 }
 
 // src/commands/auth/index.ts
 function registerAuthCommands(program3) {
-  const auth = program3.command("auth").description("Manage CLI auth status");
-  auth.command("status").description("Check encryption setup status").option("--json", "Output as JSON").action(statusAction);
+  const auth = program3.command("auth").description("Auth and secret management");
+  registerSetupCommand(auth);
+  registerStatusCommand(auth);
 }
 
 // src/commands/axiom/index.ts
@@ -75819,9 +76254,9 @@ Saved to ${options.output}`);
   }
 }
 async function toEvalite(options) {
-  const { readFileSync: readFileSync8 } = await import("fs");
+  const { readFileSync: readFileSync9 } = await import("fs");
   const data2 = JSON.parse(
-    readFileSync8(options.input, "utf-8")
+    readFileSync9(options.input, "utf-8")
   );
   const evaliteData = data2.map((d) => ({
     input: d.triggerMessage.body,
@@ -75880,7 +76315,7 @@ var registerDbStatusCommand = (prog) => {
 
 // src/commands/deploys.ts
 init_esm_shims();
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import "commander";
 var VERCEL_SCOPE = "skillrecordings";
 var APPS = {
@@ -75898,7 +76333,7 @@ function stripAnsi(str2) {
 }
 function runVercel(args) {
   try {
-    const raw = execSync2(`vercel ${args} --scope ${VERCEL_SCOPE} --yes 2>&1`, {
+    const raw = execSync4(`vercel ${args} --scope ${VERCEL_SCOPE} --yes 2>&1`, {
       encoding: "utf-8",
       timeout: 3e4,
       stdio: ["pipe", "pipe", "pipe"],
@@ -75980,7 +76415,7 @@ async function deploysLogs(appName, options) {
   console.log(`   Deployment: ${url}
 `);
   try {
-    const logsOutput = execSync2(
+    const logsOutput = execSync4(
       `vercel logs ${url} --scope ${VERCEL_SCOPE} --output short 2>&1 | tail -${options.lines || "30"}`,
       { encoding: "utf-8", timeout: 3e4 }
     );
@@ -77500,7 +77935,7 @@ async function runScenario(scenario, systemPrompt, model, verbose, useRealTools)
   const startTime = Date.now();
   const failureReasons = [];
   const trigger = scenario.trigger || scenario.triggerMessage || { subject: "", body: "" };
-  const input2 = `Subject: ${trigger.subject}
+  const input3 = `Subject: ${trigger.subject}
 
 ${trigger.body}`;
   const name = scenario.name || trigger.subject || scenario.id;
@@ -77544,7 +77979,7 @@ App: ${scenario.appId || "total-typescript"}`;
     const result = await generateText({
       model,
       system: evalSystemPrompt,
-      messages: [{ role: "user", content: input2 }],
+      messages: [{ role: "user", content: input3 }],
       tools,
       stopWhen: stepCountIs(10)
       // Match production - use stopWhen for multi-step
@@ -77955,12 +78390,12 @@ async function scoreProduction(options) {
 
 // src/commands/eval-local/seed.ts
 init_esm_shims();
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { glob as glob3 } from "glob";
 
 // src/lib/eval-seed.ts
 init_esm_shims();
-import { join } from "path";
+import { join as join2 } from "path";
 import { readFile as readFile4, readdir } from "fs/promises";
 import { glob as glob2 } from "glob";
 import matter from "gray-matter";
@@ -77996,7 +78431,7 @@ async function loadJsonFiles(dirPath) {
     const jsonFiles = files.filter((f) => f.endsWith(".json"));
     const items = await Promise.all(
       jsonFiles.map(async (file) => {
-        const content = await readFile4(join(dirPath, file), "utf-8");
+        const content = await readFile4(join2(dirPath, file), "utf-8");
         return JSON.parse(content);
       })
     );
@@ -78006,7 +78441,7 @@ async function loadJsonFiles(dirPath) {
   }
 }
 async function loadKnowledgeFiles(basePath) {
-  const files = await glob2(join(basePath, "**/*.md"));
+  const files = await glob2(join2(basePath, "**/*.md"));
   const docs = [];
   for (const filePath of files) {
     const content = await readFile4(filePath, "utf-8");
@@ -78201,16 +78636,16 @@ async function seed(options) {
       }
     }
     if (!options.json) console.log("\u{1F4E6} Seeding apps...");
-    const apps = await loadJsonFiles(join2(fixturesPath, "apps"));
+    const apps = await loadJsonFiles(join3(fixturesPath, "apps"));
     result.apps = await seedApps(connection, apps);
     if (!options.json) console.log("\u{1F465} Loading customer fixtures...");
-    const customers = await loadJsonFiles(join2(fixturesPath, "customers"));
+    const customers = await loadJsonFiles(join3(fixturesPath, "customers"));
     result.customers = customers.length;
     if (!options.json) console.log("\u{1F4DA} Seeding knowledge base...");
-    const knowledge = await loadKnowledgeFiles(join2(fixturesPath, "knowledge"));
+    const knowledge = await loadKnowledgeFiles(join3(fixturesPath, "knowledge"));
     result.knowledge = knowledge.length;
     result.embeddings = await seedKnowledgeBase(knowledge, !options.json);
-    const scenarioFiles = await glob3(join2(fixturesPath, "scenarios/**/*.json"));
+    const scenarioFiles = await glob3(join3(fixturesPath, "scenarios/**/*.json"));
     result.scenarios = scenarioFiles.length;
     await connection.end();
     if (options.json) {
@@ -78263,8 +78698,8 @@ init_esm_shims();
 // src/commands/eval-pipeline/run.ts
 init_esm_shims();
 import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
 import { readFile as readFile5 } from "fs/promises";
 import { glob as glob4 } from "glob";
 
@@ -78670,12 +79105,12 @@ function getCacheKey(scenarioId, classifySourceHash) {
 function getClassifySourceHash() {
   try {
     const possiblePaths = [
-      join3(process.cwd(), "packages/core/src/pipeline/classify.ts"),
-      join3(process.cwd(), "../core/src/pipeline/classify.ts")
+      join4(process.cwd(), "packages/core/src/pipeline/classify.ts"),
+      join4(process.cwd(), "../core/src/pipeline/classify.ts")
     ];
     for (const path2 of possiblePaths) {
-      if (existsSync(path2)) {
-        const content = readFileSync(path2, "utf-8");
+      if (existsSync3(path2)) {
+        const content = readFileSync2(path2, "utf-8");
         return createHash("md5").update(content).digest("hex");
       }
     }
@@ -78684,10 +79119,10 @@ function getClassifySourceHash() {
   return createHash("md5").update(Math.floor(Date.now() / 3e5).toString()).digest("hex");
 }
 function loadCachedClassify(cacheKey) {
-  const cachePath = join3(CACHE_DIR, `${cacheKey}.json`);
+  const cachePath = join4(CACHE_DIR, `${cacheKey}.json`);
   try {
-    if (existsSync(cachePath)) {
-      return JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (existsSync3(cachePath)) {
+      return JSON.parse(readFileSync2(cachePath, "utf-8"));
     }
   } catch {
   }
@@ -78695,17 +79130,17 @@ function loadCachedClassify(cacheKey) {
 }
 function saveCachedClassify(cacheKey, result) {
   try {
-    if (!existsSync(CACHE_DIR)) {
+    if (!existsSync3(CACHE_DIR)) {
       mkdirSync(CACHE_DIR, { recursive: true });
     }
-    const cachePath = join3(CACHE_DIR, `${cacheKey}.json`);
+    const cachePath = join4(CACHE_DIR, `${cacheKey}.json`);
     writeFileSync2(cachePath, JSON.stringify(result));
   } catch {
   }
 }
 function clearClassifyCache() {
   try {
-    if (existsSync(CACHE_DIR)) {
+    if (existsSync3(CACHE_DIR)) {
       rmSync(CACHE_DIR, { recursive: true, force: true });
     }
   } catch {
@@ -78921,7 +79356,7 @@ async function runClassifyEval(scenarios, options) {
         durationMs: 0
       };
     }
-    const input2 = {
+    const input3 = {
       subject: trigger.subject,
       body: trigger.body,
       appId: scenario.appId
@@ -78935,14 +79370,14 @@ async function runClassifyEval(scenarios, options) {
         if (cached) {
           result = cached;
         } else {
-          result = await classify(input2, {
+          result = await classify(input3, {
             forceLLM: options.forceLlm,
             model: options.model
           });
           saveCachedClassify(cacheKey, result);
         }
       } else {
-        result = await classify(input2, {
+        result = await classify(input3, {
           forceLLM: options.forceLlm,
           model: options.model
         });
@@ -79011,7 +79446,7 @@ async function runRouteEval(scenarios, options) {
         durationMs: 0
       };
     }
-    const input2 = {
+    const input3 = {
       subject: trigger.subject,
       body: trigger.body,
       appId: scenario.appId
@@ -79025,20 +79460,20 @@ async function runRouteEval(scenarios, options) {
         if (cached) {
           classification = cached;
         } else {
-          classification = await classify(input2, {
+          classification = await classify(input3, {
             forceLLM: options.forceLlm,
             model: options.model
           });
           saveCachedClassify(cacheKey, classification);
         }
       } else {
-        classification = await classify(input2, {
+        classification = await classify(input3, {
           forceLLM: options.forceLlm,
           model: options.model
         });
       }
       const routeResult = route({
-        message: input2,
+        message: input3,
         classification,
         appConfig: {
           appId: scenario.appId || "eval",
@@ -79556,7 +79991,7 @@ Latency: ${avgLatency.toFixed(0)}ms avg`);
 
 // src/commands/eval-pipeline/seed.ts
 init_esm_shims();
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { glob as glob5 } from "glob";
 async function seed2(options) {
   const fixturesPath = options.fixtures || "fixtures";
@@ -79586,20 +80021,20 @@ async function seed2(options) {
       await cleanQdrant();
     }
     if (!options.json) console.log("\u{1F4E6} Seeding apps...");
-    const apps = await loadJsonFiles(join4(fixturesPath, "apps"));
+    const apps = await loadJsonFiles(join5(fixturesPath, "apps"));
     result.apps = await seedApps(connection, apps);
     const [trustRows] = await connection.execute(
       "SELECT COUNT(*) as count FROM SUPPORT_trust_scores"
     );
     result.trustScores = trustRows[0].count;
     if (!options.json) console.log("\u{1F465} Loading customer fixtures...");
-    const customers = await loadJsonFiles(join4(fixturesPath, "customers"));
+    const customers = await loadJsonFiles(join5(fixturesPath, "customers"));
     result.customers = customers.length;
     if (!options.json) console.log("\u{1F4DA} Seeding knowledge base...");
-    const knowledge = await loadKnowledgeFiles(join4(fixturesPath, "knowledge"));
+    const knowledge = await loadKnowledgeFiles(join5(fixturesPath, "knowledge"));
     result.knowledge = knowledge.length;
     result.embeddings = await seedKnowledgeBase(knowledge, !options.json);
-    const scenarioFiles = await glob5(join4(fixturesPath, "scenarios/**/*.json"));
+    const scenarioFiles = await glob5(join5(fixturesPath, "scenarios/**/*.json"));
     result.scenarios = scenarioFiles.length;
     await connection.end();
     if (options.json) {
@@ -79656,7 +80091,7 @@ function registerEvalPipelineCommands(program3) {
 
 // src/commands/eval-prompt.ts
 init_esm_shims();
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
 import { generateText as generateText2, stepCountIs as stepCountIs2, tool as tool4 } from "ai";
 import { z as z5 } from "zod";
 var leakPatterns = [
@@ -79789,14 +80224,14 @@ var mockTools = {
 };
 async function runSingleEval(prompt, sample, model) {
   const startTime = Date.now();
-  const input2 = `Subject: ${sample.triggerMessage.subject}
+  const input3 = `Subject: ${sample.triggerMessage.subject}
 
 ${sample.triggerMessage.body}`;
   try {
     const result = await generateText2({
       model,
       system: prompt + "\n\nApp: total-typescript",
-      messages: [{ role: "user", content: input2 }],
+      messages: [{ role: "user", content: input3 }],
       tools: mockTools,
       stopWhen: stepCountIs2(10)
     });
@@ -79805,7 +80240,7 @@ ${sample.triggerMessage.body}`;
     const output = draftCall ? draftCall.input.body : "";
     return {
       id: sample.id.slice(0, 8),
-      input: input2.slice(0, 100),
+      input: input3.slice(0, 100),
       output,
       score: scoreResponse(output),
       durationMs: Date.now() - startTime,
@@ -79815,7 +80250,7 @@ ${sample.triggerMessage.body}`;
   } catch (error) {
     return {
       id: sample.id.slice(0, 8),
-      input: input2.slice(0, 100),
+      input: input3.slice(0, 100),
       output: `ERROR: ${error instanceof Error ? error.message : "Unknown"}`,
       score: { leaks: [], meta: [], banned: [], passed: false },
       durationMs: Date.now() - startTime,
@@ -79836,20 +80271,20 @@ async function runEval2(options) {
   } = options;
   let prompt = SUPPORT_AGENT_PROMPT;
   if (promptPath) {
-    if (!existsSync2(promptPath)) {
+    if (!existsSync4(promptPath)) {
       console.error(`Prompt file not found: ${promptPath}`);
       process.exit(1);
     }
-    prompt = readFileSync2(promptPath, "utf-8");
+    prompt = readFileSync3(promptPath, "utf-8");
     console.log(`Using prompt from: ${promptPath}`);
   } else {
     console.log("Using production prompt");
   }
-  if (!existsSync2(datasetPath)) {
+  if (!existsSync4(datasetPath)) {
     console.error(`Dataset not found: ${datasetPath}`);
     process.exit(1);
   }
-  const dataset = JSON.parse(readFileSync2(datasetPath, "utf-8"));
+  const dataset = JSON.parse(readFileSync3(datasetPath, "utf-8"));
   const samples = dataset.slice(0, limit2);
   console.log(`
 \u{1F9EA} Running eval on ${samples.length} samples (model: ${model})
@@ -79921,9 +80356,9 @@ async function comparePrompts(options) {
     limit: limit2 = 10,
     model = "anthropic/claude-haiku-4-5"
   } = options;
-  const baselinePrompt = baseline ? readFileSync2(baseline, "utf-8") : SUPPORT_AGENT_PROMPT;
-  const candidatePrompt = readFileSync2(candidate, "utf-8");
-  const dataset = JSON.parse(readFileSync2(datasetPath, "utf-8"));
+  const baselinePrompt = baseline ? readFileSync3(baseline, "utf-8") : SUPPORT_AGENT_PROMPT;
+  const candidatePrompt = readFileSync3(candidate, "utf-8");
+  const dataset = JSON.parse(readFileSync3(datasetPath, "utf-8"));
   const samples = dataset.slice(0, limit2);
   console.log(`
 \u{1F52C} Comparing prompts on ${samples.length} samples
@@ -79985,20 +80420,20 @@ init_esm_shims();
 
 // src/commands/faq/classify.ts
 init_esm_shims();
-import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join5, resolve } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join6, resolve } from "path";
 import { generateObject } from "ai";
 import { z as z6 } from "zod";
 var PROJECT_ROOT = resolve(__dirname, "../../../..");
-var DEFAULT_PARQUET_PATH = join5(
+var DEFAULT_PARQUET_PATH = join6(
   PROJECT_ROOT,
   "artifacts/phase-0/embeddings/v2/conversations.parquet"
 );
-var DEFAULT_TAXONOMY_PATH = join5(
+var DEFAULT_TAXONOMY_PATH = join6(
   PROJECT_ROOT,
   "artifacts/phase-1/llm-topics/taxonomy.json"
 );
-var DEFAULT_OUTPUT_PATH = join5(
+var DEFAULT_OUTPUT_PATH = join6(
   PROJECT_ROOT,
   "artifacts/phase-1/llm-topics/classifications.jsonl"
 );
@@ -80007,7 +80442,7 @@ var CONCURRENT_LIMIT = 10;
 var DELAY_BETWEEN_BATCHES_MS = 100;
 var MODEL = "anthropic/claude-haiku-4-5";
 async function loadConversationsFromParquet(parquetPath) {
-  const { execSync: execSync3 } = await import("child_process");
+  const { execSync: execSync5 } = await import("child_process");
   const query = `
     SELECT 
       conversation_id,
@@ -80018,7 +80453,7 @@ async function loadConversationsFromParquet(parquetPath) {
     WHERE first_message IS NOT NULL
     ORDER BY conversation_id
   `;
-  const result = execSync3(`duckdb -json -c "${query.replace(/"/g, '\\"')}"`, {
+  const result = execSync5(`duckdb -json -c "${query.replace(/"/g, '\\"')}"`, {
     encoding: "utf-8",
     maxBuffer: 100 * 1024 * 1024
     // 100MB buffer for large datasets
@@ -80028,10 +80463,10 @@ async function loadConversationsFromParquet(parquetPath) {
 }
 function loadExistingClassifications(outputPath) {
   const classifiedIds = /* @__PURE__ */ new Set();
-  if (!existsSync3(outputPath)) {
+  if (!existsSync5(outputPath)) {
     return classifiedIds;
   }
-  const content = readFileSync3(outputPath, "utf-8");
+  const content = readFileSync4(outputPath, "utf-8");
   const lines = content.split("\n").filter((line) => line.trim());
   for (const line of lines) {
     try {
@@ -80043,7 +80478,7 @@ function loadExistingClassifications(outputPath) {
   return classifiedIds;
 }
 function appendClassification(outputPath, classification) {
-  appendFileSync(outputPath, JSON.stringify(classification) + "\n");
+  appendFileSync2(outputPath, JSON.stringify(classification) + "\n");
 }
 var classifySchema = z6.object({
   topicId: z6.string(),
@@ -80172,20 +80607,20 @@ async function faqClassify(options) {
   console.log(`   Concurrency:    ${CONCURRENT_LIMIT}`);
   console.log(`   Dry run:        ${options.dryRun ?? false}`);
   console.log("");
-  if (!existsSync3(parquetPath)) {
+  if (!existsSync5(parquetPath)) {
     console.error(`\u274C Parquet file not found: ${parquetPath}`);
     process.exit(1);
   }
-  if (!existsSync3(taxonomyPath)) {
+  if (!existsSync5(taxonomyPath)) {
     console.error(`\u274C Taxonomy file not found: ${taxonomyPath}`);
     process.exit(1);
   }
   const outputDir = dirname2(outputPath);
-  if (!existsSync3(outputDir)) {
+  if (!existsSync5(outputDir)) {
     mkdirSync2(outputDir, { recursive: true });
   }
   console.log("\u{1F4DA} Loading taxonomy...");
-  const taxonomy = JSON.parse(readFileSync3(taxonomyPath, "utf-8"));
+  const taxonomy = JSON.parse(readFileSync4(taxonomyPath, "utf-8"));
   const validTopicIds = new Set(taxonomy.topics.map((t2) => t2.id));
   validTopicIds.add("unknown");
   console.log(`   Found ${taxonomy.topics.length} topics`);
@@ -80278,51 +80713,51 @@ function registerFaqClassifyCommands(program3) {
 
 // src/commands/faq/cluster.ts
 init_esm_shims();
-import { existsSync as existsSync5 } from "fs";
-import { join as join7, resolve as resolve2 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join8, resolve as resolve2 } from "path";
 
 // ../core/src/faq/production-clusterer.ts
 init_esm_shims();
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
 function readPhase0Assignments(phase0Path) {
-  const assignmentsPath = join6(phase0Path, "clusters/v1/assignments.json");
-  if (!existsSync4(assignmentsPath)) {
-    const latestPath = join6(phase0Path, "clusters/latest/assignments.json");
-    if (!existsSync4(latestPath)) {
+  const assignmentsPath = join7(phase0Path, "clusters/v1/assignments.json");
+  if (!existsSync6(assignmentsPath)) {
+    const latestPath = join7(phase0Path, "clusters/latest/assignments.json");
+    if (!existsSync6(latestPath)) {
       throw new Error(`Phase 0 assignments not found at ${assignmentsPath}`);
     }
-    const content2 = readFileSync4(latestPath, "utf-8");
+    const content2 = readFileSync5(latestPath, "utf-8");
     return JSON.parse(content2);
   }
-  const content = readFileSync4(assignmentsPath, "utf-8");
+  const content = readFileSync5(assignmentsPath, "utf-8");
   return JSON.parse(content);
 }
 function readPhase0Labels(phase0Path) {
-  const labelsPath = join6(phase0Path, "clusters/v1/labels.json");
-  if (!existsSync4(labelsPath)) {
-    const latestPath = join6(phase0Path, "clusters/latest/labels.json");
-    if (!existsSync4(latestPath)) {
+  const labelsPath = join7(phase0Path, "clusters/v1/labels.json");
+  if (!existsSync6(labelsPath)) {
+    const latestPath = join7(phase0Path, "clusters/latest/labels.json");
+    if (!existsSync6(latestPath)) {
       throw new Error(`Phase 0 labels not found at ${labelsPath}`);
     }
-    const content2 = readFileSync4(latestPath, "utf-8");
+    const content2 = readFileSync5(latestPath, "utf-8");
     const parsed2 = JSON.parse(content2);
     return parsed2.clusters || [];
   }
-  const content = readFileSync4(labelsPath, "utf-8");
+  const content = readFileSync5(labelsPath, "utf-8");
   const parsed = JSON.parse(content);
   return parsed.clusters || [];
 }
 function readPhase0Metrics(phase0Path) {
-  const metricsPath = join6(phase0Path, "clusters/v1/metrics.json");
-  if (!existsSync4(metricsPath)) {
-    const latestPath = join6(phase0Path, "clusters/latest/metrics.json");
-    if (!existsSync4(latestPath)) {
+  const metricsPath = join7(phase0Path, "clusters/v1/metrics.json");
+  if (!existsSync6(metricsPath)) {
+    const latestPath = join7(phase0Path, "clusters/latest/metrics.json");
+    if (!existsSync6(latestPath)) {
       throw new Error(`Phase 0 metrics not found at ${metricsPath}`);
     }
-    return JSON.parse(readFileSync4(latestPath, "utf-8"));
+    return JSON.parse(readFileSync5(latestPath, "utf-8"));
   }
-  return JSON.parse(readFileSync4(metricsPath, "utf-8"));
+  return JSON.parse(readFileSync5(metricsPath, "utf-8"));
 }
 function calculateConfidence2(distance) {
   if (distance === null) return 0;
@@ -80437,17 +80872,17 @@ async function generateProductionClustering(options) {
   return result;
 }
 function writeProductionArtifacts(result, outputPath) {
-  const versionPath = join6(outputPath, result.version);
-  if (!existsSync4(versionPath)) {
+  const versionPath = join7(outputPath, result.version);
+  if (!existsSync6(versionPath)) {
     mkdirSync3(versionPath, { recursive: true });
   }
-  const resultPath = join6(versionPath, "clustering-result.json");
+  const resultPath = join7(versionPath, "clustering-result.json");
   writeFileSync4(resultPath, JSON.stringify(result, null, 2));
   console.log(`\u2705 Written: ${resultPath}`);
-  const assignmentsPath = join6(versionPath, "assignments.json");
+  const assignmentsPath = join7(versionPath, "assignments.json");
   writeFileSync4(assignmentsPath, JSON.stringify(result.assignments, null, 2));
   console.log(`\u2705 Written: ${assignmentsPath}`);
-  const clustersPath = join6(versionPath, "clusters.json");
+  const clustersPath = join7(versionPath, "clusters.json");
   writeFileSync4(
     clustersPath,
     JSON.stringify(
@@ -80462,7 +80897,7 @@ function writeProductionArtifacts(result, outputPath) {
     )
   );
   console.log(`\u2705 Written: ${clustersPath}`);
-  const summaryPath = join6(versionPath, "summary.json");
+  const summaryPath = join7(versionPath, "summary.json");
   const summary = {
     version: result.version,
     generatedAt: result.generatedAt,
@@ -80476,8 +80911,8 @@ function writeProductionArtifacts(result, outputPath) {
   };
   writeFileSync4(summaryPath, JSON.stringify(summary, null, 2));
   console.log(`\u2705 Written: ${summaryPath}`);
-  const latestPath = join6(outputPath, "latest");
-  if (existsSync4(latestPath)) {
+  const latestPath = join7(outputPath, "latest");
+  if (existsSync6(latestPath)) {
     const { rmSync: rmSync2 } = __require("fs");
     rmSync2(latestPath, { recursive: true, force: true });
   }
@@ -80488,9 +80923,9 @@ function writeProductionArtifacts(result, outputPath) {
     "clusters.json",
     "summary.json"
   ]) {
-    const src = join6(versionPath, file);
-    const dst = join6(latestPath, file);
-    writeFileSync4(dst, readFileSync4(src));
+    const src = join7(versionPath, file);
+    const dst = join7(latestPath, file);
+    writeFileSync4(dst, readFileSync5(src));
   }
   console.log(`\u2705 Updated: ${latestPath}`);
 }
@@ -80542,22 +80977,22 @@ function displayClusteringSummary(result) {
 
 // src/commands/faq/cluster.ts
 var PROJECT_ROOT2 = resolve2(__dirname, "../../../..");
-var DEFAULT_PHASE0_PATH = join7(PROJECT_ROOT2, "artifacts/phase-0");
-var DEFAULT_OUTPUT_PATH2 = join7(PROJECT_ROOT2, "artifacts/phase-1/clustering");
+var DEFAULT_PHASE0_PATH = join8(PROJECT_ROOT2, "artifacts/phase-0");
+var DEFAULT_OUTPUT_PATH2 = join8(PROJECT_ROOT2, "artifacts/phase-1/clustering");
 function validatePaths(phase0Path) {
-  const assignmentsPath = join7(phase0Path, "clusters/v1/assignments.json");
-  const labelsPath = join7(phase0Path, "clusters/v1/labels.json");
-  const metricsPath = join7(phase0Path, "clusters/v1/metrics.json");
-  if (!existsSync5(assignmentsPath)) {
+  const assignmentsPath = join8(phase0Path, "clusters/v1/assignments.json");
+  const labelsPath = join8(phase0Path, "clusters/v1/labels.json");
+  const metricsPath = join8(phase0Path, "clusters/v1/metrics.json");
+  if (!existsSync7(assignmentsPath)) {
     throw new Error(
       `Phase 0 assignments not found at ${assignmentsPath}
 Run Phase 0 clustering first or specify correct --phase0-path`
     );
   }
-  if (!existsSync5(labelsPath)) {
+  if (!existsSync7(labelsPath)) {
     throw new Error(`Phase 0 labels not found at ${labelsPath}`);
   }
-  if (!existsSync5(metricsPath)) {
+  if (!existsSync7(metricsPath)) {
     throw new Error(`Phase 0 metrics not found at ${metricsPath}`);
   }
 }
@@ -80586,7 +81021,7 @@ async function faqCluster(options) {
       console.log("\n\u{1F4DD} Writing artifacts...");
       writeProductionArtifacts(result, outputPath);
       console.log("\n\u2705 Production clustering complete!");
-      console.log(`   Artifacts written to: ${join7(outputPath, version)}`);
+      console.log(`   Artifacts written to: ${join8(outputPath, version)}`);
     } else {
       console.log("\n\u{1F9EA} Dry run - no artifacts written");
     }
@@ -80620,8 +81055,8 @@ function registerFaqClusterCommands(program3) {
 
 // src/commands/faq/extract.ts
 init_esm_shims();
-import { existsSync as existsSync7 } from "fs";
-import { join as join9, resolve as resolve3 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join10, resolve as resolve3 } from "path";
 
 // ../core/src/faq/duckdb-source.ts
 init_esm_shims();
@@ -81149,8 +81584,8 @@ async function createDuckDBSource(config) {
 
 // ../core/src/faq/extractor.ts
 init_esm_shims();
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
 
 // ../core/src/faq/review.ts
 init_esm_shims();
@@ -81175,39 +81610,39 @@ function getKnowledgeRedisKey(id, namespace) {
 }
 
 // ../core/src/knowledge/search.ts
-async function storeKnowledgeArticle(input2) {
+async function storeKnowledgeArticle(input3) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const id = randomUUID();
-  const namespace = input2.shared ? KNOWLEDGE_NAMESPACE.SHARED : getKnowledgeNamespace(input2.appId);
+  const namespace = input3.shared ? KNOWLEDGE_NAMESPACE.SHARED : getKnowledgeNamespace(input3.appId);
   const article = {
     id,
-    title: input2.title,
-    question: input2.question,
-    answer: input2.answer,
-    appId: input2.appId,
+    title: input3.title,
+    question: input3.question,
+    answer: input3.answer,
+    appId: input3.appId,
     metadata: {
-      source: input2.source,
-      category: input2.category,
+      source: input3.source,
+      category: input3.category,
       created_at: now,
       updated_at: now,
-      tags: input2.tags ?? [],
-      trust_score: input2.trust_score ?? 1,
+      tags: input3.tags ?? [],
+      trust_score: input3.trust_score ?? 1,
       usage_count: 0
     }
   };
-  const searchableText = `${input2.title}
+  const searchableText = `${input3.title}
 
-${input2.question}`;
+${input3.question}`;
   await upsertVector({
     id,
     data: searchableText,
     metadata: {
       type: "knowledge",
-      appId: input2.shared ? "shared" : input2.appId,
+      appId: input3.shared ? "shared" : input3.appId,
       // Map knowledge categories to vector categories where possible
-      category: input2.category,
-      source: input2.source,
-      trustScore: input2.trust_score ?? 1
+      category: input3.category,
+      source: input3.source,
+      trustScore: input3.trust_score ?? 1
     }
   });
   const redis = getRedis();
@@ -81532,12 +81967,12 @@ function deduplicateCandidates(candidates, threshold) {
   };
 }
 function readClusteringResult(path2) {
-  const content = readFileSync5(path2, "utf-8");
+  const content = readFileSync6(path2, "utf-8");
   return JSON.parse(content);
 }
 function readGoldenResponses(path2) {
   try {
-    const content = readFileSync5(path2, "utf-8");
+    const content = readFileSync6(path2, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.responses || parsed;
   } catch {
@@ -81764,14 +82199,14 @@ async function extractFaqCandidates(options) {
   return result;
 }
 function writeExtractionArtifacts(result, outputPath) {
-  const versionPath = join8(outputPath, result.version);
-  if (!existsSync6(versionPath)) {
+  const versionPath = join9(outputPath, result.version);
+  if (!existsSync8(versionPath)) {
     mkdirSync4(versionPath, { recursive: true });
   }
-  const resultPath = join8(versionPath, "extraction-result.json");
+  const resultPath = join9(versionPath, "extraction-result.json");
   writeFileSync5(resultPath, JSON.stringify(result, null, 2));
   console.log(`\u2705 Written: ${resultPath}`);
-  const candidatesPath = join8(versionPath, "candidates.json");
+  const candidatesPath = join9(versionPath, "candidates.json");
   const candidatesData = {
     version: result.version,
     extractedAt: result.extractedAt,
@@ -81791,7 +82226,7 @@ function writeExtractionArtifacts(result, outputPath) {
   };
   writeFileSync5(candidatesPath, JSON.stringify(candidatesData, null, 2));
   console.log(`\u2705 Written: ${candidatesPath}`);
-  const statsPath = join8(versionPath, "stats.json");
+  const statsPath = join9(versionPath, "stats.json");
   writeFileSync5(
     statsPath,
     JSON.stringify(
@@ -81805,8 +82240,8 @@ function writeExtractionArtifacts(result, outputPath) {
     )
   );
   console.log(`\u2705 Written: ${statsPath}`);
-  const latestPath = join8(outputPath, "latest");
-  if (existsSync6(latestPath)) {
+  const latestPath = join9(outputPath, "latest");
+  if (existsSync8(latestPath)) {
     const { rmSync: rmSync2 } = __require("fs");
     rmSync2(latestPath, { recursive: true, force: true });
   }
@@ -81816,10 +82251,10 @@ function writeExtractionArtifacts(result, outputPath) {
     "candidates.json",
     "stats.json"
   ]) {
-    const src = join8(versionPath, file);
-    const dst = join8(latestPath, file);
-    if (existsSync6(src)) {
-      writeFileSync5(dst, readFileSync5(src));
+    const src = join9(versionPath, file);
+    const dst = join9(latestPath, file);
+    if (existsSync8(src)) {
+      writeFileSync5(dst, readFileSync6(src));
     }
   }
   console.log(`\u2705 Updated: ${latestPath}`);
@@ -81872,24 +82307,24 @@ ${i + 1}. [${confPct}%]${golden} ${candidate.suggestedCategory}`
 
 // src/commands/faq/extract.ts
 var PROJECT_ROOT3 = resolve3(__dirname, "../../../..");
-var DEFAULT_CLUSTERING_PATH = join9(
+var DEFAULT_CLUSTERING_PATH = join10(
   PROJECT_ROOT3,
   "artifacts/phase-1/clustering/v1/clustering-result.json"
 );
-var DEFAULT_GOLDEN_PATH = join9(
+var DEFAULT_GOLDEN_PATH = join10(
   PROJECT_ROOT3,
   "artifacts/phase-0/golden/latest/responses.json"
 );
-var DEFAULT_OUTPUT_PATH3 = join9(PROJECT_ROOT3, "artifacts/phase-1/extraction");
+var DEFAULT_OUTPUT_PATH3 = join10(PROJECT_ROOT3, "artifacts/phase-1/extraction");
 var DEFAULT_CACHE_PATH = `${process.env.HOME}/skill/data/front-cache.db`;
 function validatePaths2(clusteringPath, goldenPath) {
-  if (!existsSync7(clusteringPath)) {
+  if (!existsSync9(clusteringPath)) {
     throw new Error(
       `Clustering result not found at ${clusteringPath}
 Run \`bun src/index.ts faq cluster\` first to generate clustering.`
     );
   }
-  if (goldenPath && !existsSync7(goldenPath)) {
+  if (goldenPath && !existsSync9(goldenPath)) {
     console.warn(`\u26A0\uFE0F  Golden responses not found at ${goldenPath}`);
     console.warn("   Golden matching will be disabled.");
   }
@@ -81913,7 +82348,7 @@ async function faqExtract(options) {
   console.log(`   Dry run:       ${options.dryRun ?? false}`);
   console.log("");
   validatePaths2(clusteringPath, goldenPath);
-  if (!existsSync7(cachePath)) {
+  if (!existsSync9(cachePath)) {
     throw new Error(
       `DuckDB cache not found at ${cachePath}
 Run \`bun src/index.ts front-cache sync\` first to populate cache.`
@@ -81931,7 +82366,7 @@ Run \`bun src/index.ts front-cache sync\` first to populate cache.`
     }
     const extractionOptions = {
       clusteringPath,
-      goldenPath: existsSync7(goldenPath) ? goldenPath : void 0,
+      goldenPath: existsSync9(goldenPath) ? goldenPath : void 0,
       source,
       outputPath,
       version,
@@ -81972,7 +82407,7 @@ Run \`bun src/index.ts front-cache sync\` first to populate cache.`
     if (!options.dryRun) {
       console.log(`
 \u2705 Extraction complete!`);
-      console.log(`   Artifacts written to: ${join9(outputPath, version)}`);
+      console.log(`   Artifacts written to: ${join10(outputPath, version)}`);
       if (options.pushRedis && options.app) {
         console.log(
           `   Candidates pushed to Redis queue: faq:pending:${options.app}`
@@ -83323,60 +83758,60 @@ function parseURL(urlStr) {
   return parse_url(urlStr);
 }
 var streamDestructionSupported = "destroy" in Stream.Readable.prototype;
-function isRequest(input2) {
-  return typeof input2 === "object" && typeof input2[INTERNALS$2] === "object";
+function isRequest(input3) {
+  return typeof input3 === "object" && typeof input3[INTERNALS$2] === "object";
 }
 function isAbortSignal(signal) {
   const proto = signal && typeof signal === "object" && Object.getPrototypeOf(signal);
   return !!(proto && proto.constructor.name === "AbortSignal");
 }
 var Request2 = class _Request {
-  constructor(input2) {
+  constructor(input3) {
     let init3 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
     let parsedURL;
-    if (!isRequest(input2)) {
-      if (input2 && input2.href) {
-        parsedURL = parseURL(input2.href);
+    if (!isRequest(input3)) {
+      if (input3 && input3.href) {
+        parsedURL = parseURL(input3.href);
       } else {
-        parsedURL = parseURL(`${input2}`);
+        parsedURL = parseURL(`${input3}`);
       }
-      input2 = {};
+      input3 = {};
     } else {
-      parsedURL = parseURL(input2.url);
+      parsedURL = parseURL(input3.url);
     }
-    let method = init3.method || input2.method || "GET";
+    let method = init3.method || input3.method || "GET";
     method = method.toUpperCase();
-    if ((init3.body != null || isRequest(input2) && input2.body !== null) && (method === "GET" || method === "HEAD")) {
+    if ((init3.body != null || isRequest(input3) && input3.body !== null) && (method === "GET" || method === "HEAD")) {
       throw new TypeError("Request with GET/HEAD method cannot have body");
     }
-    let inputBody = init3.body != null ? init3.body : isRequest(input2) && input2.body !== null ? clone(input2) : null;
+    let inputBody = init3.body != null ? init3.body : isRequest(input3) && input3.body !== null ? clone(input3) : null;
     Body.call(this, inputBody, {
-      timeout: init3.timeout || input2.timeout || 0,
-      size: init3.size || input2.size || 0
+      timeout: init3.timeout || input3.timeout || 0,
+      size: init3.size || input3.size || 0
     });
-    const headers = new Headers2(init3.headers || input2.headers || {});
+    const headers = new Headers2(init3.headers || input3.headers || {});
     if (inputBody != null && !headers.has("Content-Type")) {
       const contentType = extractContentType(inputBody);
       if (contentType) {
         headers.append("Content-Type", contentType);
       }
     }
-    let signal = isRequest(input2) ? input2.signal : null;
+    let signal = isRequest(input3) ? input3.signal : null;
     if ("signal" in init3) signal = init3.signal;
     if (signal != null && !isAbortSignal(signal)) {
       throw new TypeError("Expected signal to be an instanceof AbortSignal");
     }
     this[INTERNALS$2] = {
       method,
-      redirect: init3.redirect || input2.redirect || "follow",
+      redirect: init3.redirect || input3.redirect || "follow",
       headers,
       parsedURL,
       signal
     };
-    this.follow = init3.follow !== void 0 ? init3.follow : input2.follow !== void 0 ? input2.follow : 20;
-    this.compress = init3.compress !== void 0 ? init3.compress : input2.compress !== void 0 ? input2.compress : true;
-    this.counter = init3.counter || input2.counter || 0;
-    this.agent = init3.agent || input2.agent;
+    this.follow = init3.follow !== void 0 ? init3.follow : input3.follow !== void 0 ? input3.follow : 20;
+    this.compress = init3.compress !== void 0 ? init3.compress : input3.compress !== void 0 ? input3.compress : true;
+    this.counter = init3.counter || input3.counter || 0;
+    this.agent = init3.agent || input3.agent;
   }
   get method() {
     return this[INTERNALS$2].method;
@@ -87306,7 +87741,7 @@ var _parseJSON = (jsonString, allow) => {
   };
   return parseAny();
 };
-var partialParse = (input2) => parseJSON(input2, Allow.ALL ^ Allow.NUM);
+var partialParse = (input3) => parseJSON(input3, Allow.ALL ^ Allow.NUM);
 
 // ../../node_modules/.bun/openai@4.104.0+c05f8f6c4f18bd47/node_modules/openai/lib/ChatCompletionStream.mjs
 var __classPrivateFieldSet6 = function(receiver, state, value, kind2, f) {
@@ -90924,10 +91359,10 @@ function registerFaqMineCommands(program3) {
 // src/commands/faq/review.ts
 init_esm_shims();
 import { spawnSync } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir } from "os";
-import { join as join10 } from "path";
-import { confirm, select } from "@inquirer/prompts";
+import { join as join11 } from "path";
+import { confirm as confirm2, select as select2 } from "@inquirer/prompts";
 var COLORS2 = {
   reset: "\x1B[0m",
   green: "\x1B[32m",
@@ -90987,7 +91422,7 @@ function getEditor() {
 }
 function editInEditor(question, answer) {
   const editor = getEditor();
-  const tmpFile = join10(tmpdir(), `faq-edit-${Date.now()}.md`);
+  const tmpFile = join11(tmpdir(), `faq-edit-${Date.now()}.md`);
   const content = `# FAQ Edit
 
 ## Question
@@ -91012,7 +91447,7 @@ The sections are separated by "## Question" and "## Answer" headers.
       console.log(`${COLORS2.red}Editor exited with error${COLORS2.reset}`);
       return null;
     }
-    const edited = readFileSync6(tmpFile, "utf-8");
+    const edited = readFileSync7(tmpFile, "utf-8");
     const questionMatch = edited.match(
       /## Question\s*\n([\s\S]*?)(?=\n## Answer|$)/
     );
@@ -91030,7 +91465,7 @@ The sections are separated by "## Question" and "## Answer" headers.
       answer: editedAnswer
     };
   } finally {
-    if (existsSync8(tmpFile)) {
+    if (existsSync10(tmpFile)) {
       unlinkSync(tmpFile);
     }
   }
@@ -91060,7 +91495,7 @@ ${COLORS2.bold}\u{1F4CB} FAQ Review Session${COLORS2.reset}`);
   for (let i = 0; i < candidates.length; i++) {
     const candidate = candidates[i];
     displayCandidate(candidate, i, candidates.length);
-    const action = await select({
+    const action = await select2({
       message: "Action:",
       choices: [
         {
@@ -91132,7 +91567,7 @@ ${COLORS2.bold}New Question:${COLORS2.reset}`);
         console.log(`
 ${COLORS2.bold}New Answer:${COLORS2.reset}`);
         console.log(wordWrap(finalAnswer, 68));
-        const confirmPublish = await confirm({
+        const confirmPublish = await confirm2({
           message: "Publish edited FAQ?",
           default: true
         });
@@ -92365,7 +92800,7 @@ function registerReportCommand(front) {
 
 // src/commands/front/tags.ts
 init_esm_shims();
-import { confirm as confirm2 } from "@inquirer/prompts";
+import { confirm as confirm3 } from "@inquirer/prompts";
 
 // ../core/src/tags/audit.ts
 init_esm_shims();
@@ -92577,7 +93012,7 @@ async function deleteTag(id, options) {
           "   Deleting it will remove the tag from those conversations."
         );
       }
-      const confirmed = await confirm2({
+      const confirmed = await confirm3({
         message: `Are you sure you want to delete tag "${tag.name}"?`,
         default: false
       });
@@ -92885,7 +93320,7 @@ async function cleanupTags(options) {
       return;
     }
     console.log("");
-    const confirmed = await confirm2({
+    const confirmed = await confirm3({
       message: `Apply ${totalChanges} change(s)?`,
       default: false
     });
@@ -93761,8 +94196,8 @@ var EventResponseSchema = z7.object({
 var EventRunsResponseSchema = z7.object({
   data: z7.array(RunSchema).nullable()
 });
-function parseTimeArg(input2) {
-  const match = input2.match(/^(\d+)([hmd])$/);
+function parseTimeArg(input3) {
+  const match = input3.match(/^(\d+)([hmd])$/);
   if (match) {
     const [, num, unit] = match;
     const msPerUnit = {
@@ -93772,11 +94207,11 @@ function parseTimeArg(input2) {
     };
     const ms = unit ? msPerUnit[unit] : void 0;
     if (!ms || !num) {
-      return input2;
+      return input3;
     }
     return new Date(Date.now() - parseInt(num) * ms).toISOString();
   }
-  return input2;
+  return input3;
 }
 async function detectDevServer() {
   try {
@@ -94350,7 +94785,7 @@ function registerInvestigateCommands(inngest) {
 
 // src/commands/inngest/runs.ts
 init_esm_shims();
-import { confirm as confirm3 } from "@inquirer/prompts";
+import { confirm as confirm4 } from "@inquirer/prompts";
 import "commander";
 function formatRun(run3) {
   const startedAt = new Date(run3.run_started_at).toLocaleString();
@@ -94396,7 +94831,7 @@ async function cancelCommand(id, options) {
   try {
     const isDev = options.dev ?? await detectDevServer();
     if (!options.force) {
-      const confirmed = await confirm3({
+      const confirmed = await confirm4({
         message: `Cancel run ${id}?`,
         default: false
       });
@@ -94422,14 +94857,14 @@ function registerRunsCommands(inngest) {
 
 // src/commands/inngest/signal.ts
 init_esm_shims();
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import "commander";
 async function signalCommand(signal, options) {
   const { data: dataString, dataFile, dev = false, json = false } = options;
   let data2 = null;
   if (dataFile) {
     try {
-      const fileContent = readFileSync7(dataFile, "utf-8");
+      const fileContent = readFileSync8(dataFile, "utf-8");
       data2 = JSON.parse(fileContent);
     } catch (err) {
       const error = {
@@ -96585,22 +97020,22 @@ init_esm_shims();
 
 // ../../node_modules/.bun/entities@7.0.1/node_modules/entities/dist/esm/internal/decode-shared.js
 init_esm_shims();
-function decodeBase64(input2) {
+function decodeBase64(input3) {
   const binary = (
     // eslint-disable-next-line n/no-unsupported-features/node-builtins
     typeof atob === "function" ? (
       // Browser (and Node >=16)
       // eslint-disable-next-line n/no-unsupported-features/node-builtins
-      atob(input2)
+      atob(input3)
     ) : (
       // Older Node versions (<16)
       // eslint-disable-next-line n/no-unsupported-features/node-builtins
       typeof Buffer.from === "function" ? (
         // eslint-disable-next-line n/no-unsupported-features/node-builtins
-        Buffer.from(input2, "base64").toString("binary")
+        Buffer.from(input3, "base64").toString("binary")
       ) : (
         // eslint-disable-next-line unicorn/no-new-buffer, n/no-deprecated-api
-        new Buffer(input2, "base64").toString("binary")
+        new Buffer(input3, "base64").toString("binary")
       )
     )
   );
@@ -96708,28 +97143,28 @@ var EntityDecoder2 = class {
    * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  write(input2, offset) {
+  write(input3, offset) {
     switch (this.state) {
       case EntityDecoderState2.EntityStart: {
-        if (input2.charCodeAt(offset) === CharCodes2.NUM) {
+        if (input3.charCodeAt(offset) === CharCodes2.NUM) {
           this.state = EntityDecoderState2.NumericStart;
           this.consumed += 1;
-          return this.stateNumericStart(input2, offset + 1);
+          return this.stateNumericStart(input3, offset + 1);
         }
         this.state = EntityDecoderState2.NamedEntity;
-        return this.stateNamedEntity(input2, offset);
+        return this.stateNamedEntity(input3, offset);
       }
       case EntityDecoderState2.NumericStart: {
-        return this.stateNumericStart(input2, offset);
+        return this.stateNumericStart(input3, offset);
       }
       case EntityDecoderState2.NumericDecimal: {
-        return this.stateNumericDecimal(input2, offset);
+        return this.stateNumericDecimal(input3, offset);
       }
       case EntityDecoderState2.NumericHex: {
-        return this.stateNumericHex(input2, offset);
+        return this.stateNumericHex(input3, offset);
       }
       case EntityDecoderState2.NamedEntity: {
-        return this.stateNamedEntity(input2, offset);
+        return this.stateNamedEntity(input3, offset);
       }
     }
   }
@@ -96742,17 +97177,17 @@ var EntityDecoder2 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNumericStart(input2, offset) {
-    if (offset >= input2.length) {
+  stateNumericStart(input3, offset) {
+    if (offset >= input3.length) {
       return -1;
     }
-    if ((input2.charCodeAt(offset) | TO_LOWER_BIT2) === CharCodes2.LOWER_X) {
+    if ((input3.charCodeAt(offset) | TO_LOWER_BIT2) === CharCodes2.LOWER_X) {
       this.state = EntityDecoderState2.NumericHex;
       this.consumed += 1;
-      return this.stateNumericHex(input2, offset + 1);
+      return this.stateNumericHex(input3, offset + 1);
     }
     this.state = EntityDecoderState2.NumericDecimal;
-    return this.stateNumericDecimal(input2, offset);
+    return this.stateNumericDecimal(input3, offset);
   }
   /**
    * Parses a hexadecimal numeric entity.
@@ -96763,9 +97198,9 @@ var EntityDecoder2 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNumericHex(input2, offset) {
-    while (offset < input2.length) {
-      const char = input2.charCodeAt(offset);
+  stateNumericHex(input3, offset) {
+    while (offset < input3.length) {
+      const char = input3.charCodeAt(offset);
       if (isNumber2(char) || isHexadecimalCharacter2(char)) {
         const digit = char <= CharCodes2.NINE ? char - CharCodes2.ZERO : (char | TO_LOWER_BIT2) - CharCodes2.LOWER_A + 10;
         this.result = this.result * 16 + digit;
@@ -96786,9 +97221,9 @@ var EntityDecoder2 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNumericDecimal(input2, offset) {
-    while (offset < input2.length) {
-      const char = input2.charCodeAt(offset);
+  stateNumericDecimal(input3, offset) {
+    while (offset < input3.length) {
+      const char = input3.charCodeAt(offset);
       if (isNumber2(char)) {
         this.result = this.result * 10 + (char - CharCodes2.ZERO);
         this.consumed++;
@@ -96841,16 +97276,16 @@ var EntityDecoder2 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNamedEntity(input2, offset) {
+  stateNamedEntity(input3, offset) {
     const { decodeTree } = this;
     let current = decodeTree[this.treeIndex];
     let valueLength = (current & BinTrieFlags2.VALUE_LENGTH) >> 14;
-    while (offset < input2.length) {
+    while (offset < input3.length) {
       if (valueLength === 0 && (current & BinTrieFlags2.FLAG13) !== 0) {
         const runLength = (current & BinTrieFlags2.BRANCH_LENGTH) >> 7;
         if (this.runConsumed === 0) {
           const firstChar = current & BinTrieFlags2.JUMP_TABLE;
-          if (input2.charCodeAt(offset) !== firstChar) {
+          if (input3.charCodeAt(offset) !== firstChar) {
             return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
           }
           offset++;
@@ -96858,13 +97293,13 @@ var EntityDecoder2 = class {
           this.runConsumed++;
         }
         while (this.runConsumed < runLength) {
-          if (offset >= input2.length) {
+          if (offset >= input3.length) {
             return -1;
           }
           const charIndexInPacked = this.runConsumed - 1;
           const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
           const expectedChar = charIndexInPacked % 2 === 0 ? packedWord & 255 : packedWord >> 8 & 255;
-          if (input2.charCodeAt(offset) !== expectedChar) {
+          if (input3.charCodeAt(offset) !== expectedChar) {
             this.runConsumed = 0;
             return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
           }
@@ -96877,9 +97312,9 @@ var EntityDecoder2 = class {
         current = decodeTree[this.treeIndex];
         valueLength = (current & BinTrieFlags2.VALUE_LENGTH) >> 14;
       }
-      if (offset >= input2.length)
+      if (offset >= input3.length)
         break;
-      const char = input2.charCodeAt(offset);
+      const char = input3.charCodeAt(offset);
       if (char === CharCodes2.SEMI && valueLength !== 0 && (current & BinTrieFlags2.FLAG13) !== 0) {
         return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
       }
@@ -99886,7 +100321,7 @@ var compile3 = wrapCompile(compile2);
 var _compileUnsafe = wrapCompile(compileUnsafe);
 var _compileToken = wrapCompile(compileToken);
 function getSelectorFunc(searchFunc) {
-  return function select4(query, elements, options) {
+  return function select5(query, elements, options) {
     const opts = convertOptionFormats(options);
     if (typeof query !== "function") {
       query = compileUnsafe(query, opts, elements);
@@ -100073,7 +100508,7 @@ function filterBySelector(selector, elements, options) {
   }
   return findFilterElements(elements, selector, options, false, elements.length);
 }
-function select2(selector, root2, options = {}, limit2 = Infinity) {
+function select3(selector, root2, options = {}, limit2 = Infinity) {
   if (typeof selector === "function") {
     return find3(root2, selector);
   }
@@ -100178,7 +100613,7 @@ function _findBySelector(selector, limit2) {
     pseudos: this.options.pseudos,
     quirksMode: this.options.quirksMode
   };
-  return this._make(select2(selector, elems, options, limit2));
+  return this._make(select3(selector, elems, options, limit2));
 }
 function _getMatcher(matchMap) {
   return function(fn, ...postFns) {
@@ -101603,28 +102038,28 @@ var EntityDecoder3 = class {
    * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  write(input2, offset) {
+  write(input3, offset) {
     switch (this.state) {
       case EntityDecoderState3.EntityStart: {
-        if (input2.charCodeAt(offset) === CharCodes4.NUM) {
+        if (input3.charCodeAt(offset) === CharCodes4.NUM) {
           this.state = EntityDecoderState3.NumericStart;
           this.consumed += 1;
-          return this.stateNumericStart(input2, offset + 1);
+          return this.stateNumericStart(input3, offset + 1);
         }
         this.state = EntityDecoderState3.NamedEntity;
-        return this.stateNamedEntity(input2, offset);
+        return this.stateNamedEntity(input3, offset);
       }
       case EntityDecoderState3.NumericStart: {
-        return this.stateNumericStart(input2, offset);
+        return this.stateNumericStart(input3, offset);
       }
       case EntityDecoderState3.NumericDecimal: {
-        return this.stateNumericDecimal(input2, offset);
+        return this.stateNumericDecimal(input3, offset);
       }
       case EntityDecoderState3.NumericHex: {
-        return this.stateNumericHex(input2, offset);
+        return this.stateNumericHex(input3, offset);
       }
       case EntityDecoderState3.NamedEntity: {
-        return this.stateNamedEntity(input2, offset);
+        return this.stateNamedEntity(input3, offset);
       }
     }
   }
@@ -101637,22 +102072,22 @@ var EntityDecoder3 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNumericStart(input2, offset) {
-    if (offset >= input2.length) {
+  stateNumericStart(input3, offset) {
+    if (offset >= input3.length) {
       return -1;
     }
-    if ((input2.charCodeAt(offset) | TO_LOWER_BIT3) === CharCodes4.LOWER_X) {
+    if ((input3.charCodeAt(offset) | TO_LOWER_BIT3) === CharCodes4.LOWER_X) {
       this.state = EntityDecoderState3.NumericHex;
       this.consumed += 1;
-      return this.stateNumericHex(input2, offset + 1);
+      return this.stateNumericHex(input3, offset + 1);
     }
     this.state = EntityDecoderState3.NumericDecimal;
-    return this.stateNumericDecimal(input2, offset);
+    return this.stateNumericDecimal(input3, offset);
   }
-  addToNumericResult(input2, start, end2, base) {
+  addToNumericResult(input3, start, end2, base) {
     if (start !== end2) {
       const digitCount = end2 - start;
-      this.result = this.result * Math.pow(base, digitCount) + Number.parseInt(input2.substr(start, digitCount), base);
+      this.result = this.result * Math.pow(base, digitCount) + Number.parseInt(input3.substr(start, digitCount), base);
       this.consumed += digitCount;
     }
   }
@@ -101665,18 +102100,18 @@ var EntityDecoder3 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNumericHex(input2, offset) {
+  stateNumericHex(input3, offset) {
     const startIndex = offset;
-    while (offset < input2.length) {
-      const char = input2.charCodeAt(offset);
+    while (offset < input3.length) {
+      const char = input3.charCodeAt(offset);
       if (isNumber3(char) || isHexadecimalCharacter3(char)) {
         offset += 1;
       } else {
-        this.addToNumericResult(input2, startIndex, offset, 16);
+        this.addToNumericResult(input3, startIndex, offset, 16);
         return this.emitNumericEntity(char, 3);
       }
     }
-    this.addToNumericResult(input2, startIndex, offset, 16);
+    this.addToNumericResult(input3, startIndex, offset, 16);
     return -1;
   }
   /**
@@ -101688,18 +102123,18 @@ var EntityDecoder3 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNumericDecimal(input2, offset) {
+  stateNumericDecimal(input3, offset) {
     const startIndex = offset;
-    while (offset < input2.length) {
-      const char = input2.charCodeAt(offset);
+    while (offset < input3.length) {
+      const char = input3.charCodeAt(offset);
       if (isNumber3(char)) {
         offset += 1;
       } else {
-        this.addToNumericResult(input2, startIndex, offset, 10);
+        this.addToNumericResult(input3, startIndex, offset, 10);
         return this.emitNumericEntity(char, 2);
       }
     }
-    this.addToNumericResult(input2, startIndex, offset, 10);
+    this.addToNumericResult(input3, startIndex, offset, 10);
     return -1;
   }
   /**
@@ -101744,12 +102179,12 @@ var EntityDecoder3 = class {
    * @param offset The current offset.
    * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
    */
-  stateNamedEntity(input2, offset) {
+  stateNamedEntity(input3, offset) {
     const { decodeTree } = this;
     let current = decodeTree[this.treeIndex];
     let valueLength = (current & BinTrieFlags3.VALUE_LENGTH) >> 14;
-    for (; offset < input2.length; offset++, this.excess++) {
-      const char = input2.charCodeAt(offset);
+    for (; offset < input3.length; offset++, this.excess++) {
+      const char = input3.charCodeAt(offset);
       this.treeIndex = determineBranch3(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
       if (this.treeIndex < 0) {
         return this.result === 0 || // If we are parsing an attribute
@@ -108963,7 +109398,7 @@ var getCodePoint2 = (
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   String.prototype.codePointAt == null ? (c, index2) => (c.charCodeAt(index2) & 64512) === 55296 ? (c.charCodeAt(index2) - 55296) * 1024 + c.charCodeAt(index2 + 1) - 56320 + 65536 : c.charCodeAt(index2) : (
     // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-    (input2, index2) => input2.codePointAt(index2)
+    (input3, index2) => input3.codePointAt(index2)
   )
 );
 function getEscaper2(regex, map2) {
@@ -110149,19 +110584,19 @@ async function ingest(options) {
       }
       case "database": {
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        articles = inputArticles.map((input2, index2) => ({
-          id: `kb-${appId}-db-${index2}-${slugify4(input2.title)}`,
-          title: input2.title,
-          question: input2.question,
-          answer: input2.answer,
+        articles = inputArticles.map((input3, index2) => ({
+          id: `kb-${appId}-db-${index2}-${slugify4(input3.title)}`,
+          title: input3.title,
+          question: input3.question,
+          answer: input3.answer,
           appId,
           metadata: {
             source: defaultSource,
-            category: input2.category || defaultCategory,
+            category: input3.category || defaultCategory,
             created_at: now,
             updated_at: now,
-            tags: input2.tags || [],
-            trust_score: input2.trust_score ?? 1
+            tags: input3.tags || [],
+            trust_score: input3.trust_score ?? 1
           }
         }));
         break;
@@ -112295,7 +112730,7 @@ function registerToolsCommands(program3) {
 // src/commands/wizard.ts
 init_esm_shims();
 import { randomBytes as randomBytes2, randomUUID as randomUUID3 } from "crypto";
-import { checkbox, confirm as confirm4, input } from "@inquirer/prompts";
+import { checkbox, confirm as confirm5, input as input2 } from "@inquirer/prompts";
 var ALL_CAPABILITIES = [
   {
     value: "lookupUser",
@@ -112359,21 +112794,21 @@ async function wizard(options = {}) {
     console.log(
       "This will walk you through setting up a new app in the support platform.\n"
     );
-    const name = await input({
+    const name = await input2({
       message: 'App name (e.g., "Total TypeScript"):',
       validate: (v) => v.trim().length > 0 || "Name is required"
     });
     const suggestedSlug = slugify5(name);
-    const slug = await input({
+    const slug = await input2({
       message: "URL slug:",
       default: suggestedSlug,
       validate: (v) => /^[a-z0-9-]+$/.test(v) || "Slug must be lowercase alphanumeric with dashes"
     });
-    const frontInboxId = await input({
+    const frontInboxId = await input2({
       message: 'Front inbox ID (e.g., "inb_abc123"):',
       validate: (v) => v.startsWith("inb_") || "Must be a valid Front inbox ID (starts with inb_)"
     });
-    const integrationBaseUrl = await input({
+    const integrationBaseUrl = await input2({
       message: "Integration base URL (where SDK endpoints live):",
       default: `https://${slug}.com`,
       validate: (v) => {
@@ -112393,42 +112828,42 @@ async function wizard(options = {}) {
         checked: c.checked
       }))
     });
-    const useStripe = await confirm4({
+    const useStripe = await confirm5({
       message: "Enable Stripe Connect for refund processing?",
       default: true
     });
     let stripeAccountId;
     if (useStripe) {
-      stripeAccountId = await input({
+      stripeAccountId = await input2({
         message: 'Stripe Connect account ID (e.g., "acct_xxx") or leave blank to connect later:',
         default: ""
       }) || void 0;
     }
-    const useSlackEscalation = await confirm4({
+    const useSlackEscalation = await confirm5({
       message: "Configure Slack escalation channel?",
       default: false
     });
     let escalationSlackChannel;
     if (useSlackEscalation) {
-      escalationSlackChannel = await input({
+      escalationSlackChannel = await input2({
         message: 'Slack channel ID for escalations (e.g., "C0123456789"):',
         validate: (v) => v.startsWith("C") || "Must be a valid Slack channel ID"
       });
     }
-    const configureAutoApproval = await confirm4({
+    const configureAutoApproval = await confirm5({
       message: "Configure auto-approval thresholds? (default: 30 days refund, 14 days transfer)",
       default: false
     });
     let autoApproveRefundDays = 30;
     let autoApproveTransferDays = 14;
     if (configureAutoApproval) {
-      const refundDaysStr = await input({
+      const refundDaysStr = await input2({
         message: "Auto-approve refunds within X days of purchase:",
         default: "30",
         validate: (v) => !isNaN(parseInt(v)) && parseInt(v) >= 0 || "Must be a non-negative number"
       });
       autoApproveRefundDays = parseInt(refundDaysStr);
-      const transferDaysStr = await input({
+      const transferDaysStr = await input2({
         message: "Auto-approve transfers within X days of purchase:",
         default: "14",
         validate: (v) => !isNaN(parseInt(v)) && parseInt(v) >= 0 || "Must be a non-negative number"