@mrrlin-dev/mcp 0.3.0 → 0.3.2

package/dist/bin.cjs

@@ -4273,7 +4273,7 @@ var require_websocket = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes3, createHash } = require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash2 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -4941,7 +4941,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -5310,7 +5310,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter3 = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash } = require("crypto");
+    var { createHash: createHash2 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -5617,7 +5617,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -5704,13 +5704,1986 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/constants.js
+var require_constants2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/constants.js"(exports2, module2) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module2.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/debug.js"(exports2, module2) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module2.exports = debug;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/re.js"(exports2, module2) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants2();
+    var debug = require_debug();
+    exports2 = module2.exports = {};
+    var re = exports2.re = [];
+    var safeRe = exports2.safeRe = [];
+    var src = exports2.src = [];
+    var safeSrc = exports2.safeSrc = [];
+    var t = exports2.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      }
+      return value;
+    };
+    var createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.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[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports2.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports2.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports2.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/parse-options.js"(exports2, module2) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    module2.exports = parseOptions;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/identifiers.js"(exports2, module2) {
+    "use strict";
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module2.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/classes/semver.js"(exports2, module2) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants2();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var SemVer = class _SemVer {
+      constructor(version2, options) {
+        options = parseOptions(options);
+        if (version2 instanceof _SemVer) {
+          if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
+            return version2;
+          } else {
+            version2 = version2.version;
+          }
+        } else if (typeof version2 !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
+        }
+        if (version2.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version2, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version2.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version2}`);
+        }
+        this.raw = version2;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num = +id;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
+              }
+            }
+            return id;
+          });
+        }
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.major < other.major) {
+          return -1;
+        }
+        if (this.major > other.major) {
+          return 1;
+        }
+        if (this.minor < other.minor) {
+          return -1;
+        }
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
+      }
+      comparePre(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (identifier) {
+            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier) {
+              throw new Error(`invalid identifier: ${identifier}`);
+            }
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
+            }
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0) {
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            }
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                if (isNaN(this.prerelease[1])) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    module2.exports = SemVer;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/parse.js
+var require_parse2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/parse.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse5 = (version2, options, throwErrors = false) => {
+      if (version2 instanceof SemVer) {
+        return version2;
+      }
+      try {
+        return new SemVer(version2, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
+      }
+    };
+    module2.exports = parse5;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/valid.js"(exports2, module2) {
+    "use strict";
+    var parse5 = require_parse2();
+    var valid = (version2, options) => {
+      const v = parse5(version2, options);
+      return v ? v.version : null;
+    };
+    module2.exports = valid;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/clean.js
+var require_clean = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/clean.js"(exports2, module2) {
+    "use strict";
+    var parse5 = require_parse2();
+    var clean = (version2, options) => {
+      const s = parse5(version2.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    };
+    module2.exports = clean;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/inc.js
+var require_inc = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/inc.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var inc = (version2, release, options, identifier, identifierBase) => {
+      if (typeof options === "string") {
+        identifierBase = identifier;
+        identifier = options;
+        options = void 0;
+      }
+      try {
+        return new SemVer(
+          version2 instanceof SemVer ? version2.version : version2,
+          options
+        ).inc(release, identifier, identifierBase).version;
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = inc;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/diff.js
+var require_diff = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/diff.js"(exports2, module2) {
+    "use strict";
+    var parse5 = require_parse2();
+    var diff = (version1, version2) => {
+      const v1 = parse5(version1, null, true);
+      const v2 = parse5(version2, null, true);
+      const comparison = v1.compare(v2);
+      if (comparison === 0) {
+        return null;
+      }
+      const v1Higher = comparison > 0;
+      const highVersion = v1Higher ? v1 : v2;
+      const lowVersion = v1Higher ? v2 : v1;
+      const highHasPre = !!highVersion.prerelease.length;
+      const lowHasPre = !!lowVersion.prerelease.length;
+      if (lowHasPre && !highHasPre) {
+        if (!lowVersion.patch && !lowVersion.minor) {
+          return "major";
+        }
+        if (lowVersion.compareMain(highVersion) === 0) {
+          if (lowVersion.minor && !lowVersion.patch) {
+            return "minor";
+          }
+          return "patch";
+        }
+      }
+      const prefix = highHasPre ? "pre" : "";
+      if (v1.major !== v2.major) {
+        return prefix + "major";
+      }
+      if (v1.minor !== v2.minor) {
+        return prefix + "minor";
+      }
+      if (v1.patch !== v2.patch) {
+        return prefix + "patch";
+      }
+      return "prerelease";
+    };
+    module2.exports = diff;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/major.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var major = (a, loose) => new SemVer(a, loose).major;
+    module2.exports = major;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/minor.js
+var require_minor = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/minor.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var minor = (a, loose) => new SemVer(a, loose).minor;
+    module2.exports = minor;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/patch.js
+var require_patch = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/patch.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var patch = (a, loose) => new SemVer(a, loose).patch;
+    module2.exports = patch;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/prerelease.js"(exports2, module2) {
+    "use strict";
+    var parse5 = require_parse2();
+    var prerelease = (version2, options) => {
+      const parsed = parse5(version2, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    };
+    module2.exports = prerelease;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/compare.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module2.exports = compare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/rcompare.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare = (a, b, loose) => compare(b, a, loose);
+    module2.exports = rcompare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/compare-loose.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var compareLoose = (a, b) => compare(a, b, true);
+    module2.exports = compareLoose;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/compare-build.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var compareBuild = (a, b, loose) => {
+      const versionA = new SemVer(a, loose);
+      const versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    };
+    module2.exports = compareBuild;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/sort.js
+var require_sort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/sort.js"(exports2, module2) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+    module2.exports = sort;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/rsort.js"(exports2, module2) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+    module2.exports = rsort;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/gt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module2.exports = gt;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/lt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module2.exports = lt;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/eq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module2.exports = eq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/neq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module2.exports = neq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/gte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/lte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module2.exports = lte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/cmp.js"(exports2, module2) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module2.exports = cmp;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/coerce.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse5 = require_parse2();
+    var { safeRe: re, t } = require_re();
+    var coerce = (version2, options) => {
+      if (version2 instanceof SemVer) {
+        return version2;
+      }
+      if (typeof version2 === "number") {
+        version2 = String(version2);
+      }
+      if (typeof version2 !== "string") {
+        return null;
+      }
+      options = options || {};
+      let match = null;
+      if (!options.rtl) {
+        match = version2.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+      } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+        let next;
+        while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) {
+            match = next;
+          }
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        }
+        coerceRtlRegex.lastIndex = -1;
+      }
+      if (match === null) {
+        return null;
+      }
+      const major = match[2];
+      const minor = match[3] || "0";
+      const patch = match[4] || "0";
+      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+      return parse5(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+    };
+    module2.exports = coerce;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/truncate.js
+var require_truncate = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/truncate.js"(exports2, module2) {
+    "use strict";
+    var parse5 = require_parse2();
+    var constants = require_constants2();
+    var SemVer = require_semver();
+    var truncate2 = (version2, truncation, options) => {
+      if (!constants.RELEASE_TYPES.includes(truncation)) {
+        return null;
+      }
+      const clonedVersion = cloneInputVersion(version2, options);
+      return clonedVersion && doTruncation(clonedVersion, truncation);
+    };
+    var cloneInputVersion = (version2, options) => {
+      const versionStringToParse = version2 instanceof SemVer ? version2.version : version2;
+      return parse5(versionStringToParse, options);
+    };
+    var doTruncation = (version2, truncation) => {
+      if (isPrerelease(truncation)) {
+        return version2.version;
+      }
+      version2.prerelease = [];
+      switch (truncation) {
+        case "major":
+          version2.minor = 0;
+          version2.patch = 0;
+          break;
+        case "minor":
+          version2.patch = 0;
+          break;
+      }
+      return version2.format();
+    };
+    var isPrerelease = (type) => {
+      return type.startsWith("pre");
+    };
+    module2.exports = truncate2;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/internal/lrucache.js"(exports2, module2) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
+        }
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    };
+    module2.exports = LRUCache;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/classes/range.js"(exports2, module2) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range = class _Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) {
+              this.formatted += "||";
+            }
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) {
+                this.formatted += " ";
+              }
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached2 = cache.get(memoKey);
+        if (cached2) {
+          return cached2;
+        }
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.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[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result = [...rangeMap.values()];
+        cache.set(memoKey, result);
+        return result;
+      }
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version2) {
+        if (!version2) {
+          return false;
+        }
+        if (typeof version2 === "string") {
+          try {
+            version2 = new SemVer(version2, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version2, this.options)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    module2.exports = Range;
+    var LRU = require_lrucache();
+    var cache = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var {
+      safeRe: re,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants2();
+    var isNullSet = (c) => c.value === "<0.0.0-0";
+    var isAny = (c) => c.value === "";
+    var isSatisfiable = (comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    };
+    var parseComparator = (comp, options) => {
+      comp = comp.replace(re[t.BUILD], "");
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+    var replaceTildes = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    };
+    var replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    var replaceCarets = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    };
+    var replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z2 = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z2} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z2} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z2} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}${z2} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}${z2} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    var replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    var replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    var replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    var replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    };
+    var testSet = (set2, version2, options) => {
+      for (let i = 0; i < set2.length; i++) {
+        if (!set2[i].test(version2)) {
+          return false;
+        }
+      }
+      if (version2.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set2.length; i++) {
+          debug(set2[i].semver);
+          if (set2[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set2[i].semver.prerelease.length > 0) {
+            const allowed = set2[i].semver;
+            if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/classes/comparator.js"(exports2, module2) {
+    "use strict";
+    var ANY = Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
+          } else {
+            comp = comp.value;
+          }
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
+        }
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer(m[2], this.options.loose);
+        }
+      }
+      toString() {
+        return this.value;
+      }
+      test(version2) {
+        debug("Comparator.test", version2, this.options.loose);
+        if (this.semver === ANY || version2 === ANY) {
+          return true;
+        }
+        if (typeof version2 === "string") {
+          try {
+            version2 = new SemVer(version2, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        return cmp(version2, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
+            return true;
+          }
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
+        }
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
+      }
+    };
+    module2.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/functions/satisfies.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var satisfies = (version2, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version2);
+    };
+    module2.exports = satisfies;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    module2.exports = toComparators;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/max-satisfying.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var maxSatisfying = (versions, range, options) => {
+      let max = null;
+      let maxSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    };
+    module2.exports = maxSatisfying;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/min-satisfying.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var minSatisfying = (versions, range, options) => {
+      let min = null;
+      let minSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    };
+    module2.exports = minSatisfying;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/min-version.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var gt = require_gt();
+    var minVersion = (range, loose) => {
+      range = new Range(range, loose);
+      let minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let setMin = null;
+        comparators.forEach((comparator) => {
+          const compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            /* fallthrough */
+            case "":
+            case ">=":
+              if (!setMin || gt(compver, setMin)) {
+                setMin = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            /* istanbul ignore next */
+            default:
+              throw new Error(`Unexpected operation: ${comparator.operator}`);
+          }
+        });
+        if (setMin && (!minver || gt(minver, setMin))) {
+          minver = setMin;
+        }
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    };
+    module2.exports = minVersion;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/valid.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var validRange = (range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = validRange;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/outside.js
+var require_outside = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/outside.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var gt = require_gt();
+    var lt = require_lt();
+    var lte = require_lte();
+    var gte = require_gte();
+    var outside = (version2, range, hilo, options) => {
+      version2 = new SemVer(version2, options);
+      range = new Range(range, options);
+      let gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version2, range, options)) {
+        return false;
+      }
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let high = null;
+        let low = null;
+        comparators.forEach((comparator) => {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    module2.exports = outside;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/gtr.js"(exports2, module2) {
+    "use strict";
+    var outside = require_outside();
+    var gtr = (version2, range, options) => outside(version2, range, ">", options);
+    module2.exports = gtr;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/ltr.js"(exports2, module2) {
+    "use strict";
+    var outside = require_outside();
+    var ltr = (version2, range, options) => outside(version2, range, "<", options);
+    module2.exports = ltr;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/intersects.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var intersects = (r1, r2, options) => {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2, options);
+    };
+    module2.exports = intersects;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/simplify.js"(exports2, module2) {
+    "use strict";
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    module2.exports = (versions, range, options) => {
+      const set2 = [];
+      let first = null;
+      let prev = null;
+      const v = versions.sort((a, b) => compare(a, b, options));
+      for (const version2 of v) {
+        const included = satisfies(version2, range, options);
+        if (included) {
+          prev = version2;
+          if (!first) {
+            first = version2;
+          }
+        } else {
+          if (prev) {
+            set2.push([first, prev]);
+          }
+          prev = null;
+          first = null;
+        }
+      }
+      if (first) {
+        set2.push([first, null]);
+      }
+      const ranges = [];
+      for (const [min, max] of set2) {
+        if (min === max) {
+          ranges.push(min);
+        } else if (!max && min === v[0]) {
+          ranges.push("*");
+        } else if (!max) {
+          ranges.push(`>=${min}`);
+        } else if (min === v[0]) {
+          ranges.push(`<=${max}`);
+        } else {
+          ranges.push(`${min} - ${max}`);
+        }
+      }
+      const simplified = ranges.join(" || ");
+      const original = typeof range.raw === "string" ? range.raw : String(range);
+      return simplified.length < original.length ? simplified : range;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/subset.js
+var require_subset = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/ranges/subset.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    var subset = (sub, dom, options = {}) => {
+      if (sub === dom) {
+        return true;
+      }
+      sub = new Range(sub, options);
+      dom = new Range(dom, options);
+      let sawNonNull = false;
+      OUTER: for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+    var minimumVersion = [new Comparator(">=0.0.0")];
+    var simpleSubset = (sub, dom, options) => {
+      if (sub === dom) {
+        return true;
+      }
+      if (sub.length === 1 && sub[0].semver === ANY) {
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          return true;
+        } else if (options.includePrerelease) {
+          sub = minimumVersionWithPreRelease;
+        } else {
+          sub = minimumVersion;
+        }
+      }
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        if (options.includePrerelease) {
+          return true;
+        } else {
+          dom = minimumVersion;
+        }
+      }
+      const eqSet = /* @__PURE__ */ new Set();
+      let gt, lt;
+      for (const c of sub) {
+        if (c.operator === ">" || c.operator === ">=") {
+          gt = higherGT(gt, c, options);
+        } else if (c.operator === "<" || c.operator === "<=") {
+          lt = lowerLT(lt, c, options);
+        } else {
+          eqSet.add(c.semver);
+        }
+      }
+      if (eqSet.size > 1) {
+        return null;
+      }
+      let gtltComp;
+      if (gt && lt) {
+        gtltComp = compare(gt.semver, lt.semver, options);
+        if (gtltComp > 0) {
+          return null;
+        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+          return null;
+        }
+      }
+      for (const eq of eqSet) {
+        if (gt && !satisfies(eq, String(gt), options)) {
+          return null;
+        }
+        if (lt && !satisfies(eq, String(lt), options)) {
+          return null;
+        }
+        for (const c of dom) {
+          if (!satisfies(eq, String(c), options)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      let higher, lower;
+      let hasDomLT, hasDomGT;
+      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+      let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+        needDomLTPre = false;
+      }
+      for (const c of dom) {
+        hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+        hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+        if (gt) {
+          if (needDomGTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+              needDomGTPre = false;
+            }
+          }
+          if (c.operator === ">" || c.operator === ">=") {
+            higher = higherGT(gt, c, options);
+            if (higher === c && higher !== gt) {
+              return false;
+            }
+          } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (lt) {
+          if (needDomLTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+              needDomLTPre = false;
+            }
+          }
+          if (c.operator === "<" || c.operator === "<=") {
+            lower = lowerLT(lt, c, options);
+            if (lower === c && lower !== lt) {
+              return false;
+            }
+          } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (!c.operator && (lt || gt) && gtltComp !== 0) {
+          return false;
+        }
+      }
+      if (gt && hasDomLT && !lt && gtltComp !== 0) {
+        return false;
+      }
+      if (lt && hasDomGT && !gt && gtltComp !== 0) {
+        return false;
+      }
+      if (needDomGTPre || needDomLTPre) {
+        return false;
+      }
+      return true;
+    };
+    var higherGT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+    };
+    var lowerLT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+    };
+    module2.exports = subset;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/index.js
+var require_semver2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.0/node_modules/semver/index.js"(exports2, module2) {
+    "use strict";
+    var internalRe = require_re();
+    var constants = require_constants2();
+    var SemVer = require_semver();
+    var identifiers = require_identifiers();
+    var parse5 = require_parse2();
+    var valid = require_valid();
+    var clean = require_clean();
+    var inc = require_inc();
+    var diff = require_diff();
+    var major = require_major();
+    var minor = require_minor();
+    var patch = require_patch();
+    var prerelease = require_prerelease();
+    var compare = require_compare();
+    var rcompare = require_rcompare();
+    var compareLoose = require_compare_loose();
+    var compareBuild = require_compare_build();
+    var sort = require_sort();
+    var rsort = require_rsort();
+    var gt = require_gt();
+    var lt = require_lt();
+    var eq = require_eq();
+    var neq = require_neq();
+    var gte = require_gte();
+    var lte = require_lte();
+    var cmp = require_cmp();
+    var coerce = require_coerce();
+    var truncate2 = require_truncate();
+    var Comparator = require_comparator();
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var toComparators = require_to_comparators();
+    var maxSatisfying = require_max_satisfying();
+    var minSatisfying = require_min_satisfying();
+    var minVersion = require_min_version();
+    var validRange = require_valid2();
+    var outside = require_outside();
+    var gtr = require_gtr();
+    var ltr = require_ltr();
+    var intersects = require_intersects();
+    var simplifyRange = require_simplify();
+    var subset = require_subset();
+    module2.exports = {
+      parse: parse5,
+      valid,
+      clean,
+      inc,
+      diff,
+      major,
+      minor,
+      patch,
+      prerelease,
+      compare,
+      rcompare,
+      compareLoose,
+      compareBuild,
+      sort,
+      rsort,
+      gt,
+      lt,
+      eq,
+      neq,
+      gte,
+      lte,
+      cmp,
+      coerce,
+      truncate: truncate2,
+      Comparator,
+      Range,
+      satisfies,
+      toComparators,
+      maxSatisfying,
+      minSatisfying,
+      minVersion,
+      validRange,
+      outside,
+      gtr,
+      ltr,
+      intersects,
+      simplifyRange,
+      subset,
+      SemVer,
+      re: internalRe.re,
+      src: internalRe.src,
+      tokens: internalRe.t,
+      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants.RELEASE_TYPES,
+      compareIdentifiers: identifiers.compareIdentifiers,
+      rcompareIdentifiers: identifiers.rcompareIdentifiers
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
 var require_polyfills = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports2, module2) {
     var constants = require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -5756,20 +7729,20 @@ var require_polyfills = __commonJS({
       fs6.fstatSync = statFixSync(fs6.fstatSync);
       fs6.lstatSync = statFixSync(fs6.lstatSync);
       if (fs6.chmod && !fs6.lchmod) {
-        fs6.lchmod = function(path14, mode, cb) {
+        fs6.lchmod = function(path15, mode, cb) {
           if (cb) process.nextTick(cb);
         };
         fs6.lchmodSync = function() {
         };
       }
       if (fs6.chown && !fs6.lchown) {
-        fs6.lchown = function(path14, uid, gid, cb) {
+        fs6.lchown = function(path15, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
         fs6.lchownSync = function() {
         };
       }
-      if (platform === "win32") {
+      if (platform2 === "win32") {
         fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
@@ -5830,9 +7803,9 @@ var require_polyfills = __commonJS({
         };
       }(fs6.readSync);
       function patchLchmod(fs7) {
-        fs7.lchmod = function(path14, mode, callback) {
+        fs7.lchmod = function(path15, mode, callback) {
           fs7.open(
-            path14,
+            path15,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -5848,8 +7821,8 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs7.lchmodSync = function(path14, mode) {
-          var fd = fs7.openSync(path14, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs7.lchmodSync = function(path15, mode) {
+          var fd = fs7.openSync(path15, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -5870,8 +7843,8 @@ var require_polyfills = __commonJS({
       }
       function patchLutimes(fs7) {
         if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-          fs7.lutimes = function(path14, at, mt, cb) {
-            fs7.open(path14, constants.O_SYMLINK, function(er, fd) {
+          fs7.lutimes = function(path15, at, mt, cb) {
+            fs7.open(path15, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -5883,8 +7856,8 @@ var require_polyfills = __commonJS({
               });
             });
           };
-          fs7.lutimesSync = function(path14, at, mt) {
-            var fd = fs7.openSync(path14, constants.O_SYMLINK);
+          fs7.lutimesSync = function(path15, at, mt) {
+            var fd = fs7.openSync(path15, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -6002,11 +7975,11 @@ var require_legacy_streams = __commonJS({
         ReadStream,
         WriteStream
       };
-      function ReadStream(path14, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path14, options);
+      function ReadStream(path15, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path15, options);
         Stream.call(this);
         var self = this;
-        this.path = path14;
+        this.path = path15;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -6051,10 +8024,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path14, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path14, options);
+      function WriteStream(path15, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path15, options);
         Stream.call(this);
-        this.path = path14;
+        this.path = path15;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -6197,14 +8170,14 @@ var require_graceful_fs = __commonJS({
       fs7.createWriteStream = createWriteStream;
       var fs$readFile = fs7.readFile;
       fs7.readFile = readFile2;
-      function readFile2(path14, options, cb) {
+      function readFile2(path15, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path14, options, cb);
-        function go$readFile(path15, options2, cb2, startTime) {
-          return fs$readFile(path15, options2, function(err) {
+        return go$readFile(path15, options, cb);
+        function go$readFile(path16, options2, cb2, startTime) {
+          return fs$readFile(path16, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path15, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path16, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -6214,14 +8187,14 @@ var require_graceful_fs = __commonJS({
       }
       var fs$writeFile = fs7.writeFile;
       fs7.writeFile = writeFile;
-      function writeFile(path14, data, options, cb) {
+      function writeFile(path15, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path14, data, options, cb);
-        function go$writeFile(path15, data2, options2, cb2, startTime) {
-          return fs$writeFile(path15, data2, options2, function(err) {
+        return go$writeFile(path15, data, options, cb);
+        function go$writeFile(path16, data2, options2, cb2, startTime) {
+          return fs$writeFile(path16, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -6232,14 +8205,14 @@ var require_graceful_fs = __commonJS({
       var fs$appendFile = fs7.appendFile;
       if (fs$appendFile)
         fs7.appendFile = appendFile;
-      function appendFile(path14, data, options, cb) {
+      function appendFile(path15, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path14, data, options, cb);
-        function go$appendFile(path15, data2, options2, cb2, startTime) {
-          return fs$appendFile(path15, data2, options2, function(err) {
+        return go$appendFile(path15, data, options, cb);
+        function go$appendFile(path16, data2, options2, cb2, startTime) {
+          return fs$appendFile(path16, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -6270,31 +8243,31 @@ var require_graceful_fs = __commonJS({
       var fs$readdir = fs7.readdir;
       fs7.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path14, options, cb) {
+      function readdir(path15, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, fs$readdirCallback(
-            path15,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, options2, fs$readdirCallback(
-            path15,
+        } : function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, options2, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path14, options, cb);
-        function fs$readdirCallback(path15, options2, cb2, startTime) {
+        return go$readdir(path15, options, cb);
+        function fs$readdirCallback(path16, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path15, options2, cb2],
+                [path16, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -6365,7 +8338,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path14, options) {
+      function ReadStream(path15, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -6385,7 +8358,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path14, options) {
+      function WriteStream(path15, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -6403,22 +8376,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path14, options) {
-        return new fs7.ReadStream(path14, options);
+      function createReadStream(path15, options) {
+        return new fs7.ReadStream(path15, options);
       }
-      function createWriteStream(path14, options) {
-        return new fs7.WriteStream(path14, options);
+      function createWriteStream(path15, options) {
+        return new fs7.WriteStream(path15, options);
       }
       var fs$open = fs7.open;
       fs7.open = open;
-      function open(path14, flags, mode, cb) {
+      function open(path15, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path14, flags, mode, cb);
-        function go$open(path15, flags2, mode2, cb2, startTime) {
-          return fs$open(path15, flags2, mode2, function(err, fd) {
+        return go$open(path15, flags, mode, cb);
+        function go$open(path16, flags2, mode2, cb2, startTime) {
+          return fs$open(path16, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path15, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path16, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -6947,7 +8920,7 @@ var require_mtime_precision = __commonJS({
 var require_lockfile = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports2, module2) {
     "use strict";
-    var path14 = require("path");
+    var path15 = require("path");
     var fs6 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
@@ -6958,7 +8931,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file2, options, callback) {
       if (!options.realpath) {
-        return callback(null, path14.resolve(file2));
+        return callback(null, path15.resolve(file2));
       }
       options.fs.realpath(file2, callback);
     }
@@ -8822,10 +10795,10 @@ var require_segments = __commonJS({
       const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
       const nodes = buildNodes(segs);
       const graph = buildGraph(nodes, version2);
-      const path14 = dijkstra.find_path(graph.map, "start", "end");
+      const path15 = dijkstra.find_path(graph.map, "start", "end");
       const optimizedSegs = [];
-      for (let i = 1; i < path14.length - 1; i++) {
-        optimizedSegs.push(graph.table[path14[i]].node);
+      for (let i = 1; i < path15.length - 1; i++) {
+        optimizedSegs.push(graph.table[path15[i]].node);
       }
       return exports2.fromArray(mergeSegments(optimizedSegs));
     };
@@ -9507,7 +11480,7 @@ var require_filter_parse_async = __commonJS({
 });
 
 // ../../node_modules/.pnpm/pngjs@5.0.0/node_modules/pngjs/lib/constants.js
-var require_constants2 = __commonJS({
+var require_constants3 = __commonJS({
   "../../node_modules/.pnpm/pngjs@5.0.0/node_modules/pngjs/lib/constants.js"(exports2, module2) {
     "use strict";
     module2.exports = {
@@ -9585,7 +11558,7 @@ var require_crc = __commonJS({
 var require_parser2 = __commonJS({
   "../../node_modules/.pnpm/pngjs@5.0.0/node_modules/pngjs/lib/parser.js"(exports2, module2) {
     "use strict";
-    var constants = require_constants2();
+    var constants = require_constants3();
     var CrcCalculator = require_crc();
     var Parser = module2.exports = function(options, dependencies) {
       this._options = options;
@@ -10261,7 +12234,7 @@ var require_parser_async = __commonJS({
 var require_bitpacker = __commonJS({
   "../../node_modules/.pnpm/pngjs@5.0.0/node_modules/pngjs/lib/bitpacker.js"(exports2, module2) {
     "use strict";
-    var constants = require_constants2();
+    var constants = require_constants3();
     module2.exports = function(dataIn, width, height, options) {
       let outHasAlpha = [constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(
         options.colorType
@@ -10553,7 +12526,7 @@ var require_filter_pack = __commonJS({
 var require_packer = __commonJS({
   "../../node_modules/.pnpm/pngjs@5.0.0/node_modules/pngjs/lib/packer.js"(exports2, module2) {
     "use strict";
-    var constants = require_constants2();
+    var constants = require_constants3();
     var CrcStream = require_crc();
     var bitPacker = require_bitpacker();
     var filter = require_filter_pack();
@@ -10655,7 +12628,7 @@ var require_packer_async = __commonJS({
     "use strict";
     var util = require("util");
     var Stream = require("stream");
-    var constants = require_constants2();
+    var constants = require_constants3();
     var Packer = require_packer();
     var PackerAsync = module2.exports = function(opt) {
       Stream.call(this);
@@ -10990,7 +12963,7 @@ var require_packer_sync = __commonJS({
     if (!zlib.deflateSync) {
       hasSyncZlib = false;
     }
-    var constants = require_constants2();
+    var constants = require_constants3();
     var Packer = require_packer();
     module2.exports = function(metaData, opt) {
       if (!hasSyncZlib) {
@@ -11302,7 +13275,7 @@ var require_png2 = __commonJS({
       });
       png.pack();
     };
-    exports2.renderToFile = function renderToFile(path14, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path15, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
@@ -11313,7 +13286,7 @@ var require_png2 = __commonJS({
         called = true;
         cb.apply(null, args);
       };
-      const stream = fs6.createWriteStream(path14);
+      const stream = fs6.createWriteStream(path15);
       stream.on("error", done);
       stream.on("close", done);
       exports2.renderToFileStream(stream, qrData, options);
@@ -11375,14 +13348,14 @@ var require_utf8 = __commonJS({
       }
       return output3;
     };
-    exports2.renderToFile = function renderToFile(path14, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path15, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
       const fs6 = require("fs");
       const utf8 = exports2.render(qrData, options);
-      fs6.writeFile(path14, utf8, cb);
+      fs6.writeFile(path15, utf8, cb);
     };
   }
 });
@@ -11503,7 +13476,7 @@ var require_svg_tag = __commonJS({
       return str;
     }
     function qrToPath(data, size, margin) {
-      let path14 = "";
+      let path15 = "";
       let moveBy = 0;
       let newRow = false;
       let lineLength = 0;
@@ -11514,19 +13487,19 @@ var require_svg_tag = __commonJS({
         if (data[i]) {
           lineLength++;
           if (!(i > 0 && col > 0 && data[i - 1])) {
-            path14 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+            path15 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
             moveBy = 0;
             newRow = false;
           }
           if (!(col + 1 < size && data[i + 1])) {
-            path14 += svgCmd("h", lineLength);
+            path15 += svgCmd("h", lineLength);
             lineLength = 0;
           }
         } else {
           moveBy++;
         }
       }
-      return path14;
+      return path15;
     }
     exports2.render = function render(qrData, options, cb) {
       const opts = Utils.getOptions(options);
@@ -11534,10 +13507,10 @@ var require_svg_tag = __commonJS({
       const data = qrData.modules.data;
       const qrcodesize = size + opts.margin * 2;
       const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + ' d="M0 0h' + qrcodesize + "v" + qrcodesize + 'H0z"/>';
-      const path14 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+      const path15 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
       const viewBox = 'viewBox="0 0 ' + qrcodesize + " " + qrcodesize + '"';
       const width = !opts.width ? "" : 'width="' + opts.width + '" height="' + opts.width + '" ';
-      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path14 + "</svg>\n";
+      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path15 + "</svg>\n";
       if (typeof cb === "function") {
         cb(null, svgTag);
       }
@@ -11551,7 +13524,7 @@ var require_svg = __commonJS({
   "../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/svg.js"(exports2) {
     var svgTagRenderer = require_svg_tag();
     exports2.render = svgTagRenderer.render;
-    exports2.renderToFile = function renderToFile(path14, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path15, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
@@ -11559,7 +13532,7 @@ var require_svg = __commonJS({
       const fs6 = require("fs");
       const svgTag = exports2.render(qrData, options);
       const xmlStr = '<?xml version="1.0" encoding="utf-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">' + svgTag;
-      fs6.writeFile(path14, xmlStr, cb);
+      fs6.writeFile(path15, xmlStr, cb);
     };
   }
 });
@@ -11717,8 +13690,8 @@ var require_server = __commonJS({
         cb
       };
     }
-    function getTypeFromFilename(path14) {
-      return path14.slice((path14.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
+    function getTypeFromFilename(path15) {
+      return path15.slice((path15.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
     }
     function getRendererFromType(type) {
       switch (type) {
@@ -11782,17 +13755,17 @@ var require_server = __commonJS({
       const renderer = getRendererFromType(params.opts.type);
       return render(renderer.renderToBuffer, text, params);
     };
-    exports2.toFile = function toFile(path14, text, opts, cb) {
-      if (typeof path14 !== "string" || !(typeof text === "string" || typeof text === "object")) {
+    exports2.toFile = function toFile(path15, text, opts, cb) {
+      if (typeof path15 !== "string" || !(typeof text === "string" || typeof text === "object")) {
         throw new Error("Invalid argument");
       }
       if (arguments.length < 3 && !canPromise()) {
         throw new Error("Too few arguments provided");
       }
       const params = checkParams(text, opts, cb);
-      const type = params.opts.type || getTypeFromFilename(path14);
+      const type = params.opts.type || getTypeFromFilename(path15);
       const renderer = getRendererFromType(type);
-      const renderToFile = renderer.renderToFile.bind(null, path14);
+      const renderToFile = renderer.renderToFile.bind(null, path15);
       return render(renderToFile, text, params);
     };
     exports2.toFileStream = function toFileStream(stream, text, opts) {
@@ -15010,8 +16983,8 @@ var require_utils3 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path14) {
-      let input = path14;
+    function removeDotSegments(path15) {
+      let input = path15;
       const output3 = [];
       let nextSlash = -1;
       let len = 0;
@@ -15263,8 +17236,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path14, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path14 && path14 !== "/" ? path14 : void 0;
+        const [path15, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -18671,11 +20644,11 @@ var require_dist = __commonJS({
 });
 
 // src/bin.ts
-var import_node_path19 = __toESM(require("node:path"), 1);
-var import_node_child_process7 = require("node:child_process");
-var import_node_fs14 = require("node:fs");
-var import_node_os11 = require("node:os");
 var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs16 = require("node:fs");
+var import_node_os12 = require("node:os");
+var import_node_path21 = __toESM(require("node:path"), 1);
 
 // src/install-codex.ts
 var import_promises = __toESM(require("node:fs/promises"), 1);
@@ -18847,12 +20820,12 @@ ${block}`;
 }
 
 // src/director-bridge.ts
-var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
-var import_node_os7 = __toESM(require("node:os"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
-var import_node_child_process3 = require("node:child_process");
-var import_node_crypto4 = __toESM(require("node:crypto"), 1);
+var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_child_process4 = require("node:child_process");
+var import_node_crypto5 = __toESM(require("node:crypto"), 1);
 
 // ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -19312,7 +21285,7 @@ function compactSpecMarkdown(markdown, totalBudget, projectSlug, specWikiPageId)
     if (/^#{1,6}\s/.test(line)) {
       sections.push({ heading: line, body: [] });
     } else {
-      sections[sections.length - 1].body.push(line);
+      sections[sections.length - 1]?.body.push(line);
     }
   }
   const sectionCount = Math.max(1, sections.length);
@@ -20161,10 +22134,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path14) {
-  if (!path14)
+function getElementAtPath(obj, path15) {
+  if (!path15)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -20573,11 +22546,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path14, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -20724,16 +22697,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path14 = []) => {
+  const processError = (error52, path15 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -20760,17 +22733,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path14 = []) => {
+  const processError = (error52, path15 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -20802,8 +22775,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -33495,13 +35468,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -34901,7 +36874,15 @@ var executionRunIdParamSchema = external_exports.object({
 });
 var executionRunListFiltersSchema = external_exports.object({
   taskId: mrrlinTaskIdSchema.optional(),
-  status: mrrlinExecutionRunStatusSchema.optional()
+  status: mrrlinExecutionRunStatusSchema.optional(),
+  // Wire format is CSV (`statusIn=running,self_review`) so it survives the
+  // single-value URLSearchParams shape used by appendQuery. Empty CSV / empty
+  // array short-circuits to no rows at the DB layer.
+  statusIn: external_exports.preprocess((value) => {
+    if (typeof value === "string")
+      return value.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+    return value;
+  }, external_exports.array(mrrlinExecutionRunStatusSchema)).optional()
 });
 var mrrlinProjectSchedulerPolicySchema = external_exports.object({
   cadenceSeconds: external_exports.number().int().positive().nullable(),
@@ -35127,18 +37108,18 @@ function createMrrlinClient(config2) {
   const customFetch = config2.fetch ?? globalThis.fetch;
   const baseUrl = config2.baseUrl.replace(/\/$/, "");
   const token = config2.token;
-  async function request(path14, init) {
+  async function request(path15, init) {
     const method = init?.method ?? "GET";
     const headers = new Headers(init?.headers ?? {});
     if (token && !headers.has("authorization")) {
       headers.set("authorization", `Bearer ${token}`);
     }
-    const response = await customFetch(`${baseUrl}${path14}`, { ...init, headers });
+    const response = await customFetch(`${baseUrl}${path15}`, { ...init, headers });
     if (!response.ok) {
       const body = await response.text();
       let code = `HTTP_${response.status}`;
       let violations = null;
-      let message = `Mrrlin API ${method} ${path14} failed: ${response.status}`;
+      let message = `Mrrlin API ${method} ${path15} failed: ${response.status}`;
       try {
         const parsed = JSON.parse(body);
         const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
@@ -35158,7 +37139,7 @@ function createMrrlinClient(config2) {
       throw new MrrlinApiError({
         code,
         method,
-        path: path14,
+        path: path15,
         responseBody: body,
         status: response.status,
         violations,
@@ -35405,7 +37386,7 @@ function createMrrlinClient(config2) {
       return taskEventListResponseSchema.parse(body).data;
     },
     async listTasks(projectSlug, filters = {}) {
-      const path14 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
+      const path15 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
         assignee: filters.assignee,
         autonomyLevel: filters.autonomyLevel,
         blockedBy: filters.blockedBy,
@@ -35417,7 +37398,7 @@ function createMrrlinClient(config2) {
         subcategory: filters.subcategory,
         type: filters.type
       });
-      const body = await request(path14);
+      const body = await request(path15);
       return taskListResponseSchema.parse(body).data;
     },
     async listTaxonomy(projectSlug) {
@@ -35425,22 +37406,22 @@ function createMrrlinClient(config2) {
       return taxonomyListResponseSchema.parse(body).data;
     },
     async listWikiPages(projectSlug, filters = {}) {
-      const path14 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
+      const path15 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
         folder: filters.folder,
         q: filters.q,
         taskId: filters.taskId
       });
-      const body = await request(path14);
+      const body = await request(path15);
       return wikiPageListResponseSchema.parse(body).data;
     },
     async searchWikiPages(projectSlug, query) {
-      const path14 = appendQuery(`${projectPath(projectSlug)}/wiki/search`, {
+      const path15 = appendQuery(`${projectPath(projectSlug)}/wiki/search`, {
         folder: query.folder,
         limit: query.limit === void 0 ? void 0 : String(query.limit),
         pathPrefix: query.pathPrefix,
         q: query.q
       });
-      const body = await request(path14);
+      const body = await request(path15);
       return wikiPageSearchResponseSchema.parse(body).data;
     },
     async updatePlan(projectSlug, planId, patch) {
@@ -35499,7 +37480,10 @@ function createMrrlinClient(config2) {
     async listExecutionRuns(projectSlug, filters = {}) {
       const url2 = appendQuery(`${projectPath(projectSlug)}/execution-runs`, {
         taskId: filters.taskId,
-        status: filters.status
+        status: filters.status,
+        // Wire format mirrors the server-side preprocess in
+        // executionRunListFiltersSchema (CSV → array).
+        statusIn: filters.statusIn && filters.statusIn.length > 0 ? filters.statusIn.join(",") : void 0
       });
       const body = await request(url2);
       return executionRunListResponseSchema.parse(body).data;
@@ -35898,18 +37882,256 @@ function createServiceHealth() {
 // src/turn-lock.ts
 function createTurnLock() {
   let tail2 = Promise.resolve();
+  let active = 0;
   return {
     runExclusive(fn) {
+      active += 1;
       const run2 = tail2.then(() => fn());
       tail2 = run2.then(
         () => void 0,
         () => void 0
       );
+      run2.then(
+        () => {
+          active -= 1;
+        },
+        () => {
+          active -= 1;
+        }
+      );
       return run2;
-    }
+    },
+    activeCount: () => active
+  };
+}
+
+// src/self-update.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_semver = __toESM(require_semver2(), 1);
+var DEFAULT_INTERVAL_MS = 15 * 60 * 1e3;
+var DEFAULT_IDLE_MS = 2e3;
+var DEFAULT_REGISTRY_POLL_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_STARTUP_JITTER_MS = 30 * 1e3;
+var DEFAULT_COOLDOWN_MS = 48 * 60 * 60 * 1e3;
+var REGISTRY_URL_DEFAULT = "https://registry.npmjs.org/@mrrlin-dev/mcp/latest";
+var STRICT_SEMVER = /^\d+\.\d+\.\d+(-[A-Za-z0-9.-]+)?(\+[A-Za-z0-9.-]+)?$/;
+function isDisabled() {
+  return process.env.MRRLIN_DIRECTOR_BRIDGE_SELF_UPDATE === "0";
+}
+function readIntervalEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function sha256(buf) {
+  return (0, import_node_crypto.createHash)("sha256").update(buf).digest("hex");
+}
+function startSelfUpdate(deps) {
+  const log = deps.log ?? (() => {
+  });
+  const readFile2 = deps.readFileSyncImpl ?? ((p) => (0, import_node_fs.readFileSync)(p));
+  const setIntervalFn = deps.setIntervalImpl ?? setInterval;
+  const clearIntervalFn = deps.clearIntervalImpl ?? clearInterval;
+  const intervalMs = deps.intervalMs ?? readIntervalEnv("MRRLIN_DIRECTOR_BRIDGE_SELF_UPDATE_INTERVAL_MS", DEFAULT_INTERVAL_MS);
+  const idleThresholdMs = deps.idleThresholdMs ?? DEFAULT_IDLE_MS;
+  const setTimeoutFn = deps.setTimeoutImpl ?? setTimeout;
+  const clearTimeoutFn = deps.clearTimeoutImpl ?? clearTimeout;
+  const fetchFn = deps.fetchImpl ?? globalThis.fetch;
+  const pkgVersion = deps.pkgVersion ?? "0.0.0";
+  const registryUrl = deps.registryUrl ?? REGISTRY_URL_DEFAULT;
+  const registryPollIntervalMs = deps.registryPollIntervalMs ?? readIntervalEnv("MRRLIN_DIRECTOR_BRIDGE_REGISTRY_POLL_INTERVAL_MS", DEFAULT_REGISTRY_POLL_MS);
+  const startupJitterMs = deps.startupJitterMs ?? DEFAULT_STARTUP_JITTER_MS;
+  const cooldownMs = deps.cooldownMs ?? readIntervalEnv("MRRLIN_DIRECTOR_BRIDGE_UPDATE_COOLDOWN_MS", DEFAULT_COOLDOWN_MS);
+  const nowFn = deps.now ?? (() => Date.now());
+  const disabled = isDisabled();
+  let drainOnQuiet = false;
+  let shutdownCalled = false;
+  let latestVersion = null;
+  let lastUpdateMentionAt = null;
+  function maybeUpdateOffer() {
+    if (disabled) return null;
+    if (latestVersion === null) return null;
+    if (!import_semver.default.gt(latestVersion, pkgVersion)) return null;
+    if (lastUpdateMentionAt !== null && nowFn() - lastUpdateMentionAt < cooldownMs) return null;
+    lastUpdateMentionAt = nowFn();
+    log("info", "bridge.self_update.hint_injected", {
+      version: pkgVersion,
+      latestVersion
+    });
+    return `[bridge:update] An update for @mrrlin-dev/mcp is available: ${pkgVersion} \u2192 ${latestVersion}.
+
+This turn, at a natural pause, ASK the operator a yes/no question \u2014 e.g. "\u0411\u0430\u0447\u0443 \u0449\u043E bridge \u043D\u0430 ${pkgVersion}, \u043D\u0430 npm \u0443\u0436\u0435 ${latestVersion} \u2014 \u043E\u043D\u043E\u0432\u0438\u0442\u0438 \u0437\u0430\u0440\u0430\u0437? (\u0437\u0430\u043F\u0443\u0449\u0443 \`pnpm install -g @mrrlin-dev/mcp@latest\`)". Do NOT install without explicit confirmation.
+
+If the operator confirms (yes / \u0442\u0430\u043A / \u0430\u0433\u0430 / etc.): immediately run \`pnpm install -g @mrrlin-dev/mcp@latest\` via your shell tool and report the outcome in chat. After a successful install, the bridge auto-restarts via its self-update loop within a couple of minutes \u2014 you do NOT need to call pm2.
+
+If the operator declines / says "later": acknowledge briefly and do not bring it up again this turn. The bridge has a cooldown and will re-offer in 48h.
+
+If the install fails (permission denied, registry pinned, sudo required, network blocked): paste the error verbatim and show the operator the manual command \`pnpm install -g @mrrlin-dev/mcp@latest\` plus a one-line hint about likely cause.
+
+Do NOT derail the current task \u2014 if the operator has an in-flight question, answer that first; the update offer is a brief aside, not the main subject.`;
+  }
+  let startupBinSha = null;
+  try {
+    startupBinSha = sha256(readFile2(deps.binPath));
+  } catch (e) {
+    log("warn", "bridge.self_update.startup_hash_read_failed", {
+      err: String(e?.message ?? e)
+    });
+  }
+  log("info", "bridge.self_update.startup", {
+    binPath: deps.binPath,
+    startupBinSha: startupBinSha?.slice(0, 12) ?? null,
+    selfUpdateEnabled: !disabled,
+    intervalMs
+  });
+  async function pollRegistry() {
+    try {
+      const controller = new AbortController();
+      const t = setTimeout(() => controller.abort(), 5e3);
+      let res;
+      try {
+        res = await fetchFn(registryUrl, {
+          headers: { Accept: "application/json" },
+          signal: controller.signal
+        });
+      } finally {
+        clearTimeout(t);
+      }
+      if (!res.ok) {
+        log("debug", "bridge.self_update.registry_check_failed", {
+          statusCode: res.status,
+          errorKind: "http"
+        });
+        return;
+      }
+      let body;
+      try {
+        body = await res.json();
+      } catch {
+        log("debug", "bridge.self_update.registry_check_failed", { errorKind: "parse" });
+        return;
+      }
+      const candidate = body?.version;
+      if (typeof candidate !== "string" || !STRICT_SEMVER.test(candidate)) {
+        log("debug", "bridge.self_update.registry_check_failed", { errorKind: "format" });
+        return;
+      }
+      const wasStale = latestVersion ? import_semver.default.gt(latestVersion, pkgVersion) : false;
+      latestVersion = candidate;
+      log("debug", "bridge.self_update.registry_check_ok", { latestVersion: candidate });
+      const nowStale = import_semver.default.gt(candidate, pkgVersion);
+      if (nowStale && !wasStale) {
+        log("info", "bridge.self_update.update_available", {
+          version: pkgVersion,
+          latestVersion: candidate
+        });
+      }
+    } catch {
+      log("debug", "bridge.self_update.registry_check_failed", { errorKind: "network" });
+    }
+  }
+  let registryTimer = null;
+  let startupPollTimer = null;
+  if (!disabled) {
+    startupPollTimer = setTimeoutFn(() => {
+      void pollRegistry();
+    }, startupJitterMs);
+    const st = startupPollTimer;
+    if (st && typeof st.unref === "function") st.unref();
+    registryTimer = setIntervalFn(() => {
+      void pollRegistry();
+    }, registryPollIntervalMs);
+    const rt = registryTimer;
+    if (rt && typeof rt.unref === "function") rt.unref();
+  }
+  let timer = null;
+  if (!disabled) {
+    timer = setIntervalFn(() => {
+      try {
+        if (!startupBinSha) {
+          try {
+            startupBinSha = sha256(readFile2(deps.binPath));
+          } catch {
+            return;
+          }
+        }
+        let currentBinSha;
+        try {
+          currentBinSha = sha256(readFile2(deps.binPath));
+        } catch {
+          return;
+        }
+        if (currentBinSha !== startupBinSha) {
+          if (!drainOnQuiet) {
+            drainOnQuiet = true;
+            log("info", "bridge.self_update.hash_drift_detected", {
+              startupBinSha: startupBinSha.slice(0, 12),
+              currentBinSha: currentBinSha.slice(0, 12)
+            });
+          }
+        }
+        const driftConfirmed = startupBinSha !== null && currentBinSha !== startupBinSha;
+        if (drainOnQuiet && driftConfirmed && !shutdownCalled) {
+          const active = deps.getActiveTurnCount();
+          const idle = deps.getIdleMs();
+          if (active === 0 && idle >= idleThresholdMs) {
+            shutdownCalled = true;
+            log("info", "bridge.self_update.self_exit_for_reload", {});
+            try {
+              deps.shutdown();
+            } catch (e) {
+              log("error", "bridge.self_update.shutdown_threw", {
+                err: String(e?.message ?? e)
+              });
+            }
+          }
+        }
+      } catch (e) {
+        log("error", "bridge.self_update.tick_threw", {
+          err: String(e?.message ?? e)
+        });
+      }
+    }, intervalMs);
+    const t = timer;
+    if (t && typeof t.unref === "function") t.unref();
+  }
+  return {
+    stop: () => {
+      if (timer) {
+        clearIntervalFn(timer);
+        timer = null;
+      }
+      if (registryTimer) {
+        clearIntervalFn(registryTimer);
+        registryTimer = null;
+      }
+      if (startupPollTimer) {
+        clearTimeoutFn(startupPollTimer);
+        startupPollTimer = null;
+      }
+    },
+    requestDrain: () => {
+      if (disabled) {
+        log("warn", "bridge.self_update.signal_ignored_disabled", {});
+        return;
+      }
+      if (!drainOnQuiet) {
+        drainOnQuiet = true;
+        log("info", "bridge.self_update.signal_received", { signal: "SIGUSR2" });
+      }
+    },
+    getDrainOnQuiet: () => drainOnQuiet,
+    getLatestVersion: () => latestVersion,
+    isStale: () => latestVersion !== null && import_semver.default.gt(latestVersion, pkgVersion),
+    maybeUpdateOffer
   };
 }
 
+// src/_generated/version.ts
+var PKG_VERSION = "0.3.2";
+
 // src/api-base-url.ts
 var DEFAULT_API_BASE_URL = "http://127.0.0.1:8787";
 var STAGING_API_BASE_URL = "https://mrrlin-api-fnnzzz-fnnzzzs-projects.vercel.app";
@@ -35973,7 +38195,7 @@ async function resolveApiBaseUrlDynamic(opts = {}) {
 }
 
 // src/execution-consumer.ts
-var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_crypto2 = __toESM(require("node:crypto"), 1);
 
 // src/deploy-gate.ts
 var DEFAULT_DEPLOY_POLL_BUDGET_SECONDS = 1200;
@@ -36138,18 +38360,18 @@ async function awaitTurnWithDeadline(opts) {
 
 // src/worktree.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path3 = require("node:path");
 
 // src/checkout-lock.ts
-var import_node_fs = require("node:fs");
+var import_node_fs2 = require("node:fs");
 var import_node_path2 = require("node:path");
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 async function withCheckoutLock(locksDir, slug, fn) {
-  (0, import_node_fs.mkdirSync)(locksDir, { recursive: true });
+  (0, import_node_fs2.mkdirSync)(locksDir, { recursive: true });
   const target = (0, import_node_path2.join)(locksDir, `${slug}.lock`);
-  if (!(0, import_node_fs.existsSync)(target)) (0, import_node_fs.writeFileSync)(target, "");
+  if (!(0, import_node_fs2.existsSync)(target)) (0, import_node_fs2.writeFileSync)(target, "");
   const release = await import_proper_lockfile.default.lock(target, {
     retries: { retries: 600, factor: 1, minTimeout: 100, maxTimeout: 100 },
     stale: 5 * 6e4
@@ -36176,10 +38398,10 @@ function git(checkout, args) {
 async function createRunWorktree(opts) {
   const worktreePath = (0, import_node_path3.join)(opts.worktreeRoot, opts.slug, opts.runId);
   await withCheckoutLock(opts.locksDir, opts.slug, async () => {
-    (0, import_node_fs2.mkdirSync)(opts.worktreeRoot, { recursive: true });
+    (0, import_node_fs3.mkdirSync)(opts.worktreeRoot, { recursive: true });
     try {
       git(opts.checkout, ["fetch", "origin", opts.defaultBranch]);
-      if (!(0, import_node_fs2.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs3.existsSync)(worktreePath)) {
         git(opts.checkout, [
           "worktree",
           "add",
@@ -36237,15 +38459,15 @@ async function doPushRunBranch(opts, execGit) {
   if (localConfig.trim()) {
     throw new Error(`push aborted: agent-controlled git config present in worktree: ${localConfig.trim().split("\n")[0]}`);
   }
-  const dir = (0, import_node_fs2.mkdtempSync)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "mrrlin-push-"));
+  const dir = (0, import_node_fs3.mkdtempSync)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "mrrlin-push-"));
   const askpass = (0, import_node_path3.join)(dir, "askpass");
   try {
-    (0, import_node_fs2.writeFileSync)(
+    (0, import_node_fs3.writeFileSync)(
       askpass,
       '#!/bin/sh\ncase "$1" in *[Uu]sername*) printf %s "x-access-token" ;; *) printf %s "$MRRLIN_PUSH_TOKEN" ;; esac\n',
       { mode: 320 }
     );
-    (0, import_node_fs2.chmodSync)(askpass, 320);
+    (0, import_node_fs3.chmodSync)(askpass, 320);
     execGit(
       [
         "-C",
@@ -36264,7 +38486,7 @@ async function doPushRunBranch(opts, execGit) {
     );
     return { pushedSha: localSha };
   } finally {
-    (0, import_node_fs2.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs3.rmSync)(dir, { recursive: true, force: true });
   }
 }
 async function sweepOrphanWorktrees(opts) {
@@ -36369,7 +38591,7 @@ function isBridgeGeneratedArtifact(artifact) {
   return typeof payload === "object" && payload !== null && "event" in payload;
 }
 function newArtifactId() {
-  return `EA-${import_node_crypto.default.randomUUID()}`;
+  return `EA-${import_node_crypto2.default.randomUUID()}`;
 }
 async function gatherContext(client, projectSlug, task, openRunId) {
   const runs = (await client.listExecutionRuns(projectSlug, { taskId: task.id })).sort(
@@ -36500,7 +38722,7 @@ async function driveRun(deps, projectSlug, runId) {
   if (!claimed) return;
   if (!claimed.leaseId) {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto.default.randomUUID()}`,
+      id: `II-${import_node_crypto2.default.randomUUID()}`,
       kind: "handoff",
       taskId: claimed.taskId,
       body: `Execution run ${runId} was claimed but returned no leaseId. This indicates DB/API corruption and requires operator attention.`
@@ -36752,7 +38974,7 @@ async function notifyOperatorHandoff(deps, projectSlug, task, runId, reason) {
   }
   try {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto.default.randomUUID()}`,
+      id: `II-${import_node_crypto2.default.randomUUID()}`,
       kind: "handoff",
       taskId: task.id,
       body: `Execution run ${runId} for task ${task.id} (${task.title}) needs operator attention: ${reason}`
@@ -36828,7 +39050,7 @@ async function deployGateHandoff(deps, projectSlug, task, runId, reason, leaseId
   }).catch(() => {
   });
   await deps.client.createInboxItem(projectSlug, {
-    id: `II-${import_node_crypto.default.randomUUID()}`,
+    id: `II-${import_node_crypto2.default.randomUUID()}`,
     kind: "handoff",
     taskId: task.id,
     body: `Deploy gate for run ${runId} (task ${task.id} \u2014 ${task.title}) needs operator attention: ${reason}`
@@ -36844,7 +39066,7 @@ function claimIntervalMs() {
 }
 
 // src/async-job-consumer.ts
-var import_node_crypto2 = __toESM(require("node:crypto"), 1);
+var import_node_crypto3 = __toESM(require("node:crypto"), 1);
 
 // src/async-tools/registry.ts
 var registry2 = /* @__PURE__ */ new Map();
@@ -36922,7 +39144,7 @@ async function driveAsyncJob(deps, projectSlug, jobId) {
   });
   const delivery = descriptor2.onComplete(outcome, input);
   await deps.client.createInboxItem(projectSlug, {
-    id: `II-${import_node_crypto2.default.randomUUID()}`,
+    id: `II-${import_node_crypto3.default.randomUUID()}`,
     kind: delivery.kind,
     body: delivery.body
   }).catch(() => {
@@ -37038,7 +39260,7 @@ function codexIdleMs() {
 }
 
 // src/operator-token.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_node_os3 = __toESM(require("node:os"), 1);
 var import_node_path4 = __toESM(require("node:path"), 1);
 function operatorDir() {
@@ -37050,7 +39272,7 @@ function operatorTokenPath() {
 }
 function readOperatorToken() {
   try {
-    const token = (0, import_node_fs3.readFileSync)(operatorTokenPath(), "utf8").trim();
+    const token = (0, import_node_fs4.readFileSync)(operatorTokenPath(), "utf8").trim();
     return token.length > 0 ? token : null;
   } catch {
     return null;
@@ -37058,8 +39280,8 @@ function readOperatorToken() {
 }
 function persistOperatorToken(token) {
   const dir = operatorDir();
-  (0, import_node_fs3.mkdirSync)(dir, { recursive: true, mode: 448 });
-  (0, import_node_fs3.writeFileSync)(operatorTokenPath(), `${token.trim()}
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs4.writeFileSync)(operatorTokenPath(), `${token.trim()}
 `, { encoding: "utf8", mode: 384 });
 }
 function agentCredentialPath() {
@@ -37067,15 +39289,15 @@ function agentCredentialPath() {
 }
 function persistAgentSecret(secret) {
   const dir = operatorDir();
-  (0, import_node_fs3.mkdirSync)(dir, { recursive: true, mode: 448 });
-  (0, import_node_fs3.writeFileSync)(agentCredentialPath(), `${secret.trim()}
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs4.writeFileSync)(agentCredentialPath(), `${secret.trim()}
 `, { encoding: "utf8", mode: 384 });
 }
 function readAgentSecret() {
   const fromEnv = process.env.MRRLIN_AGENT_SECRET?.trim();
   if (fromEnv) return fromEnv;
   try {
-    const raw = (0, import_node_fs3.readFileSync)(agentCredentialPath(), "utf8").trim();
+    const raw = (0, import_node_fs4.readFileSync)(agentCredentialPath(), "utf8").trim();
     return raw || void 0;
   } catch {
     return void 0;
@@ -37083,7 +39305,7 @@ function readAgentSecret() {
 }
 
 // src/thread-index.ts
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_node_path5 = __toESM(require("node:path"), 1);
 function threadIndexPath(stateDir) {
   return import_node_path5.default.join(stateDir, "threads.json");
@@ -37092,7 +39314,7 @@ function loadThreadIndex(stateDir, ttlMs, now) {
   const result = /* @__PURE__ */ new Map();
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs4.readFileSync)(threadIndexPath(stateDir), "utf8"));
+    parsed = JSON.parse((0, import_node_fs5.readFileSync)(threadIndexPath(stateDir), "utf8"));
   } catch {
     return result;
   }
@@ -37114,8 +39336,8 @@ function loadThreadIndex(stateDir, ttlMs, now) {
   return result;
 }
 function saveThreadIndex(stateDir, entries) {
-  (0, import_node_fs4.mkdirSync)(stateDir, { recursive: true, mode: 448 });
-  (0, import_node_fs4.writeFileSync)(threadIndexPath(stateDir), `${JSON.stringify(Object.fromEntries(entries), null, 2)}
+  (0, import_node_fs5.mkdirSync)(stateDir, { recursive: true, mode: 448 });
+  (0, import_node_fs5.writeFileSync)(threadIndexPath(stateDir), `${JSON.stringify(Object.fromEntries(entries), null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -37169,8 +39391,8 @@ function chatTurnMaxMs() {
 }
 
 // src/worker-token.ts
-var import_node_crypto3 = require("node:crypto");
-var import_node_fs5 = require("node:fs");
+var import_node_crypto4 = require("node:crypto");
+var import_node_fs6 = require("node:fs");
 var import_node_os4 = __toESM(require("node:os"), 1);
 var import_node_path6 = __toESM(require("node:path"), 1);
 var DEFAULT_WORKER_PORT = 8792;
@@ -37189,7 +39411,7 @@ function workerTokenPath() {
 }
 function readWorkerToken() {
   try {
-    const token = (0, import_node_fs5.readFileSync)(workerTokenPath(), "utf8").trim();
+    const token = (0, import_node_fs6.readFileSync)(workerTokenPath(), "utf8").trim();
     return token.length > 0 ? token : null;
   } catch {
     return null;
@@ -37199,16 +39421,16 @@ function readOrCreateWorkerToken() {
   const existing = readWorkerToken();
   if (existing) return existing;
   const dir = workerDir();
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
-  const token = (0, import_node_crypto3.randomBytes)(32).toString("hex");
-  (0, import_node_fs5.writeFileSync)(workerTokenPath(), `${token}
+  (0, import_node_fs6.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const token = (0, import_node_crypto4.randomBytes)(32).toString("hex");
+  (0, import_node_fs6.writeFileSync)(workerTokenPath(), `${token}
 `, { encoding: "utf8", mode: 384 });
   return token;
 }
 
 // src/remote-phone-relay.ts
 var import_node_events2 = require("node:events");
-var import_node_fs6 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 var import_node_os5 = require("node:os");
 var import_node_path7 = require("node:path");
 
@@ -37673,7 +39895,7 @@ var SHA256 = class extends SHA2 {
     this.buffer.fill(0);
   }
 };
-var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+var sha2562 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
 // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/utils.js
 var _0n = BigInt(0);
@@ -37817,7 +40039,7 @@ function validateObject(object3, validators, optValidators = {}) {
 // ../../packages/director-e2e/dist/verifier.js
 var RELAY_AUTH_LABEL = utf8ToBytes("relay-auth");
 function relayAuth(secret) {
-  return hmac(sha256, secret, RELAY_AUTH_LABEL);
+  return hmac(sha2562, secret, RELAY_AUTH_LABEL);
 }
 
 // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/_u64.js
@@ -39151,16 +41373,16 @@ var hkdf = (hash3, ikm, salt, info, length) => expand(hash3, extract(hash3, ikm,
 
 // ../../packages/director-e2e/dist/kdf.js
 function deriveMasterKey(ikm, salt, info) {
-  return hkdf(sha256, ikm, salt, info, 32);
+  return hkdf(sha2562, ikm, salt, info, 32);
 }
 function deriveDirectionKeys(masterKey) {
   return {
-    p2a: hkdf(sha256, masterKey, void 0, utf8ToBytes("dir:phone->agent"), 32),
-    a2p: hkdf(sha256, masterKey, void 0, utf8ToBytes("dir:agent->phone"), 32)
+    p2a: hkdf(sha2562, masterKey, void 0, utf8ToBytes("dir:phone->agent"), 32),
+    a2p: hkdf(sha2562, masterKey, void 0, utf8ToBytes("dir:agent->phone"), 32)
   };
 }
 function confirmationMac(masterKey, role, transcript) {
-  return hmac(sha256, masterKey, concatBytes(utf8ToBytes(`confirm:${role}`), transcript));
+  return hmac(sha2562, masterKey, concatBytes(utf8ToBytes(`confirm:${role}`), transcript));
 }
 
 // ../../node_modules/.pnpm/@noble+ciphers@0.4.1/node_modules/@noble/ciphers/esm/utils.js
@@ -40777,9 +42999,9 @@ var DirectorRelay = class {
 
 // src/remote-phone-relay.ts
 function loadOrCreateAgentDeviceKey() {
-  const path14 = (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin", "agent-device-key");
+  const path15 = (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin", "agent-device-key");
   try {
-    const raw = JSON.parse((0, import_node_fs6.readFileSync)(path14, "utf8"));
+    const raw = JSON.parse((0, import_node_fs7.readFileSync)(path15, "utf8"));
     if (typeof raw.priv === "string" && typeof raw.pub === "string") {
       return { privateKey: fromBase64Url(raw.priv), publicKey: fromBase64Url(raw.pub) };
     }
@@ -40787,9 +43009,9 @@ function loadOrCreateAgentDeviceKey() {
   }
   const kp = generateIdentityKeyPair();
   try {
-    (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin"), { recursive: true });
-    (0, import_node_fs6.writeFileSync)(
-      path14,
+    (0, import_node_fs7.mkdirSync)((0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs7.writeFileSync)(
+      path15,
       JSON.stringify({ priv: toBase64Url(kp.privateKey), pub: toBase64Url(kp.publicKey) }),
       { mode: 384 }
     );
@@ -40800,7 +43022,7 @@ function loadOrCreateAgentDeviceKey() {
 var AGENT_PAIRING_PATH = (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin", "agent-pairing.json");
 function loadAgentPairing() {
   try {
-    const raw = JSON.parse((0, import_node_fs6.readFileSync)(AGENT_PAIRING_PATH, "utf8"));
+    const raw = JSON.parse((0, import_node_fs7.readFileSync)(AGENT_PAIRING_PATH, "utf8"));
     if (typeof raw.channelId === "string" && typeof raw.agentControlSecret === "string" && typeof raw.relayAuth === "string" && typeof raw.peerIdentityKey === "string") {
       return {
         channelId: raw.channelId,
@@ -40815,8 +43037,8 @@ function loadAgentPairing() {
 }
 function saveAgentPairing(record2) {
   try {
-    (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin"), { recursive: true });
-    (0, import_node_fs6.writeFileSync)(AGENT_PAIRING_PATH, JSON.stringify(record2), { mode: 384 });
+    (0, import_node_fs7.mkdirSync)((0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs7.writeFileSync)(AGENT_PAIRING_PATH, JSON.stringify(record2), { mode: 384 });
   } catch {
   }
 }
@@ -40985,18 +43207,18 @@ async function renderPairingQrSvg(payload) {
 }
 
 // src/checkout-registry.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var import_node_path8 = require("node:path");
 var CheckoutRegistry = class {
   file;
   constructor(stateDir) {
     this.file = (0, import_node_path8.join)(stateDir, "checkouts.json");
-    (0, import_node_fs7.mkdirSync)(stateDir, { recursive: true });
+    (0, import_node_fs8.mkdirSync)(stateDir, { recursive: true });
   }
   read() {
-    if (!(0, import_node_fs7.existsSync)(this.file)) return {};
+    if (!(0, import_node_fs8.existsSync)(this.file)) return {};
     try {
-      return JSON.parse((0, import_node_fs7.readFileSync)(this.file, "utf8"));
+      return JSON.parse((0, import_node_fs8.readFileSync)(this.file, "utf8"));
     } catch {
       return {};
     }
@@ -41004,15 +43226,15 @@ var CheckoutRegistry = class {
   get(slug) {
     return this.read()[slug] ?? null;
   }
-  confirm(slug, path14, now) {
+  confirm(slug, path15, now) {
     const all = this.read();
-    all[slug] = { path: path14, confirmedAt: now };
-    (0, import_node_fs7.writeFileSync)(this.file, JSON.stringify(all, null, 2));
+    all[slug] = { path: path15, confirmedAt: now };
+    (0, import_node_fs8.writeFileSync)(this.file, JSON.stringify(all, null, 2));
   }
 };
 
 // src/executor-server.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_os6 = require("node:os");
 var import_node_path9 = require("node:path");
 var DENY_READ_GLOBS = [
@@ -41065,7 +43287,7 @@ function isSecretDirectoryPath(p) {
 }
 function writeExecutorCodexHome(scratchDir, opts) {
   const codexHome = (0, import_node_path9.join)(scratchDir, ".codex");
-  (0, import_node_fs8.mkdirSync)(codexHome, { recursive: true });
+  (0, import_node_fs9.mkdirSync)(codexHome, { recursive: true });
   const hasEgress = opts.egressDomains.length > 0;
   const networkSection = hasEgress ? [
     "[permissions.executor.network]",
@@ -41100,21 +43322,21 @@ function writeExecutorCodexHome(scratchDir, opts) {
     networkSection,
     ""
   ].join("\n");
-  (0, import_node_fs8.writeFileSync)((0, import_node_path9.join)(codexHome, "config.toml"), toml3, "utf8");
+  (0, import_node_fs9.writeFileSync)((0, import_node_path9.join)(codexHome, "config.toml"), toml3, "utf8");
   return codexHome;
 }
 async function startExecutorServer(opts) {
   const egressDomains = opts.egressDomains ?? DEFAULT_EGRESS_DOMAINS;
   const realHome = (0, import_node_os6.homedir)();
   const denySecretPaths = operatorSecretPaths(realHome);
-  const scratchDir = (0, import_node_fs8.mkdtempSync)((0, import_node_path9.join)((0, import_node_os6.tmpdir)(), "mrrlin-executor-"));
+  const scratchDir = (0, import_node_fs9.mkdtempSync)((0, import_node_path9.join)((0, import_node_os6.tmpdir)(), "mrrlin-executor-"));
   const scratchHome = scratchDir;
   let scratchCleaned = false;
   const cleanScratch = () => {
     if (scratchCleaned) return;
     scratchCleaned = true;
     try {
-      (0, import_node_fs8.rmSync)(scratchDir, { recursive: true, force: true });
+      (0, import_node_fs9.rmSync)(scratchDir, { recursive: true, force: true });
     } catch {
     }
   };
@@ -41305,7 +43527,7 @@ function extractVerificationSection(markdown) {
 }
 
 // src/bridge-log.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_node_path10 = require("node:path");
 
 // src/redact.ts
@@ -41344,8 +43566,8 @@ var IMAGE_DATA_URI_RE = /^(data:image\/[a-zA-Z0-9.+-]+;base64,)([A-Za-z0-9+/=]+)
 function redactImageDataUri(value) {
   const m = value.match(IMAGE_DATA_URI_RE);
   if (!m) return value;
-  const prefix = m[1];
-  const body = m[2];
+  const [, prefix, body] = m;
+  if (prefix === void 0 || body === void 0) return value;
   return `${prefix}\u2026(${body.length} bytes)`;
 }
 function redactValue(value, depth) {
@@ -41393,7 +43615,7 @@ function createBridgeLogger(stateDir, env = process.env) {
   if (!resolveBridgeLogEnabled(env)) return NOOP_LOGGER;
   const logsDir = (0, import_node_path10.join)(stateDir, "logs");
   try {
-    (0, import_node_fs9.mkdirSync)(logsDir, { recursive: true });
+    (0, import_node_fs10.mkdirSync)(logsDir, { recursive: true });
   } catch {
     return NOOP_LOGGER;
   }
@@ -41410,7 +43632,7 @@ function createBridgeLogger(stateDir, env = process.env) {
         ...rec.ms !== void 0 ? { ms: rec.ms } : {},
         payload: redactMessage(rec.payload, { includePrompts })
       }) + "\n";
-      (0, import_node_fs9.appendFileSync)(fileFor(), line);
+      (0, import_node_fs10.appendFileSync)(fileFor(), line);
     } catch {
     }
   };
@@ -41422,6 +43644,336 @@ function createBridgeLogger(stateDir, env = process.env) {
   };
 }
 
+// src/issue-report.ts
+var import_node_fs11 = require("node:fs");
+var import_node_os7 = require("node:os");
+var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_child_process3 = require("node:child_process");
+var TELEGRAM_BOT_TOKEN = "8506614214:AAGyhO1phWb7ah2aN6_gAX2Co7OXNN3zb0A";
+var TELEGRAM_CHAT_ID = "-5373779177";
+function summarizeTranscript(entries = []) {
+  const normalized = entries.map((entry) => ({
+    kind: entry.kind,
+    content: squashWhitespace(entry.content)
+  })).filter((entry) => entry.content.length > 0);
+  if (normalized.length <= 20) return normalized;
+  return normalized.slice(normalized.length - 20);
+}
+function squashWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function clip(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+function firstSentence(value) {
+  const trimmed = squashWhitespace(value);
+  if (!trimmed) return "";
+  const match = trimmed.match(/^(.{1,120}?[.!?])(?:\s|$)/);
+  return match?.[1] ? squashWhitespace(match[1]) : clip(trimmed, 120);
+}
+function describePayload(payload) {
+  if (typeof payload === "string") return payload;
+  try {
+    return JSON.stringify(payload);
+  } catch {
+    return String(payload);
+  }
+}
+function resolveLogDir() {
+  const codexHome = process.env.CODEX_HOME?.trim();
+  if (codexHome) {
+    const candidate = import_node_path11.default.join(codexHome, "mrrlin", "director-bridge", "logs");
+    if (existsDir(candidate)) return candidate;
+  }
+  const fallback = import_node_path11.default.join((0, import_node_os7.homedir)(), ".mrrlin", "director-bridge", "logs");
+  return fallback;
+}
+function existsDir(candidate) {
+  try {
+    return (0, import_node_fs11.statSync)(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function listRecentLogFiles(logDir) {
+  if (!existsDir(logDir)) return [];
+  return (0, import_node_fs11.readdirSync)(logDir).filter((name) => /^bridge-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name)).sort((a, b) => b.localeCompare(a)).slice(0, 3).map((name) => import_node_path11.default.join(logDir, name));
+}
+function parseLogFile(file2) {
+  const lines2 = (0, import_node_fs11.readFileSync)(file2, "utf8").split(/\r?\n/).filter(Boolean);
+  const parsed = [];
+  for (const rawLine of lines2) {
+    try {
+      const raw = JSON.parse(rawLine);
+      if (typeof raw.ts !== "string" || typeof raw.type !== "string" || typeof raw.spanId !== "string") continue;
+      parsed.push({
+        ts: raw.ts,
+        dir: raw.dir === "in" ? "in" : "out",
+        spanId: raw.spanId,
+        sessionId: typeof raw.sessionId === "string" ? raw.sessionId : null,
+        type: raw.type,
+        ms: typeof raw.ms === "number" ? raw.ms : void 0,
+        payload: raw.payload,
+        rawLine,
+        file: file2
+      });
+    } catch {
+    }
+  }
+  return parsed;
+}
+function looksLikeError(record2) {
+  if (record2.type === "error" || record2.type === "<parse-error>") return true;
+  const text = `${record2.type} ${describePayload(record2.payload)}`.toLowerCase();
+  return /(^|[^a-z])(error|failed|failure|timed out|timeout|unauthorized|forbidden|invalid|closed before returning a reply)([^a-z]|$)/.test(
+    text
+  );
+}
+function buildKeywordSet(input) {
+  return Array.from(
+    new Set(
+      input.toLowerCase().split(/[^a-z0-9_:-]+/).map((part) => part.trim()).filter((part) => part.length >= 4)
+    )
+  ).slice(0, 8);
+}
+function pickCluster(records, index) {
+  const from = Math.max(0, index - 10);
+  const to = Math.min(records.length, index + 31);
+  return records.slice(from, to);
+}
+function findRelevantLogWindow(request, opts = {}) {
+  const logDir = opts.logDir ?? resolveLogDir();
+  const files = listRecentLogFiles(logDir);
+  if (files.length === 0) {
+    return { strategy: "no-log", matchedOn: "(log directory missing or empty)", records: [], file: null };
+  }
+  const allRecords = files.flatMap((file2) => parseLogFile(file2));
+  if (allRecords.length === 0) {
+    return { strategy: "no-log", matchedOn: "(no readable JSONL records)", records: [], file: files[0] ?? null };
+  }
+  const directorSessionId = request.directorSessionId?.trim() || "";
+  if (directorSessionId) {
+    const sessionRecords = allRecords.filter((record2) => record2.sessionId === directorSessionId);
+    if (sessionRecords.length > 0) {
+      for (let index = sessionRecords.length - 1; index >= 0; index -= 1) {
+        const record2 = sessionRecords[index];
+        if (!record2 || !looksLikeError(record2)) continue;
+        const cluster = pickCluster(sessionRecords, index);
+        return {
+          strategy: "session-error-cluster",
+          matchedOn: clip(record2.rawLine, 160),
+          records: cluster,
+          file: record2.file
+        };
+      }
+      return {
+        strategy: "session-tail",
+        matchedOn: `directorSessionId=${directorSessionId}`,
+        records: sessionRecords.slice(Math.max(0, sessionRecords.length - 30)),
+        file: sessionRecords.at(-1)?.file ?? null
+      };
+    }
+  }
+  const description = request.customerDescription.trim();
+  const keywords = buildKeywordSet(description);
+  if (keywords.length > 0) {
+    for (let index = allRecords.length - 1; index >= 0; index -= 1) {
+      const record2 = allRecords[index];
+      if (!record2) continue;
+      const haystack = `${record2.type} ${describePayload(record2.payload)}`.toLowerCase();
+      if (!keywords.some((keyword) => haystack.includes(keyword))) continue;
+      return {
+        strategy: "hint-cluster",
+        matchedOn: clip(record2.rawLine, 160),
+        records: pickCluster(allRecords, index),
+        file: record2.file
+      };
+    }
+  }
+  for (let index = allRecords.length - 1; index >= 0; index -= 1) {
+    const record2 = allRecords[index];
+    if (!record2 || !looksLikeError(record2)) continue;
+    return {
+      strategy: "global-error-tail",
+      matchedOn: clip(record2.rawLine, 160),
+      records: pickCluster(allRecords, index),
+      file: record2.file
+    };
+  }
+  const tail2 = allRecords.slice(Math.max(0, allRecords.length - 30));
+  return {
+    strategy: "global-error-tail",
+    matchedOn: "(no error cluster; using global tail)",
+    records: tail2,
+    file: tail2.at(-1)?.file ?? null
+  };
+}
+function formatTranscript(entries) {
+  if (entries.length === 0) return "(no transcript context)";
+  return entries.map((entry) => `- ${entry.kind}: ${clip(redact(entry.content), 400)}`).join("\n");
+}
+function formatLogWindow(window) {
+  if (window.records.length === 0) return "(no relevant bridge log lines found)";
+  const preferred = window.records.filter((record2) => looksLikeError(record2)).concat(window.records.filter((record2) => !looksLikeError(record2)));
+  const unique = preferred.filter((record2, index, array2) => array2.findIndex((item) => item.rawLine === record2.rawLine) === index);
+  return clip(
+    unique.map((record2) => {
+      const payload = clip(redact(describePayload(record2.payload)), 360);
+      return `${record2.ts} ${record2.dir} ${record2.type} span=${record2.spanId}${record2.sessionId ? ` session=${record2.sessionId}` : ""} ${payload}`;
+    }).join("\n"),
+    5e3
+  );
+}
+function titlePrefix(source) {
+  return source === "shell-menu" ? "[Web]" : "[Director]";
+}
+function plainTitle(title) {
+  return title.replace(/^\[[^\]]+\]\s*/, "").trim();
+}
+function buildIssueDraft(request, logWindow) {
+  const customerDescription = clip(redact(request.customerDescription.trim() || "(not provided)"), 4e3);
+  const titleStem = firstSentence(customerDescription) || firstSentence(logWindow.records.find((record2) => looksLikeError(record2))?.rawLine ?? "") || "Issue report";
+  const title = clip(`${titlePrefix(request.source)} ${titleStem}`, 96);
+  const transcript = summarizeTranscript(request.transcript ?? []);
+  const screenshotLines = request.screenshots && request.screenshots.length > 0 ? request.screenshots.map((shot) => `- [${shot.filename}](${shot.url})`).join("\n") : "(no screenshots)";
+  const environment = [
+    `- Created at (UTC): ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `- Source: ${request.source}`,
+    `- Project: ${request.projectSlug?.trim() || "(unknown)"}`,
+    `- Route: ${request.urlPath?.trim() || "(unknown)"}`,
+    `- Director session: ${request.directorSessionId?.trim() || "(none)"}`,
+    `- @mrrlin-dev/mcp: ${PKG_VERSION}`,
+    `- OS: ${(0, import_node_os7.platform)()}`,
+    `- Node: ${process.version}`
+  ].join("\n");
+  const logLabel = logWindow.file ? import_node_path11.default.basename(logWindow.file) : "(none)";
+  const body = [
+    "## Summary",
+    `${titlePrefix(request.source)} issue report generated from local Mrrlin evidence.`,
+    "",
+    "## Customer report",
+    customerDescription,
+    "",
+    "## Observed behavior",
+    `- Log search strategy: ${logWindow.strategy}`,
+    `- Matched on: ${redact(logWindow.matchedOn)}`,
+    "",
+    "## Director / shell context",
+    environment,
+    "",
+    `## Bridge log excerpt (${logLabel})`,
+    "```text",
+    formatLogWindow(logWindow),
+    "```",
+    "",
+    "## Transcript excerpt",
+    "```text",
+    formatTranscript(transcript),
+    "```",
+    "",
+    "## Screenshots",
+    screenshotLines
+  ].join("\n");
+  return { title, body, labels: ["bug"] };
+}
+function buildTelegramAnnouncement(request, draft, issueUrl) {
+  const summary = firstSentence(redact(request.customerDescription.trim())) || firstSentence(plainTitle(draft.title)) || "\u043D\u0435\u0432\u0456\u0434\u0442\u0432\u043E\u0440\u0435\u043D\u0430 \u043F\u0440\u043E\u0431\u043B\u0435\u043C\u0430";
+  return `\u0437\u0430\u0440\u0435\u043F\u043E\u0440\u0447\u0435\u043D\u043E \u043D\u043E\u0432\u0438\u0439 \u0431\u0430\u0433, \u043A\u043E\u0440\u043E\u0442\u043A\u043E: ${clip(summary, 280)}
+${issueUrl}`;
+}
+function ensureGhReady() {
+  const auth = (0, import_node_child_process3.spawnSync)("gh", ["auth", "status", "-h", "github.com"], { encoding: "utf8" });
+  if (auth.status !== 0) {
+    const detail = (auth.stderr || auth.stdout || "gh auth status failed").trim();
+    throw new Error(`GitHub CLI is not ready: ${detail}`);
+  }
+}
+function createGithubIssue(draft) {
+  ensureGhReady();
+  const tmpDir = (0, import_node_fs11.mkdtempSync)(import_node_path11.default.join((0, import_node_os7.tmpdir)(), "mrrlin-issue-"));
+  const bodyFile = import_node_path11.default.join(tmpDir, "issue-body.md");
+  try {
+    (0, import_node_fs11.writeFileSync)(bodyFile, draft.body, "utf8");
+    const args = ["issue", "create", "--repo", "fnnzzz/mrrlin", "--title", draft.title, "--body-file", bodyFile];
+    for (const label of draft.labels) args.push("--label", label);
+    const result = (0, import_node_child_process3.spawnSync)("gh", args, { encoding: "utf8" });
+    if (result.status !== 0) {
+      const detail = (result.stderr || result.stdout || "gh issue create failed").trim();
+      throw new Error(detail);
+    }
+    const url2 = (result.stdout || "").trim().split(/\s+/).at(-1) ?? "";
+    if (!/^https?:\/\//.test(url2)) {
+      throw new Error(`Issue created but URL could not be parsed from gh output: ${result.stdout.trim()}`);
+    }
+    const numberMatch = url2.match(/\/issues\/(\d+)$/);
+    return { issueNumber: numberMatch ? Number(numberMatch[1]) : null, url: url2 };
+  } finally {
+    (0, import_node_fs11.rmSync)(tmpDir, { recursive: true, force: true });
+  }
+}
+function sendTelegramAnnouncement(text) {
+  const tmpDir = (0, import_node_fs11.mkdtempSync)(import_node_path11.default.join((0, import_node_os7.tmpdir)(), "mrrlin-issue-telegram-"));
+  const bodyFile = import_node_path11.default.join(tmpDir, "telegram-body.json");
+  try {
+    (0, import_node_fs11.writeFileSync)(
+      bodyFile,
+      JSON.stringify({
+        chat_id: TELEGRAM_CHAT_ID,
+        text,
+        disable_web_page_preview: true
+      }),
+      "utf8"
+    );
+    const result = (0, import_node_child_process3.spawnSync)(
+      "curl",
+      [
+        "-sS",
+        "-X",
+        "POST",
+        `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage`,
+        "-H",
+        "Content-Type: application/json",
+        "--data-binary",
+        `@${bodyFile}`
+      ],
+      { encoding: "utf8" }
+    );
+    if (result.error) {
+      return `Telegram announce failed: ${result.error.message}`;
+    }
+    if (result.status !== 0) {
+      const detail = (result.stderr || result.stdout || "curl failed").trim();
+      return `Telegram announce failed: ${detail}`;
+    }
+    let parsed = null;
+    try {
+      parsed = JSON.parse(result.stdout || "{}");
+    } catch {
+      return `Telegram announce failed: could not parse response: ${result.stdout.trim()}`;
+    }
+    if (!parsed?.ok) {
+      return `Telegram announce failed: ${parsed?.description || "unknown Telegram error"}`;
+    }
+    return null;
+  } finally {
+    (0, import_node_fs11.rmSync)(tmpDir, { recursive: true, force: true });
+  }
+}
+function fileIssueReport(request, opts = {}) {
+  const logWindow = findRelevantLogWindow(request, opts);
+  const draft = buildIssueDraft(request, logWindow);
+  const created = createGithubIssue(draft);
+  const telegramWarning = sendTelegramAnnouncement(buildTelegramAnnouncement(request, draft, created.url));
+  return {
+    issueNumber: created.issueNumber,
+    title: draft.title,
+    url: created.url,
+    telegramDelivered: telegramWarning === null,
+    telegramWarning
+  };
+}
+
 // src/director-bridge.ts
 var DEFAULT_DIRECTOR_BRIDGE_ALLOWED_ORIGINS = [
   "http://localhost:*",
@@ -41443,10 +43995,46 @@ function normalizeModel(value) {
   const trimmed = value.trim();
   return trimmed ? trimmed : null;
 }
+function normalizeIssueTranscript(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) return { error: "transcript must be an array." };
+  const transcript = [];
+  for (const entry of value.slice(0, 20)) {
+    if (!entry || typeof entry !== "object") return { error: "transcript entries must be objects." };
+    const kind = entry.kind;
+    const content = entry.content;
+    if (kind !== "user" && kind !== "assistant" && kind !== "error" && kind !== "tool") {
+      return { error: "transcript entry kind is invalid." };
+    }
+    if (typeof content !== "string") return { error: "transcript entry content must be a string." };
+    const trimmed = content.trim();
+    if (!trimmed) continue;
+    transcript.push({ kind, content: trimmed });
+  }
+  return transcript;
+}
+function normalizeIssueScreenshots(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) return { error: "screenshots must be an array." };
+  const screenshots = [];
+  for (const entry of value.slice(0, 3)) {
+    if (!entry || typeof entry !== "object") return { error: "screenshots entries must be objects." };
+    const filename = entry.filename;
+    const url2 = entry.url;
+    if (typeof filename !== "string" || !filename.trim()) {
+      return { error: "screenshot filename is required." };
+    }
+    if (typeof url2 !== "string" || !/^https?:\/\//.test(url2)) {
+      return { error: "screenshot url must be an absolute http(s) URL." };
+    }
+    screenshots.push({ filename: filename.trim(), url: url2.trim() });
+  }
+  return screenshots;
+}
 function neutralCheckoutCwd(stateDir) {
-  const dir = import_node_path11.default.join(stateDir, "no-checkout");
+  const dir = import_node_path12.default.join(stateDir, "no-checkout");
   try {
-    import_node_fs10.default.mkdirSync(dir, { recursive: true });
+    import_node_fs12.default.mkdirSync(dir, { recursive: true });
   } catch {
   }
   return dir;
@@ -41584,6 +44172,7 @@ function tokenRefreshIntervalMs() {
   return seconds * 1e3;
 }
 var COLLECTED_TURN_TIMEOUT_MS = 3e5;
+var DEFAULT_IMAGE_ONLY_PROMPT = "Look at the attached image.";
 var VERIFICATION_BASE_INSTRUCTIONS = [
   "You are a deployment verification agent. You may ONLY make read-only HTTP requests to the",
   "single allowlisted environment URL to confirm a deploy succeeded. You have NO repository,",
@@ -41637,7 +44226,7 @@ function resolveDefaultBranch(checkoutPath) {
   if (!checkoutPath) return "main";
   const runGit = (args) => {
     try {
-      return (0, import_node_child_process3.execFileSync)("git", ["-C", checkoutPath, ...args], {
+      return (0, import_node_child_process4.execFileSync)("git", ["-C", checkoutPath, ...args], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
         timeout: 15e3,
@@ -41669,7 +44258,7 @@ async function runOrphanWorktreeSweep(client, opts) {
   const cutoff = Date.now() - worktreeRetentionMs();
   const isReapable = (worktreePath) => {
     try {
-      return import_node_fs10.default.statSync(worktreePath).mtimeMs < cutoff;
+      return import_node_fs12.default.statSync(worktreePath).mtimeMs < cutoff;
     } catch {
       return false;
     }
@@ -41706,8 +44295,8 @@ async function runOrphanWorktreeSweep(client, opts) {
   }
 }
 function readStateDir() {
-  if (process.env.CODEX_HOME) return import_node_path11.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
-  return import_node_path11.default.join(import_node_os7.default.homedir(), ".mrrlin", "director-bridge");
+  if (process.env.CODEX_HOME) return import_node_path12.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
+  return import_node_path12.default.join(import_node_os8.default.homedir(), ".mrrlin", "director-bridge");
 }
 function readAllowedOrigins() {
   const raw = (process.env.MRRLIN_DIRECTOR_BRIDGE_ALLOWED_ORIGINS ?? "").trim();
@@ -41782,7 +44371,7 @@ function createBridgeRequestListener(opts) {
         res.end(JSON.stringify({ ok: false, error: "Origin not allowed." }));
         return;
       }
-      const nonce = import_node_crypto4.default.randomBytes(16).toString("base64url");
+      const nonce = import_node_crypto5.default.randomBytes(16).toString("base64url");
       res.writeHead(200, { "content-type": "application/json" });
       res.end(JSON.stringify({ ok: true, wsUrl: `ws://${host}:${port}/ws`, token, nonce }));
       return;
@@ -41795,7 +44384,7 @@ function sessionIdOf(msg) {
   return typeof id === "string" ? id : null;
 }
 function attachBridgeWss(server, opts) {
-  const { token, allowedOrigins, onReady, logger, onPaired } = opts;
+  const { token, allowedOrigins, onReady, logger, onPaired, selfUpdate } = opts;
   const wss = new import_websocket_server.default({ server, path: "/ws" });
   wss.on("connection", (socket, request) => {
     const origin = request.headers.origin;
@@ -41834,7 +44423,15 @@ function attachBridgeWss(server, opts) {
         })
       );
     }
-    send({ type: "ready", bridgeVersion: 1 });
+    send({
+      type: "ready",
+      bridgeVersion: 1,
+      ...selfUpdate ? {
+        version: selfUpdate.version,
+        binSha: selfUpdate.binSha,
+        latestVersion: selfUpdate.getLatestVersion()
+      } : {}
+    });
     onPaired?.();
     onReady?.(socket, request, send, logger ? { logger, span } : void 0);
   });
@@ -41850,7 +44447,7 @@ function createBridgeMessageHandler(deps) {
       boundSessions.clear();
     });
     socket.on("message", async (data) => {
-      const spanId = import_node_crypto4.default.randomUUID();
+      const spanId = import_node_crypto5.default.randomUUID();
       if (logCtx) {
         logCtx.span.id = spanId;
         logCtx.span.at = Date.now();
@@ -41938,6 +44535,54 @@ function createBridgeMessageHandler(deps) {
         sendForSpan({ type: "bootstrap", models, rateLimits, ...bootstrapError ? { error: bootstrapError } : {} });
         return;
       }
+      if (msg.type === "report_issue") {
+        if (msg.source !== "director-chat" && msg.source !== "director-panel" && msg.source !== "shell-menu") {
+          sendForSpan({ type: "report-issue-result", status: "error", error: "report source is invalid." });
+          return;
+        }
+        const customerDescription = typeof msg.customerDescription === "string" ? msg.customerDescription.trim() : "";
+        if (!customerDescription) {
+          sendForSpan({ type: "report-issue-result", status: "error", error: "customerDescription is required." });
+          return;
+        }
+        const transcript = normalizeIssueTranscript(msg.transcript);
+        if ("error" in transcript) {
+          sendForSpan({ type: "report-issue-result", status: "error", error: transcript.error });
+          return;
+        }
+        const screenshots = normalizeIssueScreenshots(msg.screenshots);
+        if ("error" in screenshots) {
+          sendForSpan({ type: "report-issue-result", status: "error", error: screenshots.error });
+          return;
+        }
+        try {
+          const result = fileIssueReport({
+            source: msg.source,
+            customerDescription,
+            directorSessionId: typeof msg.directorSessionId === "string" ? msg.directorSessionId.trim() || null : null,
+            projectSlug: typeof msg.projectSlug === "string" ? msg.projectSlug.trim() || null : null,
+            urlPath: typeof msg.urlPath === "string" ? msg.urlPath.trim() || null : null,
+            transcript,
+            screenshots
+          });
+          sendForSpan({
+            type: "report-issue-result",
+            status: "ok",
+            issueNumber: result.issueNumber,
+            title: result.title,
+            url: result.url,
+            telegramDelivered: result.telegramDelivered,
+            telegramWarning: result.telegramWarning
+          });
+        } catch (error51) {
+          sendForSpan({
+            type: "report-issue-result",
+            status: "error",
+            error: error51 instanceof Error ? error51.message : String(error51)
+          });
+        }
+        return;
+      }
       if (msg.type === "interrupt") {
         const directorSessionId2 = (msg.directorSessionId ?? "").trim();
         const existing = directorSessionId2 ? deps.threads.get(directorSessionId2) : void 0;
@@ -42145,10 +44790,15 @@ function createBridgeMessageHandler(deps) {
           pokeActivity = () => watchdog.poke();
           const runSequence = (async () => {
             const turnInput = [];
-            if (inputText.length > 0) {
-              const composed = contextPrefix ? `${contextPrefix}
+            const effectiveText = inputText.length > 0 ? inputText : imageDataUri ? DEFAULT_IMAGE_ONLY_PROMPT : "";
+            if (effectiveText.length > 0) {
+              const updateOffer = deps.maybeUpdateOffer ? deps.maybeUpdateOffer() : null;
+              const composedPrefix = updateOffer ? contextPrefix ? `${updateOffer}
 
-${inputText}` : inputText;
+${contextPrefix}` : updateOffer : contextPrefix;
+              const composed = composedPrefix ? `${composedPrefix}
+
+${effectiveText}` : effectiveText;
               turnInput.push({ type: "text", text: composed, text_elements: [] });
             }
             if (imageDataUri) {
@@ -42234,9 +44884,59 @@ function parseConfig() {
   const idleThreadTtlMs = Math.max(6e4, readEnvInt("MRRLIN_DIRECTOR_BRIDGE_IDLE_TTL_SECONDS", 1800) * 1e3);
   return { host, port, stateDir, allowedOrigins, token, codexCwd, codexExecutable, idleThreadTtlMs };
 }
+function scanForOtherBridges() {
+  try {
+    const result = (0, import_node_child_process4.spawnSync)("pgrep", ["-f", "mrrlin-mcp director-bridge"], {
+      encoding: "utf8"
+    });
+    if (result.status !== 0) return [];
+    return result.stdout.trim().split("\n").map((s) => Number.parseInt(s, 10)).filter((n) => Number.isInteger(n) && n !== process.pid);
+  } catch {
+    return [];
+  }
+}
 async function startDirectorBridge() {
   const config2 = parseConfig();
   const turnLock = createTurnLock();
+  let lastTurnEndedAt = Date.now();
+  const wrappedTurnLock = {
+    runExclusive(fn) {
+      return turnLock.runExclusive(async () => {
+        try {
+          return await fn();
+        } finally {
+          lastTurnEndedAt = Date.now();
+        }
+      });
+    },
+    activeCount: turnLock.activeCount
+  };
+  const shutdownHolder = { fn: null };
+  const selfUpdateHandle = startSelfUpdate({
+    binPath: process.argv[1] ?? "",
+    getActiveTurnCount: () => wrappedTurnLock.activeCount(),
+    getIdleMs: () => Date.now() - lastTurnEndedAt,
+    pkgVersion: PKG_VERSION,
+    shutdown: () => {
+      try {
+        shutdownHolder.fn?.();
+      } catch (e) {
+        process.stderr.write(
+          `[mrrlin-mcp director-bridge] error self_update shutdown threw: ${String(
+            e?.message ?? e
+          )}
+`
+        );
+      }
+    },
+    log: (level, event, fields) => {
+      const payload = fields ? ` ${JSON.stringify(fields)}` : "";
+      process.stderr.write(
+        `[mrrlin-mcp director-bridge] ${level} ${event}${payload}
+`
+      );
+    }
+  });
   const consumerState = { inFlightRunId: null, lastClaimAt: null };
   const health = createServiceHealth();
   const apiBaseUrl = readConfiguredApiBaseUrl();
@@ -42312,14 +45012,14 @@ async function startDirectorBridge() {
     // handle returned by acquireExecutorCodex (Fix A + G), so there is no shared
     // mutable `activeExecutorClient` slot to race a concurrent chat/bootstrap turn.
     releaseCodex: () => codexKeepalive.release(),
-    runExclusive: turnLock.runExclusive,
+    runExclusive: wrappedTurnLock.runExclusive,
     staleSeconds,
     touchIntervalMs: Math.min(DEFAULT_TOUCH_INTERVAL_MS, Math.floor(staleSeconds * 1e3 / 2)),
     codexCwd: config2.codexCwd,
     codexExecutable: config2.codexExecutable,
     checkoutRegistry,
-    worktreeRoot: import_node_path11.default.join(config2.stateDir, "worktrees"),
-    locksDir: import_node_path11.default.join(config2.stateDir, "locks"),
+    worktreeRoot: import_node_path12.default.join(config2.stateDir, "worktrees"),
+    locksDir: import_node_path12.default.join(config2.stateDir, "locks"),
     // Wire the profile-enforced executor server for code-execution runs. Each run gets its own
     // sandboxed Codex instance (scrubbed env, scratch CODEX_HOME, deny-read, egress allowlist).
     // The returned handle's dispose() shuts down the spawned app-server CHILD (manager.shutdown(),
@@ -42352,13 +45052,13 @@ async function startDirectorBridge() {
       },
       runVerificationTurn: createRunVerificationTurn({
         startSandbox: async (egressDomains) => {
-          const cwd = import_node_fs10.default.mkdtempSync(import_node_path11.default.join(import_node_os7.default.tmpdir(), "mrrlin-verify-"));
+          const cwd = import_node_fs12.default.mkdtempSync(import_node_path12.default.join(import_node_os8.default.tmpdir(), "mrrlin-verify-"));
           let handle;
           try {
             handle = await startExecutorServer({ worktree: cwd, egressDomains });
           } catch (error51) {
             try {
-              import_node_fs10.default.rmSync(cwd, { recursive: true, force: true });
+              import_node_fs12.default.rmSync(cwd, { recursive: true, force: true });
             } catch {
             }
             throw error51;
@@ -42369,7 +45069,7 @@ async function startDirectorBridge() {
             dispose: () => {
               handle.dispose();
               try {
-                import_node_fs10.default.rmSync(cwd, { recursive: true, force: true });
+                import_node_fs12.default.rmSync(cwd, { recursive: true, force: true });
               } catch {
               }
             }
@@ -42383,7 +45083,7 @@ async function startDirectorBridge() {
   const sessionSinks = createSessionSinkRegistry();
   const asyncConsumerDeps = {
     client,
-    runExclusive: turnLock.runExclusive,
+    runExclusive: wrappedTurnLock.runExclusive,
     cwd: config2.codexCwd ?? process.cwd(),
     codexExecutable: config2.codexExecutable,
     staleSeconds,
@@ -42483,7 +45183,7 @@ async function startDirectorBridge() {
   const sharedHandlerDeps = {
     acquireCodex: () => codexKeepalive.acquire(),
     releaseCodex: () => codexKeepalive.release(),
-    runExclusive: turnLock.runExclusive,
+    runExclusive: wrappedTurnLock.runExclusive,
     buildStartParams: (msg, desiredModel) => buildThreadStartParams(msg, config2, desiredModel),
     turnInactivity: () => ({ idleMs: chatTurnIdleMs(), maxMs: chatTurnMaxMs() }),
     checkoutRegistry,
@@ -42499,15 +45199,26 @@ async function startDirectorBridge() {
     },
     unbindSessionSink: (directorSessionId, send) => {
       sessionSinks.unbind(directorSessionId, send);
-    }
+    },
+    maybeUpdateOffer: () => selfUpdateHandle.maybeUpdateOffer()
   };
   const bridgeLogger = createBridgeLogger(config2.stateDir, process.env);
+  let bridgeBinShaShort = "unknown00000";
+  try {
+    bridgeBinShaShort = import_node_crypto5.default.createHash("sha256").update(import_node_fs12.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
+  } catch {
+  }
   attachBridgeWss(server, {
     token: config2.token,
     allowedOrigins: config2.allowedOrigins,
     onReady: createBridgeMessageHandler({ ...sharedHandlerDeps, threads, persistThreads }),
     logger: bridgeLogger,
-    onPaired: () => health.setPaired(true)
+    onPaired: () => health.setPaired(true),
+    selfUpdate: {
+      version: PKG_VERSION,
+      binSha: bridgeBinShaShort,
+      getLatestVersion: () => selfUpdateHandle.getLatestVersion()
+    }
   });
   if (agentSecret && relayUrl) {
     try {
@@ -42602,8 +45313,8 @@ async function startDirectorBridge() {
       enqueueRun(
         () => runOrphanWorktreeSweep(client, {
           checkoutRegistry,
-          worktreeRoot: import_node_path11.default.join(config2.stateDir, "worktrees"),
-          locksDir: import_node_path11.default.join(config2.stateDir, "locks")
+          worktreeRoot: import_node_path12.default.join(config2.stateDir, "worktrees"),
+          locksDir: import_node_path12.default.join(config2.stateDir, "locks")
         })
       );
       scheduleClaimLoop();
@@ -42618,10 +45329,34 @@ async function startDirectorBridge() {
     );
   }
   await new Promise((resolve, reject) => {
-    server.on("error", reject);
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        const conflictingPids = scanForOtherBridges();
+        process.stderr.write(
+          `[mrrlin-mcp director-bridge] error bridge.startup.port_in_use ${JSON.stringify({
+            host: config2.host,
+            port: config2.port,
+            conflictingPids
+          })}
+`
+        );
+        process.exit(1);
+      }
+      reject(err);
+    });
     server.listen(config2.port, config2.host, () => resolve());
   });
-  const shutdown = createBridgeShutdown({
+  const orphans = scanForOtherBridges();
+  if (orphans.length > 0) {
+    process.stderr.write(
+      `[mrrlin-mcp director-bridge] warn bridge.startup.zombie_scan ${JSON.stringify({
+        pids: orphans,
+        hint: "run the one-time cleanup from the README to remove them"
+      })}
+`
+    );
+  }
+  shutdownHolder.fn = createBridgeShutdown({
     closers: [
       () => server.close(),
       () => dispatchServer.close(),
@@ -42632,15 +45367,20 @@ async function startDirectorBridge() {
         claimLoopStopped = true;
         if (claimTimer) clearTimeout(claimTimer);
       },
-      () => codexKeepalive.dropNow()
+      () => codexKeepalive.dropNow(),
+      () => selfUpdateHandle.stop()
     ],
     shutdownCodex: () => codexServerManager.shutdown(),
     exit: (code) => process.exit(code),
     log: (message) => process.stderr.write(`${message}
 `)
   });
+  const shutdown = shutdownHolder.fn;
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
+  process.on("SIGUSR2", () => {
+    selfUpdateHandle.requestDrain();
+  });
   process.stderr.write(`[mrrlin-mcp director-bridge] listening on http://${config2.host}:${config2.port} (ws://${config2.host}:${config2.port}/ws)
 `);
   process.stderr.write(`[mrrlin-mcp director-bridge] token: ${config2.token}
@@ -42738,7 +45478,7 @@ function timingSafeTokenEqual(provided, expected) {
   const a = Buffer.from(provided);
   const b = Buffer.from(expected);
   if (a.length !== b.length) return false;
-  return import_node_crypto4.default.timingSafeEqual(a, b);
+  return import_node_crypto5.default.timingSafeEqual(a, b);
 }
 function readDispatchBody(req) {
   return new Promise((resolve, reject) => {
@@ -42760,15 +45500,15 @@ function readDispatchBody(req) {
 function readOrCreateBridgeToken(stateDir) {
   const explicit = (process.env.MRRLIN_DIRECTOR_BRIDGE_TOKEN ?? "").trim();
   if (explicit) return explicit;
-  const tokenPath = import_node_path11.default.join(stateDir, "token.txt");
+  const tokenPath = import_node_path12.default.join(stateDir, "token.txt");
   try {
-    const existing = import_node_fs10.default.readFileSync(tokenPath, "utf8").trim();
+    const existing = import_node_fs12.default.readFileSync(tokenPath, "utf8").trim();
     if (existing) return existing;
   } catch {
   }
-  import_node_fs10.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
-  const token = import_node_crypto4.default.randomBytes(32).toString("base64url");
-  import_node_fs10.default.writeFileSync(tokenPath, `${token}
+  import_node_fs12.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
+  const token = import_node_crypto5.default.randomBytes(32).toString("base64url");
+  import_node_fs12.default.writeFileSync(tokenPath, `${token}
 `, { mode: 384 });
   return token;
 }
@@ -46151,17 +48891,17 @@ var StdioServerTransport = class {
 
 // src/tools.ts
 var import_promises3 = require("node:fs/promises");
-var import_node_fs12 = require("node:fs");
-var import_node_path14 = __toESM(require("node:path"), 1);
-var import_node_os8 = __toESM(require("node:os"), 1);
-var import_node_child_process6 = require("node:child_process");
+var import_node_fs14 = require("node:fs");
+var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_os9 = __toESM(require("node:os"), 1);
+var import_node_child_process7 = require("node:child_process");
 
 // ../../packages/wiki/dist/index.js
 var import_promises2 = __toESM(require("node:fs/promises"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 var INCLUDED_DOC_FOLDERS = /* @__PURE__ */ new Set(["_meta", "explanation", "how-to", "reference", "sdd", "tutorials"]);
 function toPosixPath(input) {
-  return input.split(import_node_path12.default.sep).join("/");
+  return input.split(import_node_path13.default.sep).join("/");
 }
 function slugifyWikiSegment(input) {
   return input.trim().toLowerCase().replace(/`/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -46175,12 +48915,12 @@ async function pathExists2(input) {
   }
 }
 async function findWorkspaceRoot(start = process.cwd()) {
-  let current = import_node_path12.default.resolve(start);
+  let current = import_node_path13.default.resolve(start);
   while (true) {
-    if (await pathExists2(import_node_path12.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path12.default.join(current, "docs"))) {
+    if (await pathExists2(import_node_path13.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path13.default.join(current, "docs"))) {
       return current;
     }
-    const parent = import_node_path12.default.dirname(current);
+    const parent = import_node_path13.default.dirname(current);
     if (parent === current) {
       throw new Error(`Unable to find Mrrlin workspace root from ${start}`);
     }
@@ -46189,28 +48929,28 @@ async function findWorkspaceRoot(start = process.cwd()) {
 }
 async function resolveDocsRoot(input) {
   if (input) {
-    return import_node_path12.default.resolve(input);
+    return import_node_path13.default.resolve(input);
   }
   if (process.env.MRRLIN_DOCS_ROOT) {
-    return import_node_path12.default.resolve(process.env.MRRLIN_DOCS_ROOT);
+    return import_node_path13.default.resolve(process.env.MRRLIN_DOCS_ROOT);
   }
-  return import_node_path12.default.join(await findWorkspaceRoot(), "docs");
+  return import_node_path13.default.join(await findWorkspaceRoot(), "docs");
 }
 async function resolveIndexPath(input) {
   if (input) {
-    return import_node_path12.default.resolve(input);
+    return import_node_path13.default.resolve(input);
   }
   if (process.env.MRRLIN_WIKI_INDEX_PATH) {
-    return import_node_path12.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
+    return import_node_path13.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
   }
   const workspaceRoot = await findWorkspaceRoot();
-  return import_node_path12.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
+  return import_node_path13.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
 }
 async function walkMarkdownFiles(root, dir = root) {
   const entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolute = import_node_path12.default.join(dir, entry.name);
+    const absolute = import_node_path13.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkMarkdownFiles(root, absolute));
       continue;
@@ -46229,7 +48969,7 @@ function parseTitle(markdown, sourcePath) {
   return title;
 }
 function documentFromFile(docsRoot, absolutePath, markdown) {
-  const relativePath = toPosixPath(import_node_path12.default.relative(docsRoot, absolutePath));
+  const relativePath = toPosixPath(import_node_path13.default.relative(docsRoot, absolutePath));
   const [section, fileName] = relativePath.split("/");
   if (!section || !fileName || !INCLUDED_DOC_FOLDERS.has(section)) {
     return null;
@@ -46644,7 +49384,7 @@ async function runCodeGate(_target, deps) {
 }
 
 // src/consensus/codex-exec.ts
-var import_node_child_process4 = require("node:child_process");
+var import_node_child_process5 = require("node:child_process");
 function extractFinalMessage(stdout) {
   let last = null;
   for (const rawLine of stdout.split(/\r?\n/)) {
@@ -46689,7 +49429,7 @@ function firstString(...values) {
   return null;
 }
 function runCodexExec(input, deps) {
-  const spawn2 = deps?.spawn ?? import_node_child_process4.spawn;
+  const spawn2 = deps?.spawn ?? import_node_child_process5.spawn;
   const executable = input.codexExecutable ?? "codex";
   const sandbox = input.sandbox ?? "read-only";
   const fullPrompt = input.developerInstructions.trim() ? `${input.developerInstructions.trim()}
@@ -46761,12 +49501,12 @@ function errMessage(err) {
 }
 
 // src/consensus/wiring.ts
-var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var import_node_url = require("node:url");
 
 // src/consensus/code-gate-git.ts
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 var DIFF_MAX_BYTES = 2e5;
 var FASTGATE_OUTPUT_MAX_BYTES = 16e3;
 var GIT_TIMEOUT_MS = 6e4;
@@ -46782,7 +49522,7 @@ var defaultRunCmd = (cmd, args, opts) => new Promise((resolve) => {
   };
   let child;
   try {
-    child = (0, import_node_child_process5.spawn)(cmd, args, {
+    child = (0, import_node_child_process6.spawn)(cmd, args, {
       cwd: opts.cwd,
       env: process.env,
       shell: false,
@@ -46997,15 +49737,15 @@ ${res.stdout}${res.stderr}`);
 var import_meta = {};
 function getPersonasDir() {
   if (typeof __dirname !== "undefined") {
-    return import_node_path13.default.join(__dirname, "consensus", "personas");
+    return import_node_path14.default.join(__dirname, "consensus", "personas");
   }
-  return import_node_path13.default.join(import_node_path13.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url)), "personas");
+  return import_node_path14.default.join(import_node_path14.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url)), "personas");
 }
 var personaCache = /* @__PURE__ */ new Map();
 function loadPersona(name) {
   const cached2 = personaCache.get(name);
   if (cached2 !== void 0) return cached2;
-  const content = import_node_fs11.default.readFileSync(import_node_path13.default.join(getPersonasDir(), `${name}.md`), "utf8");
+  const content = import_node_fs13.default.readFileSync(import_node_path14.default.join(getPersonasDir(), `${name}.md`), "utf8");
   personaCache.set(name, content);
   return content;
 }
@@ -47283,7 +50023,7 @@ var consensusDescriptor = {
 };
 
 // src/async-tools/enqueue.ts
-var import_node_crypto5 = __toESM(require("node:crypto"), 1);
+var import_node_crypto6 = __toESM(require("node:crypto"), 1);
 async function enqueueAsyncTool(client, descriptor2, input) {
   if (descriptor2.cachedResult) {
     const cached2 = await descriptor2.cachedResult(client, input);
@@ -47296,7 +50036,7 @@ async function enqueueAsyncTool(client, descriptor2, input) {
   if (active) {
     return { status: "already_running", jobId: active.id, message: "Already running; will notify in inbox." };
   }
-  const jobId = `AJ-${import_node_crypto5.default.randomUUID()}`;
+  const jobId = `AJ-${import_node_crypto6.default.randomUUID()}`;
   try {
     await client.createAsyncJob(input.projectSlug, {
       id: jobId,
@@ -48768,7 +51508,7 @@ function createMrrlinTools(options) {
       "ARTIFACT_FILE_UPLOAD_FAILED",
       "Unable to upload artifact file.",
       async (c, { projectSlug, path: filePath, class: artifactClass, taskId, runId, description }) => {
-        const extension2 = import_node_path14.default.extname(filePath).toLowerCase();
+        const extension2 = import_node_path15.default.extname(filePath).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -48796,7 +51536,7 @@ function createMrrlinTools(options) {
             "Artifact exceeds 5MB; split or summarize instead."
           );
         }
-        const filename = import_node_path14.default.basename(filePath);
+        const filename = import_node_path15.default.basename(filePath);
         const created = await c.createArtifactFile(projectSlug, {
           class: artifactClass,
           contentType,
@@ -48879,7 +51619,7 @@ function createMrrlinTools(options) {
       "Unable to register local checkout.",
       async (_c, { projectSlug, path: checkoutPath, repo }) => {
         const trimmedPath = checkoutPath.trim();
-        if (!import_node_path14.default.isAbsolute(trimmedPath)) {
+        if (!import_node_path15.default.isAbsolute(trimmedPath)) {
           throw new McpToolCodedError(
             "LOCAL_CHECKOUT_PATH_NOT_ABSOLUTE",
             `Path must be absolute, got: ${trimmedPath}`
@@ -48887,7 +51627,7 @@ function createMrrlinTools(options) {
         }
         let resolvedPath;
         try {
-          resolvedPath = (0, import_node_fs12.realpathSync)(trimmedPath);
+          resolvedPath = (0, import_node_fs14.realpathSync)(trimmedPath);
         } catch {
           throw new McpToolCodedError(
             "LOCAL_CHECKOUT_PATH_NOT_FOUND",
@@ -48896,7 +51636,7 @@ function createMrrlinTools(options) {
         }
         let remoteUrl;
         try {
-          remoteUrl = (0, import_node_child_process6.execFileSync)("git", ["-C", resolvedPath, "remote", "get-url", "origin"], {
+          remoteUrl = (0, import_node_child_process7.execFileSync)("git", ["-C", resolvedPath, "remote", "get-url", "origin"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
             timeout: 15e3,
@@ -48914,7 +51654,7 @@ function createMrrlinTools(options) {
             `Origin remote ${remoteUrl} does not match repo ${repo}.`
           );
         }
-        const stateDir = process.env.CODEX_HOME ? import_node_path14.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path14.default.join(import_node_os8.default.homedir(), ".mrrlin", "director-bridge");
+        const stateDir = process.env.CODEX_HOME ? import_node_path15.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path15.default.join(import_node_os9.default.homedir(), ".mrrlin", "director-bridge");
         const registry3 = new CheckoutRegistry(stateDir);
         const confirmedAt = (/* @__PURE__ */ new Date()).toISOString();
         registry3.confirm(projectSlug, resolvedPath, confirmedAt);
@@ -49121,13 +51861,13 @@ function runSetCredential(args) {
 }
 
 // src/install-service.ts
-var import_node_os9 = __toESM(require("node:os"), 1);
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_os10 = __toESM(require("node:os"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 
 // src/service-paths.ts
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 function isWorktreePath(p) {
-  const norm = import_node_path15.default.normalize(p).split(import_node_path15.default.sep).join("/");
+  const norm = import_node_path16.default.normalize(p).split(import_node_path16.default.sep).join("/");
   return norm.includes("/.claude/worktrees/");
 }
 function resolveServiceCwd(opts) {
@@ -49161,6 +51901,7 @@ function renderEcosystemConfig(opts) {
     autorestart: true,
     max_restarts: 10,
     restart_delay: 3000,
+    kill_timeout: 10000,
     env: {
 ${envLines}
     },
@@ -49180,7 +51921,7 @@ function installService(deps) {
     deps.log(resolved.reason);
     return { ok: false };
   }
-  const home = deps.env.HOME ?? import_node_os9.default.homedir();
+  const home = deps.env.HOME ?? import_node_os10.default.homedir();
   const bins = ["node", "codex", "mrrlin-mcp"].map((b) => deps.which(b));
   if (bins.some((b) => !b)) {
     deps.log("Could not resolve absolute paths for node/codex/mrrlin-mcp on PATH. Install them or fix PATH.");
@@ -49191,7 +51932,7 @@ function installService(deps) {
     return { ok: false };
   }
   const resolvedBins = bins.filter((b) => b !== null);
-  const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path16.default.dirname(b)))).join(":");
+  const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path17.default.dirname(b)))).join(":");
   const text = renderEcosystemConfig({
     cwd: resolved.cwd,
     home,
@@ -49200,7 +51941,7 @@ function installService(deps) {
     staging: deps.env.MRRLIN_STAGING === "1",
     apiBaseUrl: deps.env.MRRLIN_API_BASE_URL?.trim() || void 0
   });
-  const ecoPath = import_node_path16.default.join(home, ".mrrlin", "ecosystem.config.cjs");
+  const ecoPath = import_node_path17.default.join(home, ".mrrlin", "ecosystem.config.cjs");
   deps.writeFile(ecoPath, text);
   const start = deps.runPm2(["startOrReload", ecoPath]);
   if (start.code !== 0) {
@@ -49231,13 +51972,13 @@ function uninstallService(deps) {
 
 // src/uninstall-codex.ts
 var import_promises4 = __toESM(require("node:fs/promises"), 1);
-var import_node_os10 = __toESM(require("node:os"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_os11 = __toESM(require("node:os"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var toml2 = __toESM(require_toml(), 1);
 function resolveCodexHome2(options) {
   if (options.codexHome) return options.codexHome;
   if (process.env.CODEX_HOME) return process.env.CODEX_HOME;
-  return import_node_path17.default.join(options.homeDir ?? import_node_os10.default.homedir(), ".codex");
+  return import_node_path18.default.join(options.homeDir ?? import_node_os11.default.homedir(), ".codex");
 }
 async function pathExists3(target) {
   try {
@@ -49250,7 +51991,7 @@ async function pathExists3(target) {
 var MRRLIN_BLOCK_RE2 = /(^|\n)\[mcp_servers\.mrrlin(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
 async function uninstallCodex(options = {}) {
   const codexHome = resolveCodexHome2(options);
-  const configPath = import_node_path17.default.join(codexHome, "config.toml");
+  const configPath = import_node_path18.default.join(codexHome, "config.toml");
   const removePrompts = async () => uninstallPrompts(codexHome, options.promptNames ?? []);
   if (!await pathExists3(configPath)) {
     return { action: "missing", configPath, prompts: await removePrompts() };
@@ -49278,10 +52019,10 @@ async function uninstallCodex(options = {}) {
 }
 async function uninstallPrompts(codexHome, names) {
   if (names.length === 0) return [];
-  const promptsDir2 = import_node_path17.default.join(codexHome, "prompts");
+  const promptsDir2 = import_node_path18.default.join(codexHome, "prompts");
   const out = [];
   for (const name of names) {
-    const promptPath = import_node_path17.default.join(promptsDir2, `${name}.md`);
+    const promptPath = import_node_path18.default.join(promptsDir2, `${name}.md`);
     try {
       await import_promises4.default.unlink(promptPath);
       out.push({ name, action: "removed", promptPath });
@@ -49298,27 +52039,27 @@ async function uninstallPrompts(codexHome, names) {
 }
 
 // src/report-issue-prompt.ts
-var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_fs15 = __toESM(require("node:fs"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_meta2 = {};
 function promptsDir() {
-  if (typeof __dirname !== "undefined") return import_node_path18.default.join(__dirname, "prompts");
-  return import_node_path18.default.join(import_node_path18.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url)), "prompts");
+  if (typeof __dirname !== "undefined") return import_node_path19.default.join(__dirname, "prompts");
+  return import_node_path19.default.join(import_node_path19.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url)), "prompts");
 }
 function readReportIssuePrompt() {
-  return import_node_fs13.default.readFileSync(import_node_path18.default.join(promptsDir(), "report-issue.md"), "utf8");
+  return import_node_fs15.default.readFileSync(import_node_path19.default.join(promptsDir(), "report-issue.md"), "utf8");
 }
 
 // src/bin.ts
 function pm2Runner(args) {
-  const r = (0, import_node_child_process7.spawnSync)("pm2", args, { encoding: "utf8" });
+  const r = (0, import_node_child_process8.spawnSync)("pm2", args, { encoding: "utf8" });
   process.stderr.write(r.stdout ?? "");
   process.stderr.write(r.stderr ?? "");
   return { code: r.status ?? 1, stdout: r.stdout ?? "" };
 }
 function whichBin(bin) {
-  const r = (0, import_node_child_process7.spawnSync)("which", [bin], { encoding: "utf8" });
+  const r = (0, import_node_child_process8.spawnSync)("which", [bin], { encoding: "utf8" });
   const out = (r.stdout ?? "").trim();
   return r.status === 0 && out ? out.split("\n")[0] ?? null : null;
 }
@@ -49426,22 +52167,20 @@ Usage:
                                 Bearer/JWT tokens, long hex / base64-ish runs)
                                 from stdin and write the result to stdout. Same
                                 regex set as the bridge logger. Empty input ->
-                                empty output, exit 0. Used by the /report-issue
-                                prompt to ensure no raw text reaches Telegram:
+                                empty output, exit 0. Useful for any local
+                                support/debug packaging flow:
                                   printf %s "$HINT" | mrrlin-mcp redact
 
-  mrrlin-mcp report-issue       Print the bundled support-report prompt to
-                                stdout. Normal users don't need this \u2014 install-codex
-                                already drops it as a /report-issue slash command.
-                                Operator usage from inside Codex (paste a hint \u2014
-                                pasted error blurb, weird output quote, one-line
-                                description, or sessionId):
-                                  /report-issue Codex hung after sending a turn
-                                  /report-issue [paste failing stack here]
-                                The prompt greps the bridge log for that hint
-                                and only asks follow-ups the log doesn't already
-                                answer. Useful for: piping ad-hoc, inspecting
-                                shipped contents, repairing a deleted file:
+  mrrlin-mcp report-issue       Print the bundled compatibility prompt for the
+                                legacy /report-issue slash command. Preferred
+                                flows now live inside the Mrrlin UI:
+                                - Director chat: /report-issue <what broke>
+                                - Header menu: Report issue
+                                Those flows package bridge logs, transcript
+                                context, screenshots, and create a GitHub issue
+                                in fnnzzz/mrrlin via local gh. This command is
+                                mainly useful for inspecting or re-installing
+                                the shipped prompt:
                                   codex "$(mrrlin-mcp report-issue)"
                                   mrrlin-mcp report-issue > ~/.codex/prompts/report-issue.md
 
@@ -49519,8 +52258,8 @@ async function main() {
         env: process.env,
         cwd: process.cwd(),
         writeFile: (p, c) => {
-          (0, import_node_fs14.mkdirSync)(import_node_path20.default.dirname(p), { recursive: true, mode: 448 });
-          (0, import_node_fs14.writeFileSync)(p, c, { mode: 384 });
+          (0, import_node_fs16.mkdirSync)(import_node_path21.default.dirname(p), { recursive: true, mode: 448 });
+          (0, import_node_fs16.writeFileSync)(p, c, { mode: 384 });
         },
         runPm2: pm2Runner,
         which: whichBin,
@@ -49537,35 +52276,35 @@ async function main() {
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs14.rmSync)(p, { force: true });
+            (0, import_node_fs16.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: purge,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path20.default.join(process.env.HOME ?? (0, import_node_os11.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path21.default.join(process.env.HOME ?? (0, import_node_os12.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
         log: (m) => process.stderr.write(`[mrrlin-mcp uninstall-service] ${m}
 `)
       });
       return;
     }
     case "uninstall": {
-      const home = process.env.HOME ?? (0, import_node_os11.homedir)();
+      const home = process.env.HOME ?? (0, import_node_os12.homedir)();
       const log = (m) => process.stderr.write(`[mrrlin-mcp uninstall] ${m}
 `);
       uninstallService({
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs14.rmSync)(p, { force: true });
+            (0, import_node_fs16.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: true,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path20.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path21.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
         log
       });
       let codexOk = true;
@@ -49585,7 +52324,7 @@ async function main() {
         log(`codex config NOT modified: ${error51 instanceof Error ? error51.message : String(error51)}`);
       }
       try {
-        (0, import_node_fs14.rmSync)(import_node_path20.default.join(home, ".mrrlin"), { recursive: true, force: true });
+        (0, import_node_fs16.rmSync)(import_node_path21.default.join(home, ".mrrlin"), { recursive: true, force: true });
       } catch {
       }
       log("removed ~/.mrrlin");
@@ -49626,7 +52365,7 @@ ${HELP_TEXT}`);
   }
 }
 function resolveSelfBinPath() {
-  return import_node_path19.default.resolve(process.argv[1] ?? process.execPath);
+  return import_node_path20.default.resolve(process.argv[1] ?? process.execPath);
 }
 main().catch((error51) => {
   process.stderr.write(`mrrlin-mcp fatal error: ${error51 instanceof Error ? error51.message : String(error51)}