xtrm-tools 0.5.36 → 0.5.37

package/cli/dist/index.cjs

@@ -1202,8 +1202,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path22 = require("path");
-    var fs22 = require("fs");
+    var path24 = require("path");
+    var fs24 = require("fs");
     var process19 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2197,7 +2197,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs22.existsSync(executableFile)) return;
+        if (fs24.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2215,11 +2215,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path22.resolve(baseDir, baseName);
-          if (fs22.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path22.extname(baseName))) return void 0;
+          const localBin = path24.resolve(baseDir, baseName);
+          if (fs24.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path24.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs22.existsSync(`${localBin}${ext}`)
+            (ext) => fs24.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2231,21 +2231,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs22.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs24.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path22.resolve(
-            path22.dirname(resolvedScriptPath),
+          executableDir = path24.resolve(
+            path24.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path22.basename(
+            const legacyName = path24.basename(
               this._scriptPath,
-              path22.extname(this._scriptPath)
+              path24.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2256,7 +2256,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path22.extname(executableFile));
+        launchWithNode = sourceExt.includes(path24.extname(executableFile));
         let proc;
         if (process19.platform !== "win32") {
           if (launchWithNode) {
@@ -3171,7 +3171,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path22.basename(filename, path22.extname(filename));
+        this._name = path24.basename(filename, path24.extname(filename));
         return this;
       }
       /**
@@ -3185,9 +3185,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path23) {
-        if (path23 === void 0) return this._executableDir;
-        this._executableDir = path23;
+      executableDir(path25) {
+        if (path25 === void 0) return this._executableDir;
+        this._executableDir = path25;
         return this;
       }
       /**
@@ -6053,7 +6053,7 @@ var require_dist = __commonJS({
         });
       };
     }
-    var prompts6 = require_prompts();
+    var prompts7 = require_prompts();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -6104,7 +6104,7 @@ var require_dist = __commonJS({
             var _question2 = question;
             name = _question2.name;
             type = _question2.type;
-            if (prompts6[type] === void 0) {
+            if (prompts7[type] === void 0) {
               throw new Error(`prompt type (${type}) is not defined`);
             }
             if (override2[question.name] !== void 0) {
@@ -6115,7 +6115,7 @@ var require_dist = __commonJS({
               }
             }
             try {
-              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts6[type](question);
+              answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : yield prompts7[type](question);
               answers[name] = answer = yield getFormattedAnswer(question, answer, true);
               quit = yield onSubmit(question, answer, answers);
             } catch (err) {
@@ -6147,7 +6147,7 @@ var require_dist = __commonJS({
     }
     module2.exports = Object.assign(prompt, {
       prompt,
-      prompts: prompts6,
+      prompts: prompts7,
       inject,
       override
     });
@@ -8234,7 +8234,7 @@ var require_prompts2 = __commonJS({
 var require_lib = __commonJS({
   "../node_modules/prompts/lib/index.js"(exports2, module2) {
     "use strict";
-    var prompts6 = require_prompts2();
+    var prompts7 = require_prompts2();
     var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
     var noop = () => {
     };
@@ -8266,7 +8266,7 @@ var require_lib = __commonJS({
           throw new Error("prompt message is required");
         }
         ({ name, type } = question);
-        if (prompts6[type] === void 0) {
+        if (prompts7[type] === void 0) {
           throw new Error(`prompt type (${type}) is not defined`);
         }
         if (override2[question.name] !== void 0) {
@@ -8277,7 +8277,7 @@ var require_lib = __commonJS({
           }
         }
         try {
-          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts6[type](question);
+          answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts7[type](question);
           answers[name] = answer = await getFormattedAnswer(question, answer, true);
           quit = await onSubmit(question, answer, answers);
         } catch (err) {
@@ -8300,7 +8300,7 @@ var require_lib = __commonJS({
     function override(answers) {
       prompt._override = Object.assign({}, answers);
     }
-    module2.exports = Object.assign(prompt, { prompt, prompts: prompts6, inject, override });
+    module2.exports = Object.assign(prompt, { prompt, prompts: prompts7, inject, override });
   }
 });
 
@@ -11639,54 +11639,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs22) {
+    function patch(fs24) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs22);
-      }
-      if (!fs22.lutimes) {
-        patchLutimes(fs22);
-      }
-      fs22.chown = chownFix(fs22.chown);
-      fs22.fchown = chownFix(fs22.fchown);
-      fs22.lchown = chownFix(fs22.lchown);
-      fs22.chmod = chmodFix(fs22.chmod);
-      fs22.fchmod = chmodFix(fs22.fchmod);
-      fs22.lchmod = chmodFix(fs22.lchmod);
-      fs22.chownSync = chownFixSync(fs22.chownSync);
-      fs22.fchownSync = chownFixSync(fs22.fchownSync);
-      fs22.lchownSync = chownFixSync(fs22.lchownSync);
-      fs22.chmodSync = chmodFixSync(fs22.chmodSync);
-      fs22.fchmodSync = chmodFixSync(fs22.fchmodSync);
-      fs22.lchmodSync = chmodFixSync(fs22.lchmodSync);
-      fs22.stat = statFix(fs22.stat);
-      fs22.fstat = statFix(fs22.fstat);
-      fs22.lstat = statFix(fs22.lstat);
-      fs22.statSync = statFixSync(fs22.statSync);
-      fs22.fstatSync = statFixSync(fs22.fstatSync);
-      fs22.lstatSync = statFixSync(fs22.lstatSync);
-      if (fs22.chmod && !fs22.lchmod) {
-        fs22.lchmod = function(path22, mode, cb) {
+        patchLchmod(fs24);
+      }
+      if (!fs24.lutimes) {
+        patchLutimes(fs24);
+      }
+      fs24.chown = chownFix(fs24.chown);
+      fs24.fchown = chownFix(fs24.fchown);
+      fs24.lchown = chownFix(fs24.lchown);
+      fs24.chmod = chmodFix(fs24.chmod);
+      fs24.fchmod = chmodFix(fs24.fchmod);
+      fs24.lchmod = chmodFix(fs24.lchmod);
+      fs24.chownSync = chownFixSync(fs24.chownSync);
+      fs24.fchownSync = chownFixSync(fs24.fchownSync);
+      fs24.lchownSync = chownFixSync(fs24.lchownSync);
+      fs24.chmodSync = chmodFixSync(fs24.chmodSync);
+      fs24.fchmodSync = chmodFixSync(fs24.fchmodSync);
+      fs24.lchmodSync = chmodFixSync(fs24.lchmodSync);
+      fs24.stat = statFix(fs24.stat);
+      fs24.fstat = statFix(fs24.fstat);
+      fs24.lstat = statFix(fs24.lstat);
+      fs24.statSync = statFixSync(fs24.statSync);
+      fs24.fstatSync = statFixSync(fs24.fstatSync);
+      fs24.lstatSync = statFixSync(fs24.lstatSync);
+      if (fs24.chmod && !fs24.lchmod) {
+        fs24.lchmod = function(path24, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs22.lchmodSync = function() {
+        fs24.lchmodSync = function() {
         };
       }
-      if (fs22.chown && !fs22.lchown) {
-        fs22.lchown = function(path22, uid, gid, cb) {
+      if (fs24.chown && !fs24.lchown) {
+        fs24.lchown = function(path24, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs22.lchownSync = function() {
+        fs24.lchownSync = function() {
         };
       }
       if (platform2 === "win32") {
-        fs22.rename = typeof fs22.rename !== "function" ? fs22.rename : (function(fs$rename) {
+        fs24.rename = typeof fs24.rename !== "function" ? fs24.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs22.stat(to, function(stater, st) {
+                  fs24.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -11702,9 +11702,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs22.rename);
+        })(fs24.rename);
       }
-      fs22.read = typeof fs22.read !== "function" ? fs22.read : (function(fs$read) {
+      fs24.read = typeof fs24.read !== "function" ? fs24.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -11712,22 +11712,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs22, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs24, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs22, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs24, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs22.read);
-      fs22.readSync = typeof fs22.readSync !== "function" ? fs22.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs24.read);
+      fs24.readSync = typeof fs24.readSync !== "function" ? fs24.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs22, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs24, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -11737,11 +11737,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs22.readSync);
-      function patchLchmod(fs23) {
-        fs23.lchmod = function(path22, mode, callback) {
-          fs23.open(
-            path22,
+      })(fs24.readSync);
+      function patchLchmod(fs25) {
+        fs25.lchmod = function(path24, mode, callback) {
+          fs25.open(
+            path24,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -11749,80 +11749,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs23.fchmod(fd, mode, function(err2) {
-                fs23.close(fd, function(err22) {
+              fs25.fchmod(fd, mode, function(err2) {
+                fs25.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs23.lchmodSync = function(path22, mode) {
-          var fd = fs23.openSync(path22, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs25.lchmodSync = function(path24, mode) {
+          var fd = fs25.openSync(path24, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs23.fchmodSync(fd, mode);
+            ret = fs25.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs23.closeSync(fd);
+                fs25.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs23.closeSync(fd);
+              fs25.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs23) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs23.futimes) {
-          fs23.lutimes = function(path22, at, mt, cb) {
-            fs23.open(path22, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs25) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs25.futimes) {
+          fs25.lutimes = function(path24, at, mt, cb) {
+            fs25.open(path24, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs23.futimes(fd, at, mt, function(er2) {
-                fs23.close(fd, function(er22) {
+              fs25.futimes(fd, at, mt, function(er2) {
+                fs25.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs23.lutimesSync = function(path22, at, mt) {
-            var fd = fs23.openSync(path22, constants.O_SYMLINK);
+          fs25.lutimesSync = function(path24, at, mt) {
+            var fd = fs25.openSync(path24, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs23.futimesSync(fd, at, mt);
+              ret = fs25.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs23.closeSync(fd);
+                  fs25.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs23.closeSync(fd);
+                fs25.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs23.futimes) {
-          fs23.lutimes = function(_a2, _b, _c, cb) {
+        } else if (fs25.futimes) {
+          fs25.lutimes = function(_a2, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs23.lutimesSync = function() {
+          fs25.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs22, target, mode, function(er) {
+          return orig.call(fs24, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -11832,7 +11832,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs22, target, mode);
+            return orig.call(fs24, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -11841,7 +11841,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs22, target, uid, gid, function(er) {
+          return orig.call(fs24, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -11851,7 +11851,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs22, target, uid, gid);
+            return orig.call(fs24, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -11871,13 +11871,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs22, target, options, callback) : orig.call(fs22, target, callback);
+          return options ? orig.call(fs24, target, options, callback) : orig.call(fs24, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs22, target, options) : orig.call(fs22, target);
+          var stats = options ? orig.call(fs24, target, options) : orig.call(fs24, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -11907,16 +11907,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs22) {
+    function legacy(fs24) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path22, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path22, options);
+      function ReadStream(path24, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path24, options);
         Stream.call(this);
         var self = this;
-        this.path = path22;
+        this.path = path24;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -11950,7 +11950,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs22.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs24.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -11961,10 +11961,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path22, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path22, options);
+      function WriteStream(path24, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path24, options);
         Stream.call(this);
-        this.path = path22;
+        this.path = path24;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -11989,7 +11989,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs22.open;
+          this._open = fs24.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -12025,7 +12025,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs22 = require("fs");
+    var fs24 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone3 = require_clone();
@@ -12057,12 +12057,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs22[gracefulQueue]) {
+    if (!fs24[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs22, queue);
-      fs22.close = (function(fs$close) {
+      publishQueue(fs24, queue);
+      fs24.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs22, fd, function(err) {
+          return fs$close.call(fs24, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -12074,48 +12074,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs22.close);
-      fs22.closeSync = (function(fs$closeSync) {
+      })(fs24.close);
+      fs24.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs22, arguments);
+          fs$closeSync.apply(fs24, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs22.closeSync);
+      })(fs24.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs22[gracefulQueue]);
-          require("assert").equal(fs22[gracefulQueue].length, 0);
+          debug(fs24[gracefulQueue]);
+          require("assert").equal(fs24[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs22[gracefulQueue]);
-    }
-    module2.exports = patch(clone3(fs22));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs22.__patched) {
-      module2.exports = patch(fs22);
-      fs22.__patched = true;
-    }
-    function patch(fs23) {
-      polyfills(fs23);
-      fs23.gracefulify = patch;
-      fs23.createReadStream = createReadStream;
-      fs23.createWriteStream = createWriteStream2;
-      var fs$readFile = fs23.readFile;
-      fs23.readFile = readFile;
-      function readFile(path22, options, cb) {
+      publishQueue(global, fs24[gracefulQueue]);
+    }
+    module2.exports = patch(clone3(fs24));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs24.__patched) {
+      module2.exports = patch(fs24);
+      fs24.__patched = true;
+    }
+    function patch(fs25) {
+      polyfills(fs25);
+      fs25.gracefulify = patch;
+      fs25.createReadStream = createReadStream;
+      fs25.createWriteStream = createWriteStream2;
+      var fs$readFile = fs25.readFile;
+      fs25.readFile = readFile;
+      function readFile(path24, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path22, options, cb);
-        function go$readFile(path23, options2, cb2, startTime) {
-          return fs$readFile(path23, options2, function(err) {
+        return go$readFile(path24, options, cb);
+        function go$readFile(path25, options2, cb2, startTime) {
+          return fs$readFile(path25, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path23, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path25, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12123,16 +12123,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs23.writeFile;
-      fs23.writeFile = writeFile;
-      function writeFile(path22, data, options, cb) {
+      var fs$writeFile = fs25.writeFile;
+      fs25.writeFile = writeFile;
+      function writeFile(path24, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path22, data, options, cb);
-        function go$writeFile(path23, data2, options2, cb2, startTime) {
-          return fs$writeFile(path23, data2, options2, function(err) {
+        return go$writeFile(path24, data, options, cb);
+        function go$writeFile(path25, data2, options2, cb2, startTime) {
+          return fs$writeFile(path25, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path23, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path25, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12140,17 +12140,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs23.appendFile;
+      var fs$appendFile = fs25.appendFile;
       if (fs$appendFile)
-        fs23.appendFile = appendFile;
-      function appendFile(path22, data, options, cb) {
+        fs25.appendFile = appendFile;
+      function appendFile(path24, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path22, data, options, cb);
-        function go$appendFile(path23, data2, options2, cb2, startTime) {
-          return fs$appendFile(path23, data2, options2, function(err) {
+        return go$appendFile(path24, data, options, cb);
+        function go$appendFile(path25, data2, options2, cb2, startTime) {
+          return fs$appendFile(path25, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path23, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path25, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12158,9 +12158,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs23.copyFile;
+      var fs$copyFile = fs25.copyFile;
       if (fs$copyFile)
-        fs23.copyFile = copyFile;
+        fs25.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -12178,34 +12178,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs23.readdir;
-      fs23.readdir = readdir;
+      var fs$readdir = fs25.readdir;
+      fs25.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path22, options, cb) {
+      function readdir(path24, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path23, options2, cb2, startTime) {
-          return fs$readdir(path23, fs$readdirCallback(
-            path23,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path25, options2, cb2, startTime) {
+          return fs$readdir(path25, fs$readdirCallback(
+            path25,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path23, options2, cb2, startTime) {
-          return fs$readdir(path23, options2, fs$readdirCallback(
-            path23,
+        } : function go$readdir2(path25, options2, cb2, startTime) {
+          return fs$readdir(path25, options2, fs$readdirCallback(
+            path25,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path22, options, cb);
-        function fs$readdirCallback(path23, options2, cb2, startTime) {
+        return go$readdir(path24, options, cb);
+        function fs$readdirCallback(path25, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path23, options2, cb2],
+                [path25, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -12220,21 +12220,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs23);
+        var legStreams = legacy(fs25);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs23.ReadStream;
+      var fs$ReadStream = fs25.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs23.WriteStream;
+      var fs$WriteStream = fs25.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs23, "ReadStream", {
+      Object.defineProperty(fs25, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -12244,7 +12244,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs23, "WriteStream", {
+      Object.defineProperty(fs25, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -12255,7 +12255,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs23, "FileReadStream", {
+      Object.defineProperty(fs25, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -12266,7 +12266,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs23, "FileWriteStream", {
+      Object.defineProperty(fs25, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -12276,7 +12276,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path22, options) {
+      function ReadStream(path24, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -12296,7 +12296,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path22, options) {
+      function WriteStream(path24, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -12314,22 +12314,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path22, options) {
-        return new fs23.ReadStream(path22, options);
+      function createReadStream(path24, options) {
+        return new fs25.ReadStream(path24, options);
       }
-      function createWriteStream2(path22, options) {
-        return new fs23.WriteStream(path22, options);
+      function createWriteStream2(path24, options) {
+        return new fs25.WriteStream(path24, options);
       }
-      var fs$open = fs23.open;
-      fs23.open = open;
-      function open(path22, flags, mode, cb) {
+      var fs$open = fs25.open;
+      fs25.open = open;
+      function open(path24, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path22, flags, mode, cb);
-        function go$open(path23, flags2, mode2, cb2, startTime) {
-          return fs$open(path23, flags2, mode2, function(err, fd) {
+        return go$open(path24, flags, mode, cb);
+        function go$open(path25, flags2, mode2, cb2, startTime) {
+          return fs$open(path25, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path23, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path25, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -12337,20 +12337,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs23;
+      return fs25;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs22[gracefulQueue].push(elem);
+      fs24[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs22[gracefulQueue].length; ++i) {
-        if (fs22[gracefulQueue][i].length > 2) {
-          fs22[gracefulQueue][i][3] = now;
-          fs22[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs24[gracefulQueue].length; ++i) {
+        if (fs24[gracefulQueue][i].length > 2) {
+          fs24[gracefulQueue][i][3] = now;
+          fs24[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -12358,9 +12358,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs22[gracefulQueue].length === 0)
+      if (fs24[gracefulQueue].length === 0)
         return;
-      var elem = fs22[gracefulQueue].shift();
+      var elem = fs24[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -12382,7 +12382,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs22[gracefulQueue].push(elem);
+          fs24[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -12397,7 +12397,7 @@ var require_fs = __commonJS({
   "../node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs22 = require_graceful_fs();
+    var fs24 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -12438,26 +12438,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs22[key] === "function";
+      return typeof fs24[key] === "function";
     });
-    Object.assign(exports2, fs22);
+    Object.assign(exports2, fs24);
     api.forEach((method) => {
-      exports2[method] = u(fs22[method]);
+      exports2[method] = u(fs24[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs22.exists(filename, callback);
+        return fs24.exists(filename, callback);
       }
       return new Promise((resolve2) => {
-        return fs22.exists(filename, resolve2);
+        return fs24.exists(filename, resolve2);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs22.read(fd, buffer, offset, length, position, callback);
+        return fs24.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve2, reject) => {
-        fs22.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs24.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffer: buffer2 });
         });
@@ -12465,10 +12465,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs22.write(fd, buffer, ...args);
+        return fs24.write(fd, buffer, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs22.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs24.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffer: buffer2 });
         });
@@ -12476,10 +12476,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs22.readv(fd, buffers, ...args);
+        return fs24.readv(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs22.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs24.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesRead, buffers: buffers2 });
         });
@@ -12487,17 +12487,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs22.writev(fd, buffers, ...args);
+        return fs24.writev(fd, buffers, ...args);
       }
       return new Promise((resolve2, reject) => {
-        fs22.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs24.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve2({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs22.realpath.native === "function") {
-      exports2.realpath.native = u(fs22.realpath.native);
+    if (typeof fs24.realpath.native === "function") {
+      exports2.realpath.native = u(fs24.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -12512,10 +12512,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path22 = require("path");
+    var path24 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path22.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path24.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error49 = new Error(`Path contains invalid characters: ${pth}`);
           error49.code = "EINVAL";
@@ -12530,7 +12530,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_fs();
+    var fs24 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -12539,14 +12539,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs22.mkdir(dir, {
+      return fs24.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs22.mkdirSync(dir, {
+      return fs24.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -12578,13 +12578,13 @@ var require_path_exists = __commonJS({
   "../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs22 = require_fs();
-    function pathExists(path22) {
-      return fs22.access(path22).then(() => true).catch(() => false);
+    var fs24 = require_fs();
+    function pathExists(path24) {
+      return fs24.access(path24).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs22.existsSync
+      pathExistsSync: fs24.existsSync
     };
   }
 });
@@ -12593,16 +12593,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_fs();
+    var fs24 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path22, atime, mtime) {
-      const fd = await fs22.open(path22, "r+");
+    async function utimesMillis(path24, atime, mtime) {
+      const fd = await fs24.open(path24, "r+");
       let closeErr = null;
       try {
-        await fs22.futimes(fd, atime, mtime);
+        await fs24.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs22.close(fd);
+          await fs24.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -12611,10 +12611,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path22, atime, mtime) {
-      const fd = fs22.openSync(path22, "r+");
-      fs22.futimesSync(fd, atime, mtime);
-      return fs22.closeSync(fd);
+    function utimesMillisSync(path24, atime, mtime) {
+      const fd = fs24.openSync(path24, "r+");
+      fs24.futimesSync(fd, atime, mtime);
+      return fs24.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -12627,11 +12627,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_fs();
-    var path22 = require("path");
+    var fs24 = require_fs();
+    var path24 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file2) => fs22.stat(file2, { bigint: true }) : (file2) => fs22.lstat(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs24.stat(file2, { bigint: true }) : (file2) => fs24.lstat(file2, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -12642,7 +12642,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file2) => fs22.statSync(file2, { bigint: true }) : (file2) => fs22.lstatSync(file2, { bigint: true });
+      const statFunc = opts.dereference ? (file2) => fs24.statSync(file2, { bigint: true }) : (file2) => fs24.lstatSync(file2, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -12656,8 +12656,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path22.basename(src);
-          const destBaseName = path22.basename(dest);
+          const srcBaseName = path24.basename(src);
+          const destBaseName = path24.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -12679,8 +12679,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path22.basename(src);
-          const destBaseName = path22.basename(dest);
+          const srcBaseName = path24.basename(src);
+          const destBaseName = path24.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -12699,12 +12699,12 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path22.resolve(path22.dirname(src));
-      const destParent = path22.resolve(path22.dirname(dest));
-      if (destParent === srcParent || destParent === path22.parse(destParent).root) return;
+      const srcParent = path24.resolve(path24.dirname(src));
+      const destParent = path24.resolve(path24.dirname(dest));
+      if (destParent === srcParent || destParent === path24.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs22.stat(destParent, { bigint: true });
+        destStat = await fs24.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -12715,12 +12715,12 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path22.resolve(path22.dirname(src));
-      const destParent = path22.resolve(path22.dirname(dest));
-      if (destParent === srcParent || destParent === path22.parse(destParent).root) return;
+      const srcParent = path24.resolve(path24.dirname(src));
+      const destParent = path24.resolve(path24.dirname(dest));
+      if (destParent === srcParent || destParent === path24.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs22.statSync(destParent, { bigint: true });
+        destStat = fs24.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -12734,8 +12734,8 @@ var require_stat = __commonJS({
       return destStat.ino !== void 0 && destStat.dev !== void 0 && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     function isSrcSubdir(src, dest) {
-      const srcArr = path22.resolve(src).split(path22.sep).filter((i) => i);
-      const destArr = path22.resolve(dest).split(path22.sep).filter((i) => i);
+      const srcArr = path24.resolve(src).split(path24.sep).filter((i) => i);
+      const destArr = path24.resolve(dest).split(path24.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -12787,8 +12787,8 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_fs();
-    var path22 = require("path");
+    var fs24 = require_fs();
+    var path24 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -12811,7 +12811,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path22.dirname(dest);
+      const destParent = path24.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -12823,7 +12823,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs22.stat : fs22.lstat;
+      const statFn = opts.dereference ? fs24.stat : fs24.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -12835,7 +12835,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs22.unlink(dest);
+        await fs24.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -12843,29 +12843,29 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs22.copyFile(src, dest);
+      await fs24.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs22.stat(src);
+        const updatedSrcStat = await fs24.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs22.chmod(dest, srcStat.mode);
+      return fs24.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs22.chmod(dest, srcMode | 128);
+      return fs24.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs22.mkdir(dest);
+        await fs24.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs22.opendir(src), async (item) => {
-        const srcItem = path22.join(src, item.name);
-        const destItem = path22.join(dest, item.name);
+      await asyncIteratorConcurrentProcess(await fs24.opendir(src), async (item) => {
+        const srcItem = path24.join(src, item.name);
+        const destItem = path24.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
           const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
@@ -12873,26 +12873,26 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs22.chmod(dest, srcStat.mode);
+        await fs24.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs22.readlink(src);
+      let resolvedSrc = await fs24.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path22.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs22.symlink(resolvedSrc, dest);
+        return fs24.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs22.readlink(dest);
+        resolvedDest = await fs24.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs22.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs24.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path22.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path24.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -12902,8 +12902,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs22.unlink(dest);
-      return fs22.symlink(resolvedSrc, dest);
+      await fs24.unlink(dest);
+      return fs24.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -12913,8 +12913,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_graceful_fs();
-    var path22 = require("path");
+    var fs24 = require_graceful_fs();
+    var path24 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -12935,12 +12935,12 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path22.dirname(dest);
-      if (!fs22.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path24.dirname(dest);
+      if (!fs24.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs22.statSync : fs22.lstatSync;
+      const statSync = opts.dereference ? fs24.statSync : fs24.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -12955,14 +12955,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs22.unlinkSync(dest);
+        fs24.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs22.copyFileSync(src, dest);
+      fs24.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -12977,10 +12977,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs22.chmodSync(dest, srcMode);
+      return fs24.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs22.statSync(src);
+      const updatedSrcStat = fs24.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -12988,12 +12988,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs22.mkdirSync(dest);
+      fs24.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs22.opendirSync(src);
+      const dir = fs24.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -13004,29 +13004,29 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path22.join(src, item);
-      const destItem = path22.join(dest, item);
+      const srcItem = path24.join(src, item);
+      const destItem = path24.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs22.readlinkSync(src);
+      let resolvedSrc = fs24.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path22.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path24.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs22.symlinkSync(resolvedSrc, dest);
+        return fs24.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs22.readlinkSync(dest);
+          resolvedDest = fs24.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs22.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs24.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path22.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path24.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
           if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
@@ -13040,8 +13040,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs22.unlinkSync(dest);
-      return fs22.symlinkSync(resolvedSrc, dest);
+      fs24.unlinkSync(dest);
+      return fs24.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -13063,13 +13063,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_graceful_fs();
+    var fs24 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path22, callback) {
-      fs22.rm(path22, { recursive: true, force: true }, callback);
+    function remove(path24, callback) {
+      fs24.rm(path24, { recursive: true, force: true }, callback);
     }
-    function removeSync(path22) {
-      fs22.rmSync(path22, { recursive: true, force: true });
+    function removeSync(path24) {
+      fs24.rmSync(path24, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -13083,28 +13083,28 @@ var require_empty = __commonJS({
   "../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs22 = require_fs();
-    var path22 = require("path");
+    var fs24 = require_fs();
+    var path24 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs22.readdir(dir);
+        items = await fs24.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path22.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path24.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs22.readdirSync(dir);
+        items = fs24.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path22.join(dir, item);
+        item = path24.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -13122,52 +13122,52 @@ var require_file = __commonJS({
   "../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path22 = require("path");
-    var fs22 = require_fs();
+    var path24 = require("path");
+    var fs24 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file2) {
       let stats;
       try {
-        stats = await fs22.stat(file2);
+        stats = await fs24.stat(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path22.dirname(file2);
+      const dir = path24.dirname(file2);
       let dirStats = null;
       try {
-        dirStats = await fs22.stat(dir);
+        dirStats = await fs24.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs22.writeFile(file2, "");
+          await fs24.writeFile(file2, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs22.writeFile(file2, "");
+        await fs24.writeFile(file2, "");
       } else {
-        await fs22.readdir(dir);
+        await fs24.readdir(dir);
       }
     }
     function createFileSync(file2) {
       let stats;
       try {
-        stats = fs22.statSync(file2);
+        stats = fs24.statSync(file2);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path22.dirname(file2);
+      const dir = path24.dirname(file2);
       try {
-        if (!fs22.statSync(dir).isDirectory()) {
-          fs22.readdirSync(dir);
+        if (!fs24.statSync(dir).isDirectory()) {
+          fs24.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs22.writeFileSync(file2, "");
+      fs24.writeFileSync(file2, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -13181,50 +13181,50 @@ var require_link = __commonJS({
   "../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path22 = require("path");
-    var fs22 = require_fs();
+    var path24 = require("path");
+    var fs24 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs22.lstat(dstpath);
+        dstStat = await fs24.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs22.lstat(srcpath);
+        srcStat = await fs24.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path22.dirname(dstpath);
+      const dir = path24.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs22.link(srcpath, dstpath);
+      await fs24.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs22.lstatSync(dstpath);
+        dstStat = fs24.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs22.lstatSync(srcpath);
+        const srcStat = fs24.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path22.dirname(dstpath);
-      const dirExists = fs22.existsSync(dir);
-      if (dirExists) return fs22.linkSync(srcpath, dstpath);
+      const dir = path24.dirname(dstpath);
+      const dirExists = fs24.existsSync(dir);
+      if (dirExists) return fs24.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs22.linkSync(srcpath, dstpath);
+      return fs24.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -13237,14 +13237,14 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path22 = require("path");
-    var fs22 = require_fs();
+    var path24 = require("path");
+    var fs24 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path22.isAbsolute(srcpath)) {
+      if (path24.isAbsolute(srcpath)) {
         try {
-          await fs22.lstat(srcpath);
+          await fs24.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -13254,8 +13254,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path22.dirname(dstpath);
-      const relativeToDst = path22.join(dstdir, srcpath);
+      const dstdir = path24.dirname(dstpath);
+      const relativeToDst = path24.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -13264,39 +13264,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs22.lstat(srcpath);
+        await fs24.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path22.relative(dstdir, srcpath)
+        toDst: path24.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path22.isAbsolute(srcpath)) {
-        const exists2 = fs22.existsSync(srcpath);
+      if (path24.isAbsolute(srcpath)) {
+        const exists2 = fs24.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path22.dirname(dstpath);
-      const relativeToDst = path22.join(dstdir, srcpath);
-      const exists = fs22.existsSync(relativeToDst);
+      const dstdir = path24.dirname(dstpath);
+      const relativeToDst = path24.join(dstdir, srcpath);
+      const exists = fs24.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs22.existsSync(srcpath);
+      const srcExists = fs24.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path22.relative(dstdir, srcpath)
+        toDst: path24.relative(dstdir, srcpath)
       };
     }
     module2.exports = {
@@ -13310,13 +13310,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_fs();
+    var fs24 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs22.lstat(srcpath);
+        stats = await fs24.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -13326,7 +13326,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs22.lstatSync(srcpath);
+        stats = fs24.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -13344,8 +13344,8 @@ var require_symlink = __commonJS({
   "../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path22 = require("path");
-    var fs22 = require_fs();
+    var path24 = require("path");
+    var fs24 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -13354,44 +13354,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs22.lstat(dstpath);
+        stats = await fs24.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs22.stat(srcpath),
-          fs22.stat(dstpath)
+          fs24.stat(srcpath),
+          fs24.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path22.dirname(dstpath);
+      const dir = path24.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs22.symlink(srcpath, dstpath, toType);
+      return fs24.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs22.lstatSync(dstpath);
+        stats = fs24.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs22.statSync(srcpath);
-        const dstStat = fs22.statSync(dstpath);
+        const srcStat = fs24.statSync(srcpath);
+        const dstStat = fs24.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path22.dirname(dstpath);
-      const exists = fs22.existsSync(dir);
-      if (exists) return fs22.symlinkSync(srcpath, dstpath, type);
+      const dir = path24.dirname(dstpath);
+      const exists = fs24.existsSync(dir);
+      if (exists) return fs24.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs22.symlinkSync(srcpath, dstpath, type);
+      return fs24.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -13460,9 +13460,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs22 = options.fs || _fs;
+      const fs24 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs22.readFile)(file2, options);
+      let data = await universalify.fromCallback(fs24.readFile)(file2, options);
       data = stripBom(data);
       let obj;
       try {
@@ -13478,14 +13478,14 @@ var require_jsonfile = __commonJS({
       return obj;
     }
     var readFile = universalify.fromPromise(_readFile);
-    function readFileSync3(file2, options = {}) {
+    function readFileSync4(file2, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs22 = options.fs || _fs;
+      const fs24 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs22.readFileSync(file2, options);
+        let content = fs24.readFileSync(file2, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -13498,19 +13498,19 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file2, obj, options = {}) {
-      const fs22 = options.fs || _fs;
+      const fs24 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs22.writeFile)(file2, str, options);
+      await universalify.fromCallback(fs24.writeFile)(file2, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync3(file2, obj, options = {}) {
-      const fs22 = options.fs || _fs;
+      const fs24 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs22.writeFileSync(file2, str, options);
+      return fs24.writeFileSync(file2, str, options);
     }
     module2.exports = {
       readFile,
-      readFileSync: readFileSync3,
+      readFileSync: readFileSync4,
       writeFile,
       writeFileSync: writeFileSync3
     };
@@ -13537,23 +13537,23 @@ var require_output_file = __commonJS({
   "../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs22 = require_fs();
-    var path22 = require("path");
+    var fs24 = require_fs();
+    var path24 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file2, data, encoding = "utf-8") {
-      const dir = path22.dirname(file2);
+      const dir = path24.dirname(file2);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs22.writeFile(file2, data, encoding);
+      return fs24.writeFile(file2, data, encoding);
     }
     function outputFileSync(file2, ...args) {
-      const dir = path22.dirname(file2);
-      if (!fs22.existsSync(dir)) {
+      const dir = path24.dirname(file2);
+      if (!fs24.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs22.writeFileSync(file2, ...args);
+      fs24.writeFileSync(file2, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -13612,8 +13612,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_fs();
-    var path22 = require("path");
+    var fs24 = require_fs();
+    var path24 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -13623,8 +13623,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
       await stat.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path22.dirname(dest);
-      const parsedParentPath = path22.parse(destParent);
+      const destParent = path24.dirname(dest);
+      const parsedParentPath = path24.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -13639,7 +13639,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs22.rename(src, dest);
+        await fs24.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -13664,8 +13664,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs22 = require_graceful_fs();
-    var path22 = require("path");
+    var fs24 = require_graceful_fs();
+    var path24 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -13675,12 +13675,12 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path22.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path24.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path22.dirname(dest);
-      const parsedPath = path22.parse(parent);
+      const parent = path24.dirname(dest);
+      const parsedPath = path24.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -13689,12 +13689,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs22.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs24.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs22.renameSync(src, dest);
+        fs24.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -15255,7 +15255,7 @@ var require_dataType = __commonJS({
     exports2.coerceAndCheckDataType = coerceAndCheckDataType;
     var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
     function coerceToTypes(types, coerceTypes) {
-      return coerceTypes ? types.filter((t3) => COERCIBLE.has(t3) || coerceTypes === "array" && t3 === "array") : [];
+      return coerceTypes ? types.filter((t2) => COERCIBLE.has(t2) || coerceTypes === "array" && t2 === "array") : [];
     }
     function coerceData(it, types, coerceTo) {
       const { gen, data, opts } = it;
@@ -15265,9 +15265,9 @@ var require_dataType = __commonJS({
         gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
       }
       gen.if((0, codegen_1._)`${coerced} !== undefined`);
-      for (const t3 of coerceTo) {
-        if (COERCIBLE.has(t3) || t3 === "array" && opts.coerceTypes === "array") {
-          coerceSpecificType(t3);
+      for (const t2 of coerceTo) {
+        if (COERCIBLE.has(t2) || t2 === "array" && opts.coerceTypes === "array") {
+          coerceSpecificType(t2);
         }
       }
       gen.else();
@@ -15277,8 +15277,8 @@ var require_dataType = __commonJS({
         gen.assign(data, coerced);
         assignParentData(it, coerced);
       });
-      function coerceSpecificType(t3) {
-        switch (t3) {
+      function coerceSpecificType(t2) {
+        switch (t2) {
           case "string":
             gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
             return;
@@ -15350,8 +15350,8 @@ var require_dataType = __commonJS({
       }
       if (types.number)
         delete types.integer;
-      for (const t3 in types)
-        cond = (0, codegen_1.and)(cond, checkDataType(t3, data, strictNums, correct));
+      for (const t2 in types)
+        cond = (0, codegen_1.and)(cond, checkDataType(t2, data, strictNums, correct));
       return cond;
     }
     exports2.checkDataTypes = checkDataTypes;
@@ -16266,9 +16266,9 @@ var require_validate = __commonJS({
         it.dataTypes = types;
         return;
       }
-      types.forEach((t3) => {
-        if (!includesType(it.dataTypes, t3)) {
-          strictTypesError(it, `type "${t3}" not allowed by context "${it.dataTypes.join(",")}"`);
+      types.forEach((t2) => {
+        if (!includesType(it.dataTypes, t2)) {
+          strictTypesError(it, `type "${t2}" not allowed by context "${it.dataTypes.join(",")}"`);
         }
       });
       narrowSchemaTypes(it, types);
@@ -16284,7 +16284,7 @@ var require_validate = __commonJS({
         const rule = rules[keyword];
         if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
           const { type } = rule.definition;
-          if (type.length && !type.some((t3) => hasApplicableType(ts, t3))) {
+          if (type.length && !type.some((t2) => hasApplicableType(ts, t2))) {
             strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
           }
         }
@@ -16293,15 +16293,15 @@ var require_validate = __commonJS({
     function hasApplicableType(schTs, kwdT) {
       return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
     }
-    function includesType(ts, t3) {
-      return ts.includes(t3) || t3 === "integer" && ts.includes("number");
+    function includesType(ts, t2) {
+      return ts.includes(t2) || t2 === "integer" && ts.includes("number");
     }
     function narrowSchemaTypes(it, withTypes) {
       const ts = [];
-      for (const t3 of it.dataTypes) {
-        if (includesType(withTypes, t3))
-          ts.push(t3);
-        else if (withTypes.includes("integer") && t3 === "number")
+      for (const t2 of it.dataTypes) {
+        if (includesType(withTypes, t2))
+          ts.push(t2);
+        else if (withTypes.includes("integer") && t2 === "number")
           ts.push("integer");
       }
       it.dataTypes = ts;
@@ -16939,8 +16939,8 @@ var require_utils3 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path22) {
-      let input = path22;
+    function removeDotSegments(path24) {
+      let input = path24;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -17139,8 +17139,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path22, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path22 && path22 !== "/" ? path22 : void 0;
+        const [path24, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path24 && path24 !== "/" ? path24 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -17912,7 +17912,7 @@ var require_core = __commonJS({
           type: (0, dataType_1.getJSONTypes)(def.type),
           schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
         };
-        (0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t3) => addRule.call(this, k, definition, t3)));
+        (0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t2) => addRule.call(this, k, definition, t2)));
         return this;
       }
       getKeyword(keyword) {
@@ -18111,7 +18111,7 @@ var require_core = __commonJS({
       if (dataType && post)
         throw new Error('keyword with "post" flag cannot have "type"');
       const { RULES } = this;
-      let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t3 }) => t3 === dataType);
+      let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t2 }) => t2 === dataType);
       if (!ruleGroup) {
         ruleGroup = { type: dataType, rules: [] };
         RULES.rules.push(ruleGroup);
@@ -18659,7 +18659,7 @@ var require_uniqueItems = __commonJS({
           gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
         }
         function canOptimize() {
-          return itemTypes.length > 0 && !itemTypes.some((t3) => t3 === "object" || t3 === "array");
+          return itemTypes.length > 0 && !itemTypes.some((t2) => t2 === "object" || t2 === "array");
         }
         function loopN(i, j) {
           const item = gen.name("item");
@@ -20300,18 +20300,18 @@ var require_formats = __commonJS({
       const timeZone = matches[5];
       return (hour <= 23 && minute <= 59 && second <= 59 || hour === 23 && minute === 59 && second === 60) && (!withTimeZone || timeZone !== "");
     }
-    function compareTime(t1, t22) {
-      if (!(t1 && t22))
+    function compareTime(t1, t2) {
+      if (!(t1 && t2))
         return void 0;
       const a1 = TIME.exec(t1);
-      const a2 = TIME.exec(t22);
+      const a2 = TIME.exec(t2);
       if (!(a1 && a2))
         return void 0;
       t1 = a1[1] + a1[2] + a1[3] + (a1[4] || "");
-      t22 = a2[1] + a2[2] + a2[3] + (a2[4] || "");
-      if (t1 > t22)
+      t2 = a2[1] + a2[2] + a2[3] + (a2[4] || "");
+      if (t1 > t2)
         return 1;
-      if (t1 < t22)
+      if (t1 < t2)
         return -1;
       return 0;
     }
@@ -20324,11 +20324,11 @@ var require_formats = __commonJS({
       if (!(dt1 && dt2))
         return void 0;
       const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
-      const [d2, t22] = dt2.split(DATE_TIME_SEPARATOR);
+      const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
       const res = compareDate(d1, d2);
       if (res === void 0)
         return void 0;
-      return res || compareTime(t1, t22);
+      return res || compareTime(t1, t2);
     }
     var NOT_URI_FRAGMENT = /\/|:/;
     var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
@@ -20466,12 +20466,12 @@ var require_dist2 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs22, exportName) {
+    function addFormats(ajv, list, fs24, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = codegen_1._`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs22[f]);
+        ajv.addFormat(f, fs24[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -20536,7 +20536,7 @@ var require_re = __commonJS({
     var safeRe = exports2.safeRe = [];
     var src = exports2.src = [];
     var safeSrc = exports2.safeSrc = [];
-    var t3 = exports2.t = {};
+    var t2 = exports2.t = {};
     var R = 0;
     var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
     var safeRegexReplacements = [
@@ -20554,7 +20554,7 @@ var require_re = __commonJS({
       const safe = makeSafeRegex(value);
       const index = R++;
       debug(name, index, value);
-      t3[name] = index;
+      t2[name] = index;
       src[index] = value;
       safeSrc[index] = safe;
       re[index] = new RegExp(value, isGlobal ? "g" : void 0);
@@ -20563,46 +20563,46 @@ var require_re = __commonJS({
     createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
     createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
     createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
-    createToken("MAINVERSION", `(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})`);
-    createToken("MAINVERSIONLOOSE", `(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASEIDENTIFIER", `(?:${src[t3.NONNUMERICIDENTIFIER]}|${src[t3.NUMERICIDENTIFIER]})`);
-    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t3.NONNUMERICIDENTIFIER]}|${src[t3.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASE", `(?:-(${src[t3.PRERELEASEIDENTIFIER]}(?:\\.${src[t3.PRERELEASEIDENTIFIER]})*))`);
-    createToken("PRERELEASELOOSE", `(?:-?(${src[t3.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t3.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
     createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
-    createToken("BUILD", `(?:\\+(${src[t3.BUILDIDENTIFIER]}(?:\\.${src[t3.BUILDIDENTIFIER]})*))`);
-    createToken("FULLPLAIN", `v?${src[t3.MAINVERSION]}${src[t3.PRERELEASE]}?${src[t3.BUILD]}?`);
-    createToken("FULL", `^${src[t3.FULLPLAIN]}$`);
-    createToken("LOOSEPLAIN", `[v=\\s]*${src[t3.MAINVERSIONLOOSE]}${src[t3.PRERELEASELOOSE]}?${src[t3.BUILD]}?`);
-    createToken("LOOSE", `^${src[t3.LOOSEPLAIN]}$`);
+    createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`);
+    createToken("FULL", `^${src[t2.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`);
+    createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`);
     createToken("GTLT", "((?:<|>)?=?)");
-    createToken("XRANGEIDENTIFIERLOOSE", `${src[t3.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-    createToken("XRANGEIDENTIFIER", `${src[t3.NUMERICIDENTIFIER]}|x|X|\\*`);
-    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:${src[t3.PRERELEASE]})?${src[t3.BUILD]}?)?)?`);
-    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:${src[t3.PRERELEASELOOSE]})?${src[t3.BUILD]}?)?)?`);
-    createToken("XRANGE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAIN]}$`);
-    createToken("XRANGELOOSE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAINLOOSE]}$`);
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`);
     createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
-    createToken("COERCE", `${src[t3.COERCEPLAIN]}(?:$|[^\\d])`);
-    createToken("COERCEFULL", src[t3.COERCEPLAIN] + `(?:${src[t3.PRERELEASE]})?(?:${src[t3.BUILD]})?(?:$|[^\\d])`);
-    createToken("COERCERTL", src[t3.COERCE], true);
-    createToken("COERCERTLFULL", src[t3.COERCEFULL], true);
+    createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t2.COERCE], true);
+    createToken("COERCERTLFULL", src[t2.COERCEFULL], true);
     createToken("LONETILDE", "(?:~>?)");
-    createToken("TILDETRIM", `(\\s*)${src[t3.LONETILDE]}\\s+`, true);
+    createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
     exports2.tildeTrimReplace = "$1~";
-    createToken("TILDE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAIN]}$`);
-    createToken("TILDELOOSE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAINLOOSE]}$`);
+    createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
     createToken("LONECARET", "(?:\\^)");
-    createToken("CARETTRIM", `(\\s*)${src[t3.LONECARET]}\\s+`, true);
+    createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true);
     exports2.caretTrimReplace = "$1^";
-    createToken("CARET", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAIN]}$`);
-    createToken("CARETLOOSE", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAINLOOSE]}$`);
-    createToken("COMPARATORLOOSE", `^${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]})$|^$`);
-    createToken("COMPARATOR", `^${src[t3.GTLT]}\\s*(${src[t3.FULLPLAIN]})$|^$`);
-    createToken("COMPARATORTRIM", `(\\s*)${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]}|${src[t3.XRANGEPLAIN]})`, true);
+    createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true);
     exports2.comparatorTrimReplace = "$1$2$3";
-    createToken("HYPHENRANGE", `^\\s*(${src[t3.XRANGEPLAIN]})\\s+-\\s+(${src[t3.XRANGEPLAIN]})\\s*$`);
-    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t3.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t3.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`);
     createToken("STAR", "(<|>)?=?\\s*\\*");
     createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
     createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
@@ -20659,7 +20659,7 @@ var require_semver = __commonJS({
     "use strict";
     var debug = require_debug();
     var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
-    var { safeRe: re, t: t3 } = require_re();
+    var { safeRe: re, t: t2 } = require_re();
     var parseOptions = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
     var SemVer = class _SemVer {
@@ -20683,7 +20683,7 @@ var require_semver = __commonJS({
         this.options = options;
         this.loose = !!options.loose;
         this.includePrerelease = !!options.includePrerelease;
-        const m = version3.trim().match(options.loose ? re[t3.LOOSE] : re[t3.FULL]);
+        const m = version3.trim().match(options.loose ? re[t2.LOOSE] : re[t2.FULL]);
         if (!m) {
           throw new TypeError(`Invalid Version: ${version3}`);
         }
@@ -20822,7 +20822,7 @@ var require_semver = __commonJS({
             throw new Error("invalid increment argument: identifier is empty");
           }
           if (identifier) {
-            const match = `-${identifier}`.match(this.options.loose ? re[t3.PRERELEASELOOSE] : re[t3.PRERELEASE]);
+            const match = `-${identifier}`.match(this.options.loose ? re[t2.PRERELEASELOOSE] : re[t2.PRERELEASE]);
             if (!match || match[1] !== identifier) {
               throw new Error(`invalid identifier: ${identifier}`);
             }
@@ -21271,7 +21271,7 @@ var require_coerce = __commonJS({
     "use strict";
     var SemVer = require_semver();
     var parse4 = require_parse();
-    var { safeRe: re, t: t3 } = require_re();
+    var { safeRe: re, t: t2 } = require_re();
     var coerce = (version3, options) => {
       if (version3 instanceof SemVer) {
         return version3;
@@ -21285,9 +21285,9 @@ var require_coerce = __commonJS({
       options = options || {};
       let match = null;
       if (!options.rtl) {
-        match = version3.match(options.includePrerelease ? re[t3.COERCEFULL] : re[t3.COERCE]);
+        match = version3.match(options.includePrerelease ? re[t2.COERCEFULL] : re[t2.COERCE]);
       } else {
-        const coerceRtlRegex = options.includePrerelease ? re[t3.COERCERTLFULL] : re[t3.COERCERTL];
+        const coerceRtlRegex = options.includePrerelease ? re[t2.COERCERTLFULL] : re[t2.COERCERTL];
         let next;
         while ((next = coerceRtlRegex.exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
           if (!match || next.index + next[0].length !== match.index + match[0].length) {
@@ -21426,20 +21426,20 @@ var require_range = __commonJS({
           return cached2;
         }
         const loose = this.options.loose;
-        const hr = loose ? re[t3.HYPHENRANGELOOSE] : re[t3.HYPHENRANGE];
+        const hr = loose ? re[t2.HYPHENRANGELOOSE] : re[t2.HYPHENRANGE];
         range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
         debug("hyphen replace", range);
-        range = range.replace(re[t3.COMPARATORTRIM], comparatorTrimReplace);
+        range = range.replace(re[t2.COMPARATORTRIM], comparatorTrimReplace);
         debug("comparator trim", range);
-        range = range.replace(re[t3.TILDETRIM], tildeTrimReplace);
+        range = range.replace(re[t2.TILDETRIM], tildeTrimReplace);
         debug("tilde trim", range);
-        range = range.replace(re[t3.CARETTRIM], caretTrimReplace);
+        range = range.replace(re[t2.CARETTRIM], caretTrimReplace);
         debug("caret trim", range);
         let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
         if (loose) {
           rangeList = rangeList.filter((comp) => {
             debug("loose invalid filter", comp, this.options);
-            return !!comp.match(re[t3.COMPARATORLOOSE]);
+            return !!comp.match(re[t2.COMPARATORLOOSE]);
           });
         }
         debug("range list", rangeList);
@@ -21501,7 +21501,7 @@ var require_range = __commonJS({
     var SemVer = require_semver();
     var {
       safeRe: re,
-      t: t3,
+      t: t2,
       comparatorTrimReplace,
       tildeTrimReplace,
       caretTrimReplace
@@ -21522,7 +21522,7 @@ var require_range = __commonJS({
       return result;
     };
     var parseComparator = (comp, options) => {
-      comp = comp.replace(re[t3.BUILD], "");
+      comp = comp.replace(re[t2.BUILD], "");
       debug("comp", comp, options);
       comp = replaceCarets(comp, options);
       debug("caret", comp);
@@ -21539,7 +21539,7 @@ var require_range = __commonJS({
       return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
     };
     var replaceTilde = (comp, options) => {
-      const r = options.loose ? re[t3.TILDELOOSE] : re[t3.TILDE];
+      const r = options.loose ? re[t2.TILDELOOSE] : re[t2.TILDE];
       return comp.replace(r, (_, M, m, p, pr) => {
         debug("tilde", comp, _, M, m, p, pr);
         let ret;
@@ -21564,7 +21564,7 @@ var require_range = __commonJS({
     };
     var replaceCaret = (comp, options) => {
       debug("caret", comp, options);
-      const r = options.loose ? re[t3.CARETLOOSE] : re[t3.CARET];
+      const r = options.loose ? re[t2.CARETLOOSE] : re[t2.CARET];
       const z2 = options.includePrerelease ? "-0" : "";
       return comp.replace(r, (_, M, m, p, pr) => {
         debug("caret", comp, _, M, m, p, pr);
@@ -21612,7 +21612,7 @@ var require_range = __commonJS({
     };
     var replaceXRange = (comp, options) => {
       comp = comp.trim();
-      const r = options.loose ? re[t3.XRANGELOOSE] : re[t3.XRANGE];
+      const r = options.loose ? re[t2.XRANGELOOSE] : re[t2.XRANGE];
       return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
         debug("xRange", comp, ret, gtlt, M, m, p, pr);
         const xM = isX(M);
@@ -21667,11 +21667,11 @@ var require_range = __commonJS({
     };
     var replaceStars = (comp, options) => {
       debug("replaceStars", comp, options);
-      return comp.trim().replace(re[t3.STAR], "");
+      return comp.trim().replace(re[t2.STAR], "");
     };
     var replaceGTE0 = (comp, options) => {
       debug("replaceGTE0", comp, options);
-      return comp.trim().replace(re[options.includePrerelease ? t3.GTE0PRE : t3.GTE0], "");
+      return comp.trim().replace(re[options.includePrerelease ? t2.GTE0PRE : t2.GTE0], "");
     };
     var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
       if (isX(fM)) {
@@ -21757,7 +21757,7 @@ var require_comparator = __commonJS({
         debug("comp", this);
       }
       parse(comp) {
-        const r = this.options.loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
+        const r = this.options.loose ? re[t2.COMPARATORLOOSE] : re[t2.COMPARATOR];
         const m = comp.match(r);
         if (!m) {
           throw new TypeError(`Invalid comparator: ${comp}`);
@@ -21831,7 +21831,7 @@ var require_comparator = __commonJS({
     };
     module2.exports = Comparator;
     var parseOptions = require_parse_options();
-    var { safeRe: re, t: t3 } = require_re();
+    var { safeRe: re, t: t2 } = require_re();
     var cmp = require_cmp();
     var debug = require_debug();
     var SemVer = require_semver();
@@ -24334,15 +24334,15 @@ var require_esprima = __commonJS({
                 return this.scanner.source.slice(token.start, token.end);
               };
               Parser2.prototype.convertToken = function(token) {
-                var t3 = {
+                var t2 = {
                   type: token_1.TokenName[token.type],
                   value: this.getTokenRaw(token)
                 };
                 if (this.config.range) {
-                  t3.range = [token.start, token.end];
+                  t2.range = [token.start, token.end];
                 }
                 if (this.config.loc) {
-                  t3.loc = {
+                  t2.loc = {
                     start: {
                       line: this.startMarker.line,
                       column: this.startMarker.column
@@ -24356,9 +24356,9 @@ var require_esprima = __commonJS({
                 if (token.type === 9) {
                   var pattern = token.pattern;
                   var flags = token.flags;
-                  t3.regex = { pattern, flags };
+                  t2.regex = { pattern, flags };
                 }
-                return t3;
+                return t2;
               };
               Parser2.prototype.nextToken = function() {
                 var token = this.lookahead;
@@ -28461,7 +28461,7 @@ var require_esprima = __commonJS({
                 this.values = [];
                 this.curly = this.paren = -1;
               }
-              Reader2.prototype.beforeFunctionExpression = function(t3) {
+              Reader2.prototype.beforeFunctionExpression = function(t2) {
                 return [
                   "(",
                   "{",
@@ -28519,7 +28519,7 @@ var require_esprima = __commonJS({
                   ">",
                   "!=",
                   "!=="
-                ].indexOf(t3) >= 0;
+                ].indexOf(t2) >= 0;
               };
               Reader2.prototype.isRegexStart = function() {
                 var previous = this.values[this.values.length - 1];
@@ -28746,18 +28746,18 @@ var require_src2 = __commonJS({
         }
         const al = log10(a);
         const bl = log10(b);
-        let t3 = 0;
+        let t2 = 0;
         if (al < bl) {
           a *= POWERS_OF_TEN[bl - al - 1];
           b /= 10;
-          t3 = -1;
+          t2 = -1;
         } else if (al > bl) {
           b *= POWERS_OF_TEN[al - bl - 1];
           a /= 10;
-          t3 = 1;
+          t2 = 1;
         }
         if (a === b) {
-          return t3;
+          return t2;
         }
         return a < b ? -1 : 1;
       }
@@ -28797,9 +28797,9 @@ var require_src2 = __commonJS({
     function reverseRun(array2, lo, hi) {
       hi--;
       while (lo < hi) {
-        const t3 = array2[lo];
+        const t2 = array2[lo];
         array2[lo++] = array2[hi];
-        array2[hi--] = t3;
+        array2[hi--] = t2;
       }
     }
     function binaryInsertionSort(array2, lo, hi, start, compare) {
@@ -30006,7 +30006,7 @@ var require_parse2 = __commonJS({
       }
       return current.type === "Punctuator" ? current.value : current.type;
     };
-    var is = (t3) => type() === t3;
+    var is = (t2) => type() === t2;
     var expect = (a) => {
       if (!is(a)) {
         unexpected();
@@ -31073,8 +31073,8 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
     "use strict";
-    var fs22 = require("fs");
-    var path22 = require("path");
+    var fs24 = require("fs");
+    var path24 = require("path");
     var os8 = require("os");
     var crypto2 = require("crypto");
     var packageJson = require_package();
@@ -31182,7 +31182,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs22.existsSync(filepath)) {
+            if (fs24.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -31190,15 +31190,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path22.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path24.resolve(process.cwd(), ".env.vault");
       }
-      if (fs22.existsSync(possibleVaultPath)) {
+      if (fs24.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path22.join(os8.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path24.join(os8.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -31215,7 +31215,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path22.resolve(process.cwd(), ".env");
+      const dotenvPath = path24.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       const quiet = options && "quiet" in options ? options.quiet : true;
@@ -31239,13 +31239,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path23 of optionPaths) {
+      for (const path25 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs22.readFileSync(path23, { encoding }));
+          const parsed = DotenvModule.parse(fs24.readFileSync(path25, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path23} ${e.message}`);
+            _debug(`Failed to load ${path25} ${e.message}`);
           }
           lastError = e;
         }
@@ -31260,7 +31260,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path22.relative(process.cwd(), filePath);
+            const relative = path24.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -34911,12 +34911,12 @@ var TestRendererSerializer = class {
       data
     };
     if (typeof this.options?.task !== "boolean") {
-      const t3 = Object.fromEntries(this.options.task.map((entity) => {
+      const t2 = Object.fromEntries(this.options.task.map((entity) => {
         const property = task[entity];
         if (typeof property === "function") return [entity, property.call(task)];
         return [entity, property];
       }));
-      if (Object.keys(task).length > 0) output.task = t3;
+      if (Object.keys(task).length > 0) output.task = t2;
     }
     return output;
   }
@@ -35773,12 +35773,12 @@ var disallowedKeys = /* @__PURE__ */ new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path22) {
+function getPathSegments(path24) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path22) {
+  for (const character of path24) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -35900,11 +35900,11 @@ function assertNotStringIndex(object2, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object2, path22, value) {
-  if (!isObject(object2) || typeof path22 !== "string") {
+function getProperty(object2, path24, value) {
+  if (!isObject(object2) || typeof path24 !== "string") {
     return value === void 0 ? object2 : value;
   }
-  const pathArray = getPathSegments(path22);
+  const pathArray = getPathSegments(path24);
   if (pathArray.length === 0) {
     return value;
   }
@@ -35924,12 +35924,12 @@ function getProperty(object2, path22, value) {
   }
   return object2 === void 0 ? value : object2;
 }
-function setProperty(object2, path22, value) {
-  if (!isObject(object2) || typeof path22 !== "string") {
+function setProperty(object2, path24, value) {
+  if (!isObject(object2) || typeof path24 !== "string") {
     return object2;
   }
   const root = object2;
-  const pathArray = getPathSegments(path22);
+  const pathArray = getPathSegments(path24);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object2, key);
@@ -35942,11 +35942,11 @@ function setProperty(object2, path22, value) {
   }
   return root;
 }
-function deleteProperty(object2, path22) {
-  if (!isObject(object2) || typeof path22 !== "string") {
+function deleteProperty(object2, path24) {
+  if (!isObject(object2) || typeof path24 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path22);
+  const pathArray = getPathSegments(path24);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object2, key);
@@ -35960,11 +35960,11 @@ function deleteProperty(object2, path22) {
     }
   }
 }
-function hasProperty(object2, path22) {
-  if (!isObject(object2) || typeof path22 !== "string") {
+function hasProperty(object2, path24) {
+  if (!isObject(object2) || typeof path24 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path22);
+  const pathArray = getPathSegments(path24);
   if (pathArray.length === 0) {
     return false;
   }
@@ -37133,8 +37133,8 @@ function detectAdapter(systemRoot) {
 // src/core/diff.ts
 var IGNORED_ITEMS = /* @__PURE__ */ new Set(["__pycache__", ".DS_Store", "Thumbs.db", ".gitkeep", "node_modules"]);
 var PruneModeReadError = class extends Error {
-  constructor(path22) {
-    super(`Cannot read ${path22} in prune mode \u2014 aborting to prevent accidental deletion`);
+  constructor(path24) {
+    super(`Cannot read ${path24} in prune mode \u2014 aborting to prevent accidental deletion`);
     this.name = "PruneModeReadError";
   }
 };
@@ -37365,7 +37365,7 @@ function mergeHookWrappers(existing, incoming) {
       if (!existingCommands.some((c) => incomingKeys.has(commandKey(c)))) return false;
       if (typeof existingWrapper2.matcher === "string" && typeof incomingWrapper.matcher === "string" && incomingTokens.size > 0) {
         const existingTokens = existingWrapper2.matcher.split("|").map((s) => s.trim()).filter(Boolean);
-        const hasOverlap = existingTokens.some((t3) => incomingTokens.has(t3));
+        const hasOverlap = existingTokens.some((t2) => incomingTokens.has(t2));
         if (!hasOverlap) return false;
       }
       return true;
@@ -40118,7 +40118,7 @@ async function handleMissingEnvVars(missing) {
   if (missing.length === 0) {
     return true;
   }
-  const prompts6 = (await Promise.resolve().then(() => __toESM(require_prompts3(), 1))).default;
+  const prompts7 = (await Promise.resolve().then(() => __toESM(require_prompts3(), 1))).default;
   const answers = {};
   for (const key of missing) {
     const config3 = REQUIRED_ENV_VARS[key];
@@ -40130,7 +40130,7 @@ async function handleMissingEnvVars(missing) {
       console.log(kleur_default.yellow(`
   \u26A0\uFE0F  ${key} is required by a selected MCP server`));
     }
-    const { value } = await prompts6({
+    const { value } = await prompts7({
       type: "text",
       name: "value",
       message: `Enter ${key}:`,
@@ -40343,8 +40343,8 @@ async function syncMcpServersWithCli(agent, mcpConfig, dryRun = false, prune = f
   }
   let selectedNames = toAdd.map(([name]) => name);
   if (!dryRun) {
-    const prompts6 = await Promise.resolve().then(() => __toESM(require_prompts3(), 1));
-    const { selected } = await prompts6.default({
+    const prompts7 = await Promise.resolve().then(() => __toESM(require_prompts3(), 1));
+    const { selected } = await prompts7.default({
       type: "multiselect",
       name: "selected",
       message: `Select MCP servers to install via ${agent} CLI:`,
@@ -40954,6 +40954,27 @@ function isPiInstalled() {
   const r = (0, import_node_child_process2.spawnSync)("pi", ["--version"], { encoding: "utf8", stdio: "pipe" });
   return r.status === 0;
 }
+function isPnpmInstalled() {
+  return (0, import_node_child_process2.spawnSync)("pnpm", ["--version"], { encoding: "utf8", stdio: "pipe" }).status === 0;
+}
+function ensurePnpm2(dryRun) {
+  if (isPnpmInstalled()) {
+    const v = (0, import_node_child_process2.spawnSync)("pnpm", ["--version"], { encoding: "utf8", stdio: "pipe" });
+    console.log(t.success(`  \u2713 pnpm ${v.stdout.trim()} already installed`));
+    return;
+  }
+  console.log(kleur_default.yellow("  pnpm not found \u2014 installing via npm..."));
+  if (dryRun) {
+    console.log(kleur_default.dim("  [DRY RUN] npm install -g pnpm"));
+    return;
+  }
+  const r = (0, import_node_child_process2.spawnSync)("npm", ["install", "-g", "pnpm"], { stdio: "inherit" });
+  if (r.status !== 0) {
+    console.log(kleur_default.yellow("  \u26A0 Failed to install pnpm. Run: npm install -g pnpm"));
+  } else {
+    console.log(t.success("  \u2713 pnpm installed"));
+  }
+}
 async function runPiInstall(dryRun = false) {
   const repoRoot = await findRepoRoot();
   const piConfigDir = import_path11.default.join(repoRoot, "config", "pi");
@@ -40975,6 +40996,7 @@ async function runPiInstall(dryRun = false) {
     const v = (0, import_node_child_process2.spawnSync)("pi", ["--version"], { encoding: "utf8" });
     console.log(t.success(`  \u2713 pi ${v.stdout.trim()} already installed`));
   }
+  ensurePnpm2(dryRun);
   let packages = [];
   if (await import_fs_extra11.default.pathExists(schemaPath)) {
     const schema = await import_fs_extra11.default.readJson(schemaPath);
@@ -41014,7 +41036,16 @@ async function runPiInstall(dryRun = false) {
       }
     }
   }
-  console.log("");
+  const configFiles = ["models.json", "auth.json", "settings.json"];
+  const missingConfig = configFiles.filter((f) => !require("fs").existsSync(import_path11.default.join(PI_AGENT_DIR, f)));
+  if (missingConfig.length > 0) {
+    console.log(kleur_default.yellow(`
+  \u26A0 Pi is not fully configured (missing: ${missingConfig.join(", ")})`));
+    console.log(kleur_default.yellow("    Run: xt pi setup   to complete first-time configuration"));
+    console.log(kleur_default.dim("    (API keys, model defaults, OAuth providers)\n"));
+  } else {
+    console.log("");
+  }
 }
 
 // src/commands/install.ts
@@ -41340,8 +41371,8 @@ function createInstallCommand() {
       createMissingDirs: !dryRun
     });
     const { targets, syncMode } = ctx;
-    const claudeTargets = targets.filter((t3) => detectAgent(t3) === "claude");
-    const otherTargets = targets.filter((t3) => detectAgent(t3) !== "claude");
+    const claudeTargets = targets.filter((t2) => detectAgent(t2) === "claude");
+    const otherTargets = targets.filter((t2) => detectAgent(t2) !== "claude");
     if (!backport) {
       console.log(t.bold("\n  \u2699  beads + dolt  (workflow enforcement backend)"));
       console.log(t.muted("  beads is a git-backed issue tracker; dolt is its SQL+git storage backend."));
@@ -41569,6 +41600,13 @@ function resolveStatuslineScript() {
   const fallback = import_node_path5.default.join((0, import_node_os5.homedir)(), ".claude", "hooks", "statusline.mjs");
   return (0, import_node_fs4.existsSync)(fallback) ? fallback : null;
 }
+function writeSessionMeta(worktreePath, runtime) {
+  try {
+    const meta3 = { runtime, launchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    (0, import_node_fs4.writeFileSync)(import_node_path5.default.join(worktreePath, ".session-meta.json"), JSON.stringify(meta3, null, 2));
+  } catch {
+  }
+}
 async function launchWorktreeSession(opts) {
   const { runtime, name } = opts;
   const cwd = process.cwd();
@@ -41608,6 +41646,7 @@ async function launchWorktreeSession(opts) {
       process.exit(1);
     }
   }
+  writeSessionMeta(worktreePath, runtime);
   console.log(kleur_default.green(`
   \u2713 Worktree ready \u2014 launching ${runtime}...
 `));
@@ -41804,6 +41843,8 @@ function createInstallPiCommand() {
       console.log(t.success(`  pi ${v.stdout.trim()} already installed
 `));
     }
+    console.log(t.bold("  pnpm\n"));
+    ensurePnpm();
     const schema = await import_fs_extra13.default.readJson(import_path13.default.join(piConfigDir, "install-schema.json"));
     const existing = readExistingPiValues(PI_AGENT_DIR2);
     const values = { ...existing };
@@ -43005,10 +43046,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path22) {
-  if (!path22)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path22.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -43085,8 +43126,8 @@ function numKeys(data) {
   return keyCount;
 }
 var getParsedType = (data) => {
-  const t3 = typeof data;
-  switch (t3) {
+  const t2 = typeof data;
+  switch (t2) {
     case "undefined":
       return "undefined";
     case "string":
@@ -43125,7 +43166,7 @@ var getParsedType = (data) => {
       }
       return "object";
     default:
-      throw new Error(`Unknown data type: ${t3}`);
+      throw new Error(`Unknown data type: ${t2}`);
   }
 };
 var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
@@ -43391,11 +43432,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path22, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path22);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -43432,8 +43473,8 @@ function getLengthableOrigin(input) {
   return "unknown";
 }
 function parsedType(data) {
-  const t3 = typeof data;
-  switch (t3) {
+  const t2 = typeof data;
+  switch (t2) {
     case "number": {
       return Number.isNaN(data) ? "nan" : "number";
     }
@@ -43450,7 +43491,7 @@ function parsedType(data) {
       }
     }
   }
-  return t3;
+  return t2;
 }
 function issue(...args) {
   const [iss, input, inst] = args;
@@ -43578,7 +43619,7 @@ function formatError(error49, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error49, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error50, path22 = []) => {
+  const processError = (error50, path24 = []) => {
     var _a2, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -43588,7 +43629,7 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path22, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -43620,8 +43661,8 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path22 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path22) {
+  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path24) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -45160,12 +45201,12 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
   const unrecognized = [];
   const keySet = def.keySet;
   const _catchall = def.catchall._zod;
-  const t3 = _catchall.def.type;
+  const t2 = _catchall.def.type;
   const isOptionalOut = _catchall.optout === "optional";
   for (const key in input) {
     if (keySet.has(key))
       continue;
-    if (t3 === "never") {
+    if (t2 === "never") {
       unrecognized.push(key);
       continue;
     }
@@ -48272,16 +48313,16 @@ var error17 = () => {
     number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
     // no unit
   };
-  const typeEntry = (t3) => t3 ? TypeNames[t3] : void 0;
-  const typeLabel = (t3) => {
-    const e = typeEntry(t3);
+  const typeEntry = (t2) => t2 ? TypeNames[t2] : void 0;
+  const typeLabel = (t2) => {
+    const e = typeEntry(t2);
     if (e)
       return e.label;
-    return t3 ?? TypeNames.unknown.label;
+    return t2 ?? TypeNames.unknown.label;
   };
-  const withDefinite = (t3) => `\u05D4${typeLabel(t3)}`;
-  const verbFor = (t3) => {
-    const e = typeEntry(t3);
+  const withDefinite = (t2) => `\u05D4${typeLabel(t2)}`;
+  const verbFor = (t2) => {
+    const e = typeEntry(t2);
     const gender = e?.gender ?? "m";
     return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
   };
@@ -55598,13 +55639,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path22 = ref.slice(1).split("/").filter(Boolean);
-  if (path22.length === 0) {
+  const path24 = ref.slice(1).split("/").filter(Boolean);
+  if (path24.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path22[0] === defsKey) {
-    const key = path22[1];
+  if (path24[0] === defsKey) {
+    const key = path24[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -55676,8 +55717,8 @@ function convertBaseSchema(schema, ctx) {
   }
   const type = schema.type;
   if (Array.isArray(type)) {
-    const typeSchemas = type.map((t3) => {
-      const typeSchema = { ...schema, type: t3 };
+    const typeSchemas = type.map((t2) => {
+      const typeSchema = { ...schema, type: t2 };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -56197,9 +56238,11 @@ function createHelpCommand() {
       "  1) Start a runtime session in a worktree:",
       "     xt claude [name]   or   xt pi [name]",
       "  2) Do your work in that worktree/branch.",
-      "  3) Finish with:",
+      "  3) If the session closes unexpectedly, re-attach:",
+      "     xt attach [slug]",
+      "  4) Finish with:",
       "     xt end",
-      "  4) Manage old worktrees when needed:",
+      "  5) Manage old worktrees when needed:",
       "     xt worktree list | xt worktree clean"
     ]));
     blocks.push(section("PRIMARY COMMANDS", [
@@ -56217,8 +56260,12 @@ function createHelpCommand() {
       "  xtrm init",
       "    Initialize project-level workflow setup.",
       "",
-      "  xtrm docs show [filter] [--raw] [--json]",
-      "    Show frontmatter for README/CHANGELOG/docs/*.md.",
+      "  xtrm docs --help",
+      "    Documentation inspection and drift-check submenu.",
+      "    Subcommands: show, list, cross-check",
+      "",
+      "  xtrm docs cross-check [--days <n>] [--json]",
+      "    Validate docs against recent PR activity and closed bd issues.",
       "",
       "  xtrm debug [options]",
       "    Stream xtrm event log (tool calls, gates, session/bd lifecycle).",
@@ -56246,8 +56293,14 @@ function createHelpCommand() {
       "  xt pi status | xt pi doctor | xt pi reload"
     ]));
     blocks.push(section("WORKTREE COMMANDS", [
+      "  xt attach [slug]",
+      "    Re-attach to an existing worktree and resume the Claude or Pi session.",
+      "    Picks the most recent worktree if no slug is given; shows a picker when",
+      "    multiple exist. Resumes with --continue (claude) or -c (pi).",
+      "",
       "  xt worktree list",
-      "    List active xt/* worktrees and merge status.",
+      "    List active xt/* worktrees with runtime, last activity, last commit, and",
+      "    a ready-to-run resume hint.",
       "  xt worktree clean [--yes/-y]",
       "    Remove worktrees already merged into main.",
       "  xt worktree remove <name> [--yes/-y]",
@@ -56261,7 +56314,8 @@ function createHelpCommand() {
     blocks.push(section("NOTES", [
       "  - Banner is shown only for xtrm install.",
       "  - For command-level details, run: xtrm <command> --help",
-      "  - For subcommand details, run: xtrm <command> <subcommand> --help"
+      "  - For subcommand details, run: xtrm <command> <subcommand> --help",
+      "  - For docs workflow details, run: xtrm docs --help"
     ]));
     process.stdout.write(blocks.join("\n"));
   });
@@ -56572,13 +56626,44 @@ function bd(args, cwd) {
   return { ok: r.status === 0, out: (r.stdout ?? "").trim() };
 }
 function extractIssueIds(commitLog) {
-  const matches = commitLog.matchAll(/\(([a-z0-9]+-[a-z0-9]+-[a-z0-9]+)\)/g);
-  return [...new Set([...matches].map((m) => m[1]))];
-}
-function buildPrTitle(issues) {
-  if (issues.length === 0) return "session changes";
-  if (issues.length === 1) return issues[0].reason || issues[0].title;
-  return `${issues[0].reason || issues[0].title} (+${issues.length - 1} more)`;
+  const matches = commitLog.matchAll(/\(([a-z0-9]+(?:-[a-z0-9]+)*(?:\.[0-9]+)?)\)/gi);
+  return [...new Set([...matches].map((m) => m[1].toLowerCase()))];
+}
+function normalizePrTitle(input) {
+  const trimmed = input.trim().replace(/[.\s]+$/g, "");
+  if (!trimmed) return "Update worktree session";
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+function isGenericPrTitle(title) {
+  return /^(session changes|update|updates|misc|wip|work in progress)$/i.test(title.trim());
+}
+function inferTitleFromChangedFiles(changedFiles) {
+  const hasDocsCrossCheck = changedFiles.some((f) => f.includes("docs-cross-check"));
+  const hasDocsCommand = changedFiles.some((f) => f === "cli/src/commands/docs.ts" || f === "cli/src/commands/help.ts");
+  const hasSyncDocsSkill = changedFiles.some((f) => f === "skills/sync-docs/SKILL.md");
+  const hasDocsPages = changedFiles.some((f) => f.startsWith("docs/") || f === "README.md" || f === "XTRM-GUIDE.md");
+  const hasTests = changedFiles.some((f) => f.startsWith("cli/test/"));
+  if (hasDocsCrossCheck && hasSyncDocsSkill) return "Add docs cross-check and integrate sync-docs workflow";
+  if (hasDocsCrossCheck && hasTests) return "Add docs cross-check command and tests";
+  if (hasDocsCommand && hasDocsPages && hasSyncDocsSkill) return "Integrate docs workflow across CLI, docs, and sync-docs";
+  if (hasDocsCommand && hasDocsPages) return "Update docs workflow and CLI help";
+  if (hasDocsPages) return "Update documentation";
+  return "Update worktree session";
+}
+function buildPrTitle(issues, changedFiles) {
+  if (issues.length === 0) return inferTitleFromChangedFiles(changedFiles);
+  if (issues.length === 1) {
+    const single = normalizePrTitle(issues[0].title || issues[0].reason || issues[0].id);
+    return isGenericPrTitle(single) ? inferTitleFromChangedFiles(changedFiles) : single;
+  }
+  const titles = issues.map((i) => `${i.title} ${i.reason}`.toLowerCase());
+  const hasCrossCheck = titles.some((t2) => t2.includes("cross-check"));
+  const hasSyncDocs = titles.some((t2) => t2.includes("sync-docs"));
+  const hasDocs = titles.some((t2) => t2.includes("docs"));
+  if (hasCrossCheck && hasSyncDocs) return "Add docs cross-check and integrate sync-docs workflow";
+  if (hasDocs) return "Update docs workflow and command surfaces";
+  const multi = normalizePrTitle(issues[0].title || issues[0].reason || issues[0].id);
+  return isGenericPrTitle(multi) ? inferTitleFromChangedFiles(changedFiles) : `${multi} (+${issues.length - 1} more)`;
 }
 function buildPrBody(issues, commitLog, diffStat, branch) {
   const lines = [];
@@ -56650,30 +56735,37 @@ function createEndCommand() {
     const issueIds = extractIssueIds(logResult.out);
     const issues = [];
     for (const id of issueIds) {
-      const showResult = bd(["show", id, "--json"], cwd);
-      if (showResult.ok) {
+      const queryResult = bd(["query", `id=${id}`, "--all", "--json"], cwd);
+      if (queryResult.ok) {
         try {
-          const data = JSON.parse(showResult.out);
-          issues.push({
-            id,
-            title: data.title ?? id,
-            description: data.description ?? "",
-            reason: data.close_reason ?? ""
-          });
+          const data = JSON.parse(queryResult.out);
+          const first = Array.isArray(data) ? data[0] : data;
+          if (first) {
+            issues.push({
+              id,
+              title: first.title ?? id,
+              description: first.description ?? "",
+              reason: first.close_reason ?? ""
+            });
+            continue;
+          }
         } catch {
-          issues.push({ id, title: id, description: "", reason: "" });
         }
       }
+      issues.push({ id, title: id, description: "", reason: "" });
     }
     if (issues.length > 0) {
       console.log(t.success(`  \u2713 Found ${issues.length} closed issue(s): ${issueIds.join(", ")}`));
+    } else if (issueIds.length > 0) {
+      console.log(kleur_default.yellow(`  \u26A0 Found issue references in commits but could not load bead details: ${issueIds.join(", ")}`));
     } else {
       console.log(kleur_default.dim("  \u25CB No beads issues found in commit log"));
     }
     if (opts.dryRun) {
       const fullLog2 = git(["log", `origin/${defaultBranch}..HEAD`, "--oneline"], cwd).out;
       const diffStat2 = git(["diff", `origin/${defaultBranch}`, "--stat"], cwd).out;
-      const prTitle2 = buildPrTitle(issues);
+      const changedFiles2 = git(["diff", `origin/${defaultBranch}`, "--name-only"], cwd).out.split("\n").filter(Boolean);
+      const prTitle2 = buildPrTitle(issues, changedFiles2);
       const prBody2 = buildPrBody(issues, fullLog2, diffStat2, branch);
       console.log(t.bold("\n  [DRY RUN] PR preview\n"));
       console.log(`  ${kleur_default.bold("Title:")} ${prTitle2}`);
@@ -56716,7 +56808,8 @@ function createEndCommand() {
     console.log(t.success(`  \u2713 Pushed ${branch}`));
     const fullLog = git(["log", `origin/${defaultBranch}..HEAD`, "--oneline"], cwd).out;
     const diffStat = git(["diff", `origin/${defaultBranch}`, "--stat"], cwd).out;
-    const prTitle = buildPrTitle(issues);
+    const changedFiles = git(["diff", `origin/${defaultBranch}`, "--name-only"], cwd).out.split("\n").filter(Boolean);
+    const prTitle = buildPrTitle(issues, changedFiles);
     const prBody = buildPrBody(issues, fullLog, diffStat, branch);
     console.log(kleur_default.dim("  Creating PR..."));
     const prArgs = ["pr", "create", "--title", prTitle, "--body", prBody];
@@ -56804,6 +56897,27 @@ function listXtWorktrees(repoRoot) {
   if (current.path && current.branch?.startsWith("refs/heads/xt/")) {
     worktrees.push(current);
   }
+  for (const wt of worktrees) {
+    try {
+      const raw = (0, import_node_fs5.readFileSync)((0, import_node_path6.join)(wt.path, ".session-meta.json"), "utf8");
+      const meta3 = JSON.parse(raw);
+      wt.runtime = meta3.runtime;
+      wt.launchedAt = meta3.launchedAt;
+    } catch {
+    }
+    const logR = (0, import_node_child_process8.spawnSync)("git", ["log", "-1", "--format=%ci%s", "HEAD"], {
+      cwd: wt.path,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    if (logR.status === 0 && logR.stdout.trim()) {
+      const sep = logR.stdout.trim().indexOf("");
+      if (sep !== -1) {
+        wt.lastLogTime = new Date(logR.stdout.slice(0, sep).trim());
+        wt.lastLogMsg = logR.stdout.slice(sep + 1).trim();
+      }
+    }
+  }
   return worktrees;
 }
 function isMergedIntoMain(branch, repoRoot) {
@@ -56833,13 +56947,19 @@ function createWorktreeCommand() {
 `));
     for (const wt of worktrees) {
       const branch = wt.branch.replace("refs/heads/", "");
+      const slug = branch.replace("xt/", "");
       const merged = isMergedIntoMain(wt.branch, repoRoot);
       const status = merged ? kleur_default.green("merged") : kleur_default.yellow("open");
       const prunable = wt.prunable ? kleur_default.dim(" [prunable]") : "";
-      console.log(`  ${status} ${kleur_default.bold(branch)}${prunable}`);
-      console.log(kleur_default.dim(`         ${wt.path}`));
+      const runtimeBadge = wt.runtime ? kleur_default.cyan(` [${wt.runtime}]`) : "";
+      const timeStr = wt.lastLogTime ? kleur_default.dim(wt.lastLogTime.toLocaleString()) : wt.launchedAt ? kleur_default.dim(new Date(wt.launchedAt).toLocaleString()) : "";
+      const logLine = wt.lastLogMsg ? kleur_default.dim(`  "${wt.lastLogMsg}"`) : "";
+      console.log(`  ${status}${runtimeBadge} ${kleur_default.bold(branch)}${prunable}`);
+      if (timeStr) console.log(`    last activity: ${timeStr}${logLine}`);
+      console.log(kleur_default.dim(`    path: ${wt.path}`));
+      console.log(kleur_default.dim(`    resume: xt attach ${slug}`));
+      console.log("");
     }
-    console.log("");
   });
   cmd.command("clean").description("Remove worktrees whose branch has been merged into main").option("-y, --yes", "Skip confirmation prompt", false).action(async (opts) => {
     const repoRoot = getRepoRoot(process.cwd());
@@ -56938,10 +57058,91 @@ function clearStatuslineClaim(repoRoot) {
   }
 }
 
+// src/commands/attach.ts
+var import_prompts6 = __toESM(require_prompts3(), 1);
+var import_node_child_process9 = require("child_process");
+function createAttachCommand() {
+  return new Command("attach").description("Re-attach to an existing xt worktree and resume the Claude or Pi session").argument("[name]", 'Worktree slug or branch name to attach to (e.g. "abc1" or "xt/abc1")').action(async (name) => {
+    const repoRoot = getRepoRoot(process.cwd());
+    const worktrees = listXtWorktrees(repoRoot);
+    if (worktrees.length === 0) {
+      console.log(kleur_default.dim("\n  No xt worktrees found \u2014 start one with: xt claude\n"));
+      return;
+    }
+    let target = worktrees[0];
+    if (name) {
+      const norm = name.startsWith("xt/") ? `refs/heads/${name}` : `refs/heads/xt/${name}`;
+      const found = worktrees.find(
+        (wt) => wt.path.endsWith(name) || wt.branch === norm || wt.branch === `refs/heads/${name}`
+      );
+      if (!found) {
+        console.error(kleur_default.red(`
+  \u2717 No xt worktree found matching "${name}"
+`));
+        console.log(kleur_default.dim("  Run: xt worktree list\n"));
+        process.exit(1);
+      }
+      target = found;
+    } else if (worktrees.length > 1) {
+      const choices = worktrees.map((wt) => {
+        const branch2 = wt.branch.replace("refs/heads/", "");
+        const slug = branch2.replace("xt/", "");
+        const runtime2 = wt.runtime ? ` [${wt.runtime}]` : "";
+        const time3 = wt.lastLogTime ? wt.lastLogTime.toLocaleString() : wt.launchedAt ? new Date(wt.launchedAt).toLocaleString() : "unknown";
+        const msg = wt.lastLogMsg ? `  "${wt.lastLogMsg.slice(0, 50)}"` : "";
+        return {
+          title: `${branch2}${runtime2}  \u2014  ${time3}${msg}`,
+          value: slug
+        };
+      });
+      const { picked } = await (0, import_prompts6.default)({
+        type: "select",
+        name: "picked",
+        message: "Select worktree to attach",
+        choices
+      });
+      if (!picked) {
+        console.log(kleur_default.dim("  Cancelled\n"));
+        return;
+      }
+      target = worktrees.find((wt) => wt.branch.endsWith(`/${picked}`)) ?? target;
+    }
+    const branch = target.branch.replace("refs/heads/", "");
+    const runtime = target.runtime ?? await pickRuntime();
+    const resumeArgs = runtime === "claude" ? ["--continue", "--dangerously-skip-permissions"] : ["-c"];
+    console.log(t.bold(`
+  Attaching to ${branch}`));
+    console.log(kleur_default.dim(`  runtime: ${runtime}  (resuming session)`));
+    console.log(kleur_default.dim(`  path:    ${target.path}
+`));
+    const result = (0, import_node_child_process9.spawnSync)(runtime, resumeArgs, {
+      cwd: target.path,
+      stdio: "inherit"
+    });
+    process.exit(result.status ?? 0);
+  });
+}
+async function pickRuntime() {
+  const { runtime } = await (0, import_prompts6.default)({
+    type: "select",
+    name: "runtime",
+    message: "No session metadata found \u2014 which runtime?",
+    choices: [
+      { title: "claude", value: "claude" },
+      { title: "pi", value: "pi" }
+    ],
+    initial: 0
+  });
+  return runtime ?? "claude";
+}
+
 // src/commands/docs.ts
+var import_fs_extra21 = __toESM(require_lib2(), 1);
+var import_path22 = __toESM(require("path"), 1);
+
+// src/utils/docs-scanner.ts
 var import_fs_extra19 = __toESM(require_lib2(), 1);
 var import_path20 = __toESM(require("path"), 1);
-var REQUIRED_FIELDS = /* @__PURE__ */ new Set(["title", "type", "status", "updated_at", "version"]);
 function parseFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return null;
@@ -56953,31 +57154,349 @@ function parseFrontmatter(content) {
     const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
     if (key) fm[key] = value;
   }
+  const afterFrontmatter = content.slice(match[0].length).replace(/^\r?\n/, "");
+  const firstPara = afterFrontmatter.split(/\r?\n\r?\n/)[0].replace(/\r?\n/g, " ").trim();
+  if (firstPara && !firstPara.startsWith("#")) {
+    fm.summary = firstPara.slice(0, 120);
+  }
   return fm;
 }
+var ALWAYS_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".xtrm"]);
+function parseGitignorePatterns(content) {
+  return content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+}
+function matchesGitignore(relativePath, patterns) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  const basename2 = normalized.split("/").pop() ?? "";
+  for (const raw of patterns) {
+    const p = raw.endsWith("/") ? raw.slice(0, -1) : raw;
+    if (p.includes("*")) {
+      const regex2 = new RegExp("^" + p.replace(/\./g, "\\.").replace(/\*/g, "[^/]*") + "$");
+      if (regex2.test(normalized) || regex2.test(basename2)) return true;
+    } else {
+      if (normalized === p || normalized.startsWith(p + "/") || basename2 === p) return true;
+    }
+  }
+  return false;
+}
+async function scanDocFiles(repoRoot, options = {}) {
+  const { dir, pattern, filter, recursive = true } = options;
+  let gitignorePatterns = [];
+  try {
+    const raw = await import_fs_extra19.default.readFile(import_path20.default.join(repoRoot, ".gitignore"), "utf8");
+    gitignorePatterns = parseGitignorePatterns(raw);
+  } catch {
+  }
+  const results = [];
+  const startDir = dir ? import_path20.default.join(repoRoot, dir) : repoRoot;
+  async function walk(dirPath) {
+    let entries;
+    try {
+      entries = await import_fs_extra19.default.readdir(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = import_path20.default.join(dirPath, entry.name);
+      const relPath = import_path20.default.relative(repoRoot, fullPath).replace(/\\/g, "/");
+      if (entry.isDirectory()) {
+        if (ALWAYS_SKIP.has(entry.name)) continue;
+        if (matchesGitignore(relPath, gitignorePatterns)) continue;
+        if (recursive) await walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      if (matchesGitignore(relPath, gitignorePatterns)) continue;
+      if (dir && !relPath.startsWith(dir.replace(/\\/g, "/"))) continue;
+      if (pattern && !entry.name.includes(pattern)) continue;
+      let docEntry;
+      try {
+        const stat = await import_fs_extra19.default.stat(fullPath);
+        const content = await import_fs_extra19.default.readFile(fullPath, "utf8");
+        const frontmatter = parseFrontmatter(content);
+        if (filter && (!frontmatter || frontmatter[filter.field] !== filter.value)) continue;
+        docEntry = {
+          filePath: fullPath,
+          relativePath: relPath,
+          frontmatter,
+          sizeBytes: stat.size,
+          lastModified: stat.mtime
+        };
+      } catch (err) {
+        if (filter) continue;
+        docEntry = {
+          filePath: fullPath,
+          relativePath: relPath,
+          frontmatter: null,
+          sizeBytes: 0,
+          lastModified: /* @__PURE__ */ new Date(0),
+          parseError: err.message
+        };
+      }
+      results.push(docEntry);
+    }
+  }
+  await walk(startDir);
+  return results;
+}
+
+// src/utils/docs-cache.ts
+var import_fs_extra20 = __toESM(require_lib2(), 1);
+var import_path21 = __toESM(require("path"), 1);
+var CACHE_PATH = import_path21.default.join(".xtrm", "cache", "docs-list.json");
+var DEFAULT_TTL_MS = 6e4;
+async function readCache(repoRoot) {
+  try {
+    const raw = await import_fs_extra20.default.readFile(import_path21.default.join(repoRoot, CACHE_PATH), "utf8");
+    const parsed = JSON.parse(raw);
+    parsed.entries = parsed.entries.map((e) => ({
+      ...e,
+      lastModified: new Date(e.lastModified)
+    }));
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(repoRoot, entries) {
+  const cachePath = import_path21.default.join(repoRoot, CACHE_PATH);
+  await import_fs_extra20.default.ensureDir(import_path21.default.dirname(cachePath));
+  const cache = {
+    timestamp: Date.now(),
+    repoRoot,
+    entries
+  };
+  await import_fs_extra20.default.writeFile(cachePath, JSON.stringify(cache, null, 2), "utf8");
+}
+function isCacheValid(cache, entries, ttlMs = DEFAULT_TTL_MS) {
+  if (Date.now() - cache.timestamp > ttlMs) return false;
+  for (const entry of entries) {
+    if (entry.lastModified.getTime() > cache.timestamp) return false;
+  }
+  return true;
+}
+
+// src/commands/docs-cross-check-gh.ts
+var import_node_child_process10 = require("child_process");
+function isGhAvailable() {
+  return (0, import_node_child_process10.spawnSync)("gh", ["--version"], { stdio: "pipe", encoding: "utf8" }).status === 0;
+}
+function fetchRecentPrs(repoRoot, days) {
+  if (!isGhAvailable()) {
+    console.log(kleur_default.yellow("  \u26A0 gh CLI not found \u2014 skipping PR data (install gh to enable cross-check)"));
+    return [];
+  }
+  const r = (0, import_node_child_process10.spawnSync)("gh", [
+    "pr",
+    "list",
+    "--state",
+    "merged",
+    "--limit",
+    "100",
+    "--json",
+    "number,title,mergedAt,url,headRefName"
+  ], { stdio: "pipe", encoding: "utf8", cwd: repoRoot });
+  if (r.status === 4) {
+    console.log(kleur_default.yellow("  \u26A0 gh auth error \u2014 run: gh auth login"));
+    return [];
+  }
+  if (r.status !== 0) {
+    console.log(kleur_default.yellow(`  \u26A0 gh pr list failed (exit ${r.status}) \u2014 skipping PR data`));
+    return [];
+  }
+  let prs;
+  try {
+    prs = JSON.parse(r.stdout);
+  } catch {
+    console.log(kleur_default.yellow("  \u26A0 Failed to parse gh pr list output \u2014 skipping PR data"));
+    return [];
+  }
+  const cutoff = Date.now() - days * 864e5;
+  return prs.filter((pr) => pr.mergedAt && new Date(pr.mergedAt).getTime() >= cutoff);
+}
+
+// src/commands/docs-cross-check-bd.ts
+var import_node_child_process11 = require("child_process");
+var _bdAvailable = null;
+function isBdAvailable() {
+  if (_bdAvailable !== null) return _bdAvailable;
+  const r = (0, import_node_child_process11.spawnSync)("bd", ["--version"], { stdio: "pipe", encoding: "utf8" });
+  _bdAvailable = r.status === 0;
+  return _bdAvailable;
+}
+function logBdWarning(message) {
+  console.error(kleur_default.yellow(`[bd] ${message}`));
+}
+function fetchClosedBdIssues(days) {
+  if (!isBdAvailable()) {
+    logBdWarning("fetchClosedBdIssues: bd CLI not available, skipping issue fetch");
+    return [];
+  }
+  const r = (0, import_node_child_process11.spawnSync)("bd", [
+    "query",
+    `status=closed AND updated>${days}d`,
+    "--json"
+  ], {
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  if (r.status !== 0) {
+    const hint = r.stderr?.trim() || `exit code ${r.status}`;
+    logBdWarning(`fetchClosedBdIssues: bd query failed (${hint})`);
+    return [];
+  }
+  try {
+    const data = JSON.parse(r.stdout ?? "[]");
+    return data.map((issue2) => ({
+      id: issue2.id,
+      title: issue2.title,
+      status: issue2.status,
+      type: issue2.issue_type,
+      closedAt: issue2.closed_at
+    }));
+  } catch (e) {
+    logBdWarning(`fetchClosedBdIssues: JSON parse failed (${e instanceof Error ? e.message : "unknown error"})`);
+    return [];
+  }
+}
+
+// src/commands/docs-cross-check-core.ts
+function detectStaleDocs(docs, prs, _days) {
+  const findings = [];
+  for (const doc of docs) {
+    if (doc.parseError) continue;
+    const docDate = doc.lastModified;
+    const mergedAfter = prs.filter((pr) => {
+      if (!pr.mergedAt) return false;
+      return new Date(pr.mergedAt) > docDate;
+    });
+    if (mergedAfter.length > 0) {
+      findings.push({
+        severity: "warning",
+        kind: "stale",
+        docPath: doc.relativePath,
+        message: `Doc not updated since ${mergedAfter.length} PR${mergedAfter.length > 1 ? "s" : ""} merged`,
+        detail: mergedAfter.slice(0, 3).map((pr) => `#${pr.number}: ${pr.title}`).join("; ")
+      });
+    }
+    const updatedAtStr = doc.frontmatter?.updated_at;
+    if (updatedAtStr) {
+      const updatedAt = new Date(updatedAtStr);
+      if (!isNaN(updatedAt.getTime())) {
+        const diffDays = Math.abs(docDate.getTime() - updatedAt.getTime()) / 864e5;
+        if (diffDays > 7) {
+          findings.push({
+            severity: "info",
+            kind: "stale",
+            docPath: doc.relativePath,
+            message: `Frontmatter updated_at differs from file mtime by ${Math.round(diffDays)} days`
+          });
+        }
+      }
+    }
+  }
+  return findings;
+}
+var BD_ISSUE_ID_REGEX = /[a-z0-9]+-[a-z0-9]{4}/gi;
+function detectCoverageGaps(docs, bdIssues, docContents) {
+  const findings = [];
+  const relevantIssues = bdIssues.filter(
+    (issue2) => issue2.status === "closed" && (issue2.type === "feature" || issue2.type === "task")
+  );
+  if (relevantIssues.length === 0) return findings;
+  const mentionedIds = /* @__PURE__ */ new Set();
+  for (const doc of docs) {
+    const fmStr = JSON.stringify(doc.frontmatter ?? {});
+    for (const match of fmStr.matchAll(BD_ISSUE_ID_REGEX)) {
+      mentionedIds.add(match[0].toLowerCase());
+    }
+    const content = docContents.get(doc.relativePath) ?? "";
+    for (const match of content.matchAll(BD_ISSUE_ID_REGEX)) {
+      mentionedIds.add(match[0].toLowerCase());
+    }
+  }
+  for (const issue2 of relevantIssues) {
+    const issueIdLower = issue2.id.toLowerCase();
+    if (!mentionedIds.has(issueIdLower)) {
+      findings.push({
+        severity: "warning",
+        kind: "coverage-gap",
+        docPath: "",
+        message: `Feature issue ${issue2.id} has no doc coverage`,
+        detail: issue2.title
+      });
+    }
+  }
+  return findings;
+}
+function validateIssueReferences(docs, bdIssues, docContents) {
+  const findings = [];
+  const issueStatus = /* @__PURE__ */ new Map();
+  for (const issue2 of bdIssues) {
+    issueStatus.set(issue2.id.toLowerCase(), issue2.status);
+  }
+  for (const doc of docs) {
+    const content = docContents.get(doc.relativePath) ?? "";
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const match of content.matchAll(BD_ISSUE_ID_REGEX)) {
+      const id = match[0].toLowerCase();
+      if (seenIds.has(id)) continue;
+      seenIds.add(id);
+      const status = issueStatus.get(id);
+      if (status && status !== "closed") {
+        findings.push({
+          severity: "info",
+          kind: "ref-invalid",
+          docPath: doc.relativePath,
+          message: `References open issue ${id}`
+        });
+      }
+    }
+  }
+  return findings;
+}
+var SEVERITY_ORDER = {
+  critical: 0,
+  warning: 1,
+  info: 2
+};
+function buildReport(findings, docsChecked) {
+  const sorted = [...findings].sort(
+    (a, b) => (SEVERITY_ORDER[a.severity] ?? 2) - (SEVERITY_ORDER[b.severity] ?? 2)
+  );
+  return {
+    docsChecked,
+    findingsTotal: sorted.length,
+    findings: sorted,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/commands/docs.ts
+var REQUIRED_FIELDS = /* @__PURE__ */ new Set(["title", "type", "status", "updated_at", "version"]);
 async function collectDocFiles(repoRoot, filterPattern) {
   const candidates = [];
   for (const name of ["README.md", "CHANGELOG.md"]) {
-    const p = import_path20.default.join(repoRoot, name);
-    if (await import_fs_extra19.default.pathExists(p)) candidates.push(p);
+    const p = import_path22.default.join(repoRoot, name);
+    if (await import_fs_extra21.default.pathExists(p)) candidates.push(p);
   }
-  const docsDir = import_path20.default.join(repoRoot, "docs");
-  if (await import_fs_extra19.default.pathExists(docsDir)) {
-    const entries = await import_fs_extra19.default.readdir(docsDir);
+  const docsDir = import_path22.default.join(repoRoot, "docs");
+  if (await import_fs_extra21.default.pathExists(docsDir)) {
+    const entries = await import_fs_extra21.default.readdir(docsDir);
     for (const entry of entries) {
-      if (entry.endsWith(".md")) candidates.push(import_path20.default.join(docsDir, entry));
+      if (entry.endsWith(".md")) candidates.push(import_path22.default.join(docsDir, entry));
     }
   }
   const results = [];
   for (const filePath of candidates) {
-    const rel = import_path20.default.relative(repoRoot, filePath);
-    if (filterPattern && !rel.includes(filterPattern) && !import_path20.default.basename(filePath).includes(filterPattern)) {
+    const rel = import_path22.default.relative(repoRoot, filePath);
+    if (filterPattern && !rel.includes(filterPattern) && !import_path22.default.basename(filePath).includes(filterPattern)) {
       continue;
     }
     let entry;
     try {
-      const stat = await import_fs_extra19.default.stat(filePath);
-      const content = await import_fs_extra19.default.readFile(filePath, "utf8");
+      const stat = await import_fs_extra21.default.stat(filePath);
+      const content = await import_fs_extra21.default.readFile(filePath, "utf8");
       const frontmatter = parseFrontmatter(content);
       entry = {
         filePath,
@@ -57034,8 +57553,43 @@ ${header}${meta3}`);
     console.log(`  ${keyStr}  ${valStr}`);
   }
 }
+function printCrossCheckReport(findings, docsChecked, total) {
+  console.log(t.bold(`
+  Docs cross-check
+`));
+  console.log(kleur_default.gray(`  ${docsChecked} docs checked, ${total} finding${total !== 1 ? "s" : ""}
+`));
+  if (findings.length === 0) {
+    console.log(`  ${sym.ok} All docs current
+`);
+    return;
+  }
+  const bySeverity = {
+    critical: findings.filter((f) => f.severity === "critical"),
+    warning: findings.filter((f) => f.severity === "warning"),
+    info: findings.filter((f) => f.severity === "info")
+  };
+  for (const f of bySeverity.critical) {
+    console.log(`  ${kleur_default.red("\u2717")} ${kleur_default.red(f.docPath || "(coverage gap)")}  ${f.message}`);
+    if (f.detail) console.log(kleur_default.gray(`      ${f.detail}`));
+  }
+  for (const f of bySeverity.warning) {
+    console.log(`  ${kleur_default.yellow("\u26A0")} ${kleur_default.yellow(f.docPath || "(coverage gap)")}  ${f.message}`);
+    if (f.detail) console.log(kleur_default.gray(`      ${f.detail}`));
+  }
+  for (const f of bySeverity.info) {
+    console.log(`  ${kleur_default.gray("\u2139")} ${kleur_default.gray(f.docPath)}  ${kleur_default.gray(f.message)}`);
+  }
+  const parts = [];
+  if (bySeverity.critical.length > 0) parts.push(kleur_default.red(`${bySeverity.critical.length} critical`));
+  if (bySeverity.warning.length > 0) parts.push(kleur_default.yellow(`${bySeverity.warning.length} warning${bySeverity.warning.length > 1 ? "s" : ""}`));
+  if (bySeverity.info.length > 0) parts.push(kleur_default.gray(`${bySeverity.info.length} info`));
+  console.log(kleur_default.gray(`
+  ${parts.join(", ")}
+`));
+}
 function createDocsCommand() {
-  const docs = new Command("docs").description("Documentation management commands");
+  const docs = new Command("docs").description("Documentation inspection and drift-check commands");
   docs.command("show [filter]").description("Display frontmatters for README, CHANGELOG, and docs/ files").option("--raw", "Output raw YAML frontmatter", false).option("--json", "Output JSON", false).action(async (filter, opts) => {
     const repoRoot = await findRepoRoot();
     const entries = await collectDocFiles(repoRoot, filter);
@@ -57063,11 +57617,122 @@ function createDocsCommand() {
   ${sym.ok} ${entries.length} file${entries.length !== 1 ? "s" : ""}` + (without > 0 ? kleur_default.gray(`  (${without} without frontmatter)`) : "") + "\n"
     );
   });
+  docs.command("list").description("List markdown docs with metadata summary, filters, and optional cache bypass").option("--dir <path>", "Filter to files under this directory").option("--pattern <glob>", "Filter by filename substring").option("--filter <field=value>", "Filter by frontmatter field, e.g. --filter type=service").option("--json", "Output JSON array", false).option("--no-cache", "Bypass cache and force fresh scan").action(async (opts) => {
+    const repoRoot = await findRepoRoot();
+    let fmFilter;
+    if (opts.filter) {
+      const sep = opts.filter.indexOf("=");
+      if (sep !== -1) {
+        fmFilter = { field: opts.filter.slice(0, sep), value: opts.filter.slice(sep + 1) };
+      }
+    }
+    const scanOpts = { dir: opts.dir, pattern: opts.pattern, filter: fmFilter };
+    let entries = [];
+    let fromCache = false;
+    if (opts.cache !== false) {
+      const cached2 = await readCache(repoRoot);
+      const fresh = await scanDocFiles(repoRoot, scanOpts);
+      if (cached2 && isCacheValid(cached2, fresh)) {
+        entries = fresh;
+        fromCache = true;
+      } else {
+        entries = fresh;
+        await writeCache(repoRoot, fresh);
+      }
+    } else {
+      entries = await scanDocFiles(repoRoot, scanOpts);
+    }
+    if (entries.length === 0) {
+      console.log(kleur_default.yellow("\n  No documentation files found.\n"));
+      return;
+    }
+    if (opts.json) {
+      const output = entries.map((e) => ({
+        path: e.relativePath,
+        sizeBytes: e.sizeBytes,
+        lastModified: e.lastModified.toISOString(),
+        frontmatter: e.frontmatter,
+        parseError: e.parseError ?? null
+      }));
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    const Table = require_cli_table3();
+    const table = new Table({
+      head: [
+        kleur_default.bold("Path"),
+        kleur_default.bold("Size"),
+        kleur_default.bold("Modified"),
+        kleur_default.bold("Title"),
+        kleur_default.bold("Type")
+      ],
+      style: { head: [], border: [] }
+    });
+    let withoutFm = 0;
+    for (const e of entries) {
+      const hasFm = e.frontmatter && Object.keys(e.frontmatter).length > 0;
+      if (!hasFm) withoutFm++;
+      const row = [
+        hasFm ? e.relativePath : kleur_default.gray(e.relativePath),
+        kleur_default.dim(formatSize(e.sizeBytes)),
+        kleur_default.dim(formatDate(e.lastModified)),
+        hasFm ? e.frontmatter?.title ?? kleur_default.gray("\u2014") : kleur_default.gray("\u2014"),
+        hasFm ? e.frontmatter?.type ?? kleur_default.gray("\u2014") : kleur_default.gray("\u2014")
+      ];
+      table.push(row);
+    }
+    console.log("\n" + table.toString());
+    const cacheNote = fromCache ? kleur_default.dim("  (cached)") : "";
+    const withoutNote = withoutFm > 0 ? kleur_default.gray(`  (${withoutFm} without frontmatter)`) : "";
+    console.log(`
+  ${sym.ok} ${entries.length} file${entries.length !== 1 ? "s" : ""}${withoutNote}${cacheNote}
+`);
+  });
+  docs.command("cross-check").description("Validate docs against recent PR activity, issue coverage, and open issue refs").option("--days <n>", "Look-back window in days", "30").option("--json", "Output JSON", false).action(async (opts) => {
+    try {
+      const days = parseInt(opts.days, 10) || 30;
+      const repoRoot = await findRepoRoot();
+      const ghOk = isGhAvailable();
+      const bdOk = isBdAvailable();
+      if (!ghOk) {
+        console.error(kleur_default.yellow("[gh] GitHub CLI not available, PR data will be empty"));
+      }
+      if (!bdOk) {
+        console.error(kleur_default.yellow("[bd] bd CLI not available, issue data will be empty"));
+      }
+      const docEntries = await collectDocFiles(repoRoot);
+      const docContents = /* @__PURE__ */ new Map();
+      for (const doc of docEntries) {
+        try {
+          const content = await import_fs_extra21.default.readFile(doc.filePath, "utf8");
+          docContents.set(doc.relativePath, content);
+        } catch {
+        }
+      }
+      const [prs, issues] = await Promise.all([
+        Promise.resolve(fetchRecentPrs(repoRoot, days)),
+        Promise.resolve(fetchClosedBdIssues(days))
+      ]);
+      const staleFindings = detectStaleDocs(docEntries, prs, days);
+      const gapFindings = detectCoverageGaps(docEntries, issues, docContents);
+      const refFindings = validateIssueReferences(docEntries, issues, docContents);
+      const report = buildReport([...staleFindings, ...gapFindings, ...refFindings], docEntries.length);
+      if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+      } else {
+        printCrossCheckReport(report.findings, report.docsChecked, report.findingsTotal);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(kleur_default.red(`\u2717 Cross-check failed: ${msg}`));
+      process.exit(1);
+    }
+  });
   return docs;
 }
 
 // src/commands/debug.ts
-var import_node_child_process9 = require("child_process");
+var import_node_child_process12 = require("child_process");
 var import_node_fs6 = require("fs");
 var import_node_path7 = require("path");
 var KIND_LABELS = {
@@ -57208,14 +57873,14 @@ function buildWhere(opts, base) {
     clauses.push(`session_id LIKE '${s}%'`);
   }
   if (opts.type) {
-    const t3 = opts.type.replace(/'/g, "''");
-    clauses.push(`kind LIKE '${t3}.%' OR kind = '${t3}'`);
+    const t2 = opts.type.replace(/'/g, "''");
+    clauses.push(`kind LIKE '${t2}.%' OR kind = '${t2}'`);
   }
   return clauses.length ? clauses.join(" AND ") : "";
 }
 function queryEvents(dbPath, where, limit) {
   const sql = `SELECT id,ts,session_id,runtime,worktree,kind,tool_name,outcome,issue_id,duration_ms,data FROM events${where ? ` WHERE ${where}` : ""} ORDER BY id ASC LIMIT ${limit}`;
-  const result = (0, import_node_child_process9.spawnSync)("sqlite3", [dbPath, "-json", sql], {
+  const result = (0, import_node_child_process12.spawnSync)("sqlite3", [dbPath, "-json", sql], {
     stdio: ["pipe", "pipe", "pipe"],
     encoding: "utf8",
     timeout: 5e3
@@ -57366,8 +58031,8 @@ function gradientLine(line) {
   let out = "";
   const len = line.length;
   for (let i = 0; i < len; i++) {
-    const t3 = len > 1 ? i / (len - 1) : 0;
-    const hue = HUE_START + t3 * (HUE_END - HUE_START);
+    const t2 = len > 1 ? i / (len - 1) : 0;
+    const hue = HUE_START + t2 * (HUE_END - HUE_START);
     const [r, g, b] = hslToRgb(hue, SAT, LIG);
     out += `\x1B[38;2;${r};${g};${b}m` + line[i];
   }
@@ -57465,6 +58130,7 @@ program2.addCommand(createResetCommand());
 program2.addCommand(createCleanCommand());
 program2.addCommand(createEndCommand());
 program2.addCommand(createWorktreeCommand());
+program2.addCommand(createAttachCommand());
 program2.addCommand(createDocsCommand());
 program2.addCommand(createDebugCommand());
 program2.addCommand(createHelpCommand());