@mrrlin-dev/mcp 0.3.47 → 0.3.50

package/dist/bin.cjs

@@ -7703,54 +7703,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs6) {
+    function patch(fs8) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs6);
-      }
-      if (!fs6.lutimes) {
-        patchLutimes(fs6);
-      }
-      fs6.chown = chownFix(fs6.chown);
-      fs6.fchown = chownFix(fs6.fchown);
-      fs6.lchown = chownFix(fs6.lchown);
-      fs6.chmod = chmodFix(fs6.chmod);
-      fs6.fchmod = chmodFix(fs6.fchmod);
-      fs6.lchmod = chmodFix(fs6.lchmod);
-      fs6.chownSync = chownFixSync(fs6.chownSync);
-      fs6.fchownSync = chownFixSync(fs6.fchownSync);
-      fs6.lchownSync = chownFixSync(fs6.lchownSync);
-      fs6.chmodSync = chmodFixSync(fs6.chmodSync);
-      fs6.fchmodSync = chmodFixSync(fs6.fchmodSync);
-      fs6.lchmodSync = chmodFixSync(fs6.lchmodSync);
-      fs6.stat = statFix(fs6.stat);
-      fs6.fstat = statFix(fs6.fstat);
-      fs6.lstat = statFix(fs6.lstat);
-      fs6.statSync = statFixSync(fs6.statSync);
-      fs6.fstatSync = statFixSync(fs6.fstatSync);
-      fs6.lstatSync = statFixSync(fs6.lstatSync);
-      if (fs6.chmod && !fs6.lchmod) {
-        fs6.lchmod = function(path16, mode, cb) {
+        patchLchmod(fs8);
+      }
+      if (!fs8.lutimes) {
+        patchLutimes(fs8);
+      }
+      fs8.chown = chownFix(fs8.chown);
+      fs8.fchown = chownFix(fs8.fchown);
+      fs8.lchown = chownFix(fs8.lchown);
+      fs8.chmod = chmodFix(fs8.chmod);
+      fs8.fchmod = chmodFix(fs8.fchmod);
+      fs8.lchmod = chmodFix(fs8.lchmod);
+      fs8.chownSync = chownFixSync(fs8.chownSync);
+      fs8.fchownSync = chownFixSync(fs8.fchownSync);
+      fs8.lchownSync = chownFixSync(fs8.lchownSync);
+      fs8.chmodSync = chmodFixSync(fs8.chmodSync);
+      fs8.fchmodSync = chmodFixSync(fs8.fchmodSync);
+      fs8.lchmodSync = chmodFixSync(fs8.lchmodSync);
+      fs8.stat = statFix(fs8.stat);
+      fs8.fstat = statFix(fs8.fstat);
+      fs8.lstat = statFix(fs8.lstat);
+      fs8.statSync = statFixSync(fs8.statSync);
+      fs8.fstatSync = statFixSync(fs8.fstatSync);
+      fs8.lstatSync = statFixSync(fs8.lstatSync);
+      if (fs8.chmod && !fs8.lchmod) {
+        fs8.lchmod = function(path18, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchmodSync = function() {
+        fs8.lchmodSync = function() {
         };
       }
-      if (fs6.chown && !fs6.lchown) {
-        fs6.lchown = function(path16, uid, gid, cb) {
+      if (fs8.chown && !fs8.lchown) {
+        fs8.lchown = function(path18, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchownSync = function() {
+        fs8.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) {
+        fs8.rename = typeof fs8.rename !== "function" ? fs8.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs6.stat(to, function(stater, st) {
+                  fs8.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -7766,9 +7766,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs6.rename);
+        }(fs8.rename);
       }
-      fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) {
+      fs8.read = typeof fs8.read !== "function" ? fs8.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -7776,22 +7776,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs6, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs6.read);
-      fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs8.read);
+      fs8.readSync = typeof fs8.readSync !== "function" ? fs8.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs6, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs8, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -7801,11 +7801,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs6.readSync);
-      function patchLchmod(fs7) {
-        fs7.lchmod = function(path16, mode, callback) {
-          fs7.open(
-            path16,
+      }(fs8.readSync);
+      function patchLchmod(fs9) {
+        fs9.lchmod = function(path18, mode, callback) {
+          fs9.open(
+            path18,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -7813,80 +7813,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs7.fchmod(fd, mode, function(err2) {
-                fs7.close(fd, function(err22) {
+              fs9.fchmod(fd, mode, function(err2) {
+                fs9.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs7.lchmodSync = function(path16, mode) {
-          var fd = fs7.openSync(path16, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs9.lchmodSync = function(path18, mode) {
+          var fd = fs9.openSync(path18, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs7.fchmodSync(fd, mode);
+            ret = fs9.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs7.closeSync(fd);
+                fs9.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs7.closeSync(fd);
+              fs9.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs7) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-          fs7.lutimes = function(path16, at, mt, cb) {
-            fs7.open(path16, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs9) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs9.futimes) {
+          fs9.lutimes = function(path18, at, mt, cb) {
+            fs9.open(path18, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs7.futimes(fd, at, mt, function(er2) {
-                fs7.close(fd, function(er22) {
+              fs9.futimes(fd, at, mt, function(er2) {
+                fs9.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs7.lutimesSync = function(path16, at, mt) {
-            var fd = fs7.openSync(path16, constants.O_SYMLINK);
+          fs9.lutimesSync = function(path18, at, mt) {
+            var fd = fs9.openSync(path18, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs7.futimesSync(fd, at, mt);
+              ret = fs9.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs7.closeSync(fd);
+                  fs9.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs7.closeSync(fd);
+                fs9.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs7.futimes) {
-          fs7.lutimes = function(_a3, _b, _c, cb) {
+        } else if (fs9.futimes) {
+          fs9.lutimes = function(_a3, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs7.lutimesSync = function() {
+          fs9.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs6, target, mode, function(er) {
+          return orig.call(fs8, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -7896,7 +7896,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs6, target, mode);
+            return orig.call(fs8, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -7905,7 +7905,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs6, target, uid, gid, function(er) {
+          return orig.call(fs8, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -7915,7 +7915,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs6, target, uid, gid);
+            return orig.call(fs8, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -7935,13 +7935,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback);
+          return options ? orig.call(fs8, target, options, callback) : orig.call(fs8, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target);
+          var stats = options ? orig.call(fs8, target, options) : orig.call(fs8, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -7970,16 +7970,16 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs6) {
+    function legacy(fs8) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path16, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path16, options);
+      function ReadStream(path18, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path18, options);
         Stream.call(this);
         var self = this;
-        this.path = path16;
+        this.path = path18;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -8013,7 +8013,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs6.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs8.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -8024,10 +8024,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path16, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path16, options);
+      function WriteStream(path18, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path18, options);
         Stream.call(this);
-        this.path = path16;
+        this.path = path18;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -8052,7 +8052,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs6.open;
+          this._open = fs8.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -8087,7 +8087,7 @@ var require_clone = __commonJS({
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs6 = require("fs");
+    var fs8 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone2 = require_clone();
@@ -8119,12 +8119,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs6[gracefulQueue]) {
+    if (!fs8[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs6, queue);
-      fs6.close = function(fs$close) {
+      publishQueue(fs8, queue);
+      fs8.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs6, fd, function(err) {
+          return fs$close.call(fs8, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -8136,48 +8136,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs6.close);
-      fs6.closeSync = function(fs$closeSync) {
+      }(fs8.close);
+      fs8.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs6, arguments);
+          fs$closeSync.apply(fs8, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs6.closeSync);
+      }(fs8.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs6[gracefulQueue]);
-          require("assert").equal(fs6[gracefulQueue].length, 0);
+          debug(fs8[gracefulQueue]);
+          require("assert").equal(fs8[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs6[gracefulQueue]);
-    }
-    module2.exports = patch(clone2(fs6));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) {
-      module2.exports = patch(fs6);
-      fs6.__patched = true;
-    }
-    function patch(fs7) {
-      polyfills(fs7);
-      fs7.gracefulify = patch;
-      fs7.createReadStream = createReadStream;
-      fs7.createWriteStream = createWriteStream;
-      var fs$readFile = fs7.readFile;
-      fs7.readFile = readFile2;
-      function readFile2(path16, options, cb) {
+      publishQueue(global, fs8[gracefulQueue]);
+    }
+    module2.exports = patch(clone2(fs8));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs8.__patched) {
+      module2.exports = patch(fs8);
+      fs8.__patched = true;
+    }
+    function patch(fs9) {
+      polyfills(fs9);
+      fs9.gracefulify = patch;
+      fs9.createReadStream = createReadStream;
+      fs9.createWriteStream = createWriteStream;
+      var fs$readFile = fs9.readFile;
+      fs9.readFile = readFile2;
+      function readFile2(path18, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path16, options, cb);
-        function go$readFile(path17, options2, cb2, startTime) {
-          return fs$readFile(path17, options2, function(err) {
+        return go$readFile(path18, options, cb);
+        function go$readFile(path19, options2, cb2, startTime) {
+          return fs$readFile(path19, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path17, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path19, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -8185,16 +8185,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs7.writeFile;
-      fs7.writeFile = writeFile;
-      function writeFile(path16, data, options, cb) {
+      var fs$writeFile = fs9.writeFile;
+      fs9.writeFile = writeFile;
+      function writeFile(path18, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path16, data, options, cb);
-        function go$writeFile(path17, data2, options2, cb2, startTime) {
-          return fs$writeFile(path17, data2, options2, function(err) {
+        return go$writeFile(path18, data, options, cb);
+        function go$writeFile(path19, data2, options2, cb2, startTime) {
+          return fs$writeFile(path19, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path19, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -8202,17 +8202,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs7.appendFile;
+      var fs$appendFile = fs9.appendFile;
       if (fs$appendFile)
-        fs7.appendFile = appendFile;
-      function appendFile(path16, data, options, cb) {
+        fs9.appendFile = appendFile;
+      function appendFile(path18, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path16, data, options, cb);
-        function go$appendFile(path17, data2, options2, cb2, startTime) {
-          return fs$appendFile(path17, data2, options2, function(err) {
+        return go$appendFile(path18, data, options, cb);
+        function go$appendFile(path19, data2, options2, cb2, startTime) {
+          return fs$appendFile(path19, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path19, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -8220,9 +8220,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs7.copyFile;
+      var fs$copyFile = fs9.copyFile;
       if (fs$copyFile)
-        fs7.copyFile = copyFile;
+        fs9.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -8240,34 +8240,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs7.readdir;
-      fs7.readdir = readdir2;
+      var fs$readdir = fs9.readdir;
+      fs9.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path16, options, cb) {
+      function readdir2(path18, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) {
-          return fs$readdir(path17, fs$readdirCallback(
-            path17,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path19, options2, cb2, startTime) {
+          return fs$readdir(path19, fs$readdirCallback(
+            path19,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path17, options2, cb2, startTime) {
-          return fs$readdir(path17, options2, fs$readdirCallback(
-            path17,
+        } : function go$readdir2(path19, options2, cb2, startTime) {
+          return fs$readdir(path19, options2, fs$readdirCallback(
+            path19,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path16, options, cb);
-        function fs$readdirCallback(path17, options2, cb2, startTime) {
+        return go$readdir(path18, options, cb);
+        function fs$readdirCallback(path19, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path17, options2, cb2],
+                [path19, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -8282,21 +8282,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs7);
+        var legStreams = legacy(fs9);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs7.ReadStream;
+      var fs$ReadStream = fs9.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs7.WriteStream;
+      var fs$WriteStream = fs9.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs7, "ReadStream", {
+      Object.defineProperty(fs9, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -8306,7 +8306,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs7, "WriteStream", {
+      Object.defineProperty(fs9, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -8317,7 +8317,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs7, "FileReadStream", {
+      Object.defineProperty(fs9, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -8328,7 +8328,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs7, "FileWriteStream", {
+      Object.defineProperty(fs9, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -8338,7 +8338,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path16, options) {
+      function ReadStream(path18, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -8358,7 +8358,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path16, options) {
+      function WriteStream(path18, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -8376,22 +8376,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path16, options) {
-        return new fs7.ReadStream(path16, options);
+      function createReadStream(path18, options) {
+        return new fs9.ReadStream(path18, options);
       }
-      function createWriteStream(path16, options) {
-        return new fs7.WriteStream(path16, options);
+      function createWriteStream(path18, options) {
+        return new fs9.WriteStream(path18, options);
       }
-      var fs$open = fs7.open;
-      fs7.open = open;
-      function open(path16, flags, mode, cb) {
+      var fs$open = fs9.open;
+      fs9.open = open;
+      function open(path18, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path16, flags, mode, cb);
-        function go$open(path17, flags2, mode2, cb2, startTime) {
-          return fs$open(path17, flags2, mode2, function(err, fd) {
+        return go$open(path18, flags, mode, cb);
+        function go$open(path19, flags2, mode2, cb2, startTime) {
+          return fs$open(path19, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path17, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path19, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -8399,20 +8399,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs7;
+      return fs9;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs6[gracefulQueue].push(elem);
+      fs8[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs6[gracefulQueue].length; ++i) {
-        if (fs6[gracefulQueue][i].length > 2) {
-          fs6[gracefulQueue][i][3] = now;
-          fs6[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs8[gracefulQueue].length; ++i) {
+        if (fs8[gracefulQueue][i].length > 2) {
+          fs8[gracefulQueue][i][3] = now;
+          fs8[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -8420,9 +8420,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs6[gracefulQueue].length === 0)
+      if (fs8[gracefulQueue].length === 0)
         return;
-      var elem = fs6[gracefulQueue].shift();
+      var elem = fs8[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -8444,7 +8444,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs6[gracefulQueue].push(elem);
+          fs8[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -8879,10 +8879,10 @@ var require_mtime_precision = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js"(exports2, module2) {
     "use strict";
     var cacheSymbol = Symbol();
-    function probe(file2, fs6, callback) {
-      const cachedPrecision = fs6[cacheSymbol];
+    function probe(file2, fs8, callback) {
+      const cachedPrecision = fs8[cacheSymbol];
       if (cachedPrecision) {
-        return fs6.stat(file2, (err, stat2) => {
+        return fs8.stat(file2, (err, stat2) => {
           if (err) {
             return callback(err);
           }
@@ -8890,16 +8890,16 @@ var require_mtime_precision = __commonJS({
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs6.utimes(file2, mtime, mtime, (err) => {
+      fs8.utimes(file2, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs6.stat(file2, (err2, stat2) => {
+        fs8.stat(file2, (err2, stat2) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat2.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs6, cacheSymbol, { value: precision });
+          Object.defineProperty(fs8, cacheSymbol, { value: precision });
           callback(null, stat2.mtime, precision);
         });
       });
@@ -8920,8 +8920,8 @@ 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 path16 = require("path");
-    var fs6 = require_graceful_fs();
+    var path18 = require("path");
+    var fs8 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
     var mtimePrecision = require_mtime_precision();
@@ -8931,7 +8931,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file2, options, callback) {
       if (!options.realpath) {
-        return callback(null, path16.resolve(file2));
+        return callback(null, path18.resolve(file2));
       }
       options.fs.realpath(file2, callback);
     }
@@ -9052,7 +9052,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs6,
+        fs: fs8,
         onCompromised: (err) => {
           throw err;
         },
@@ -9096,7 +9096,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file2, options, callback) {
       options = {
-        fs: fs6,
+        fs: fs8,
         realpath: true,
         ...options
       };
@@ -9118,7 +9118,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs6,
+        fs: fs8,
         ...options
       };
       options.stale = Math.max(options.stale || 0, 2e3);
@@ -9157,16 +9157,16 @@ var require_lockfile = __commonJS({
 var require_adapter = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js"(exports2, module2) {
     "use strict";
-    var fs6 = require_graceful_fs();
-    function createSyncFs(fs7) {
+    var fs8 = require_graceful_fs();
+    function createSyncFs(fs9) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs7 };
+      const newFs = { ...fs9 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs7[`${method}Sync`](...args);
+            ret = fs9[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -9204,7 +9204,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs6);
+      options.fs = createSyncFs(options.fs || fs8);
       if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
         throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
       }
@@ -10795,10 +10795,10 @@ var require_segments = __commonJS({
       const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
       const nodes = buildNodes(segs);
       const graph = buildGraph(nodes, version2);
-      const path16 = dijkstra.find_path(graph.map, "start", "end");
+      const path18 = dijkstra.find_path(graph.map, "start", "end");
       const optimizedSegs = [];
-      for (let i = 1; i < path16.length - 1; i++) {
-        optimizedSegs.push(graph.table[path16[i]].node);
+      for (let i = 1; i < path18.length - 1; i++) {
+        optimizedSegs.push(graph.table[path18[i]].node);
       }
       return exports2.fromArray(mergeSegments(optimizedSegs));
     };
@@ -13234,7 +13234,7 @@ var require_utils2 = __commonJS({
 // ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/png.js
 var require_png2 = __commonJS({
   "../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/png.js"(exports2) {
-    var fs6 = require("fs");
+    var fs8 = require("fs");
     var PNG = require_png().PNG;
     var Utils = require_utils2();
     exports2.render = function render(qrData, options) {
@@ -13275,7 +13275,7 @@ var require_png2 = __commonJS({
       });
       png.pack();
     };
-    exports2.renderToFile = function renderToFile(path16, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path18, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
@@ -13286,7 +13286,7 @@ var require_png2 = __commonJS({
         called = true;
         cb.apply(null, args);
       };
-      const stream = fs6.createWriteStream(path16);
+      const stream = fs8.createWriteStream(path18);
       stream.on("error", done);
       stream.on("close", done);
       exports2.renderToFileStream(stream, qrData, options);
@@ -13348,14 +13348,14 @@ var require_utf8 = __commonJS({
       }
       return output3;
     };
-    exports2.renderToFile = function renderToFile(path16, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path18, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs6 = require("fs");
+      const fs8 = require("fs");
       const utf8 = exports2.render(qrData, options);
-      fs6.writeFile(path16, utf8, cb);
+      fs8.writeFile(path18, utf8, cb);
     };
   }
 });
@@ -13476,7 +13476,7 @@ var require_svg_tag = __commonJS({
       return str;
     }
     function qrToPath(data, size, margin) {
-      let path16 = "";
+      let path18 = "";
       let moveBy = 0;
       let newRow = false;
       let lineLength = 0;
@@ -13487,19 +13487,19 @@ var require_svg_tag = __commonJS({
         if (data[i]) {
           lineLength++;
           if (!(i > 0 && col > 0 && data[i - 1])) {
-            path16 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+            path18 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
             moveBy = 0;
             newRow = false;
           }
           if (!(col + 1 < size && data[i + 1])) {
-            path16 += svgCmd("h", lineLength);
+            path18 += svgCmd("h", lineLength);
             lineLength = 0;
           }
         } else {
           moveBy++;
         }
       }
-      return path16;
+      return path18;
     }
     exports2.render = function render(qrData, options, cb) {
       const opts = Utils.getOptions(options);
@@ -13507,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 path16 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+      const path18 = "<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 + path16 + "</svg>\n";
+      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path18 + "</svg>\n";
       if (typeof cb === "function") {
         cb(null, svgTag);
       }
@@ -13524,15 +13524,15 @@ 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(path16, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path18, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs6 = require("fs");
+      const fs8 = 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(path16, xmlStr, cb);
+      fs8.writeFile(path18, xmlStr, cb);
     };
   }
 });
@@ -13690,8 +13690,8 @@ var require_server = __commonJS({
         cb
       };
     }
-    function getTypeFromFilename(path16) {
-      return path16.slice((path16.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
+    function getTypeFromFilename(path18) {
+      return path18.slice((path18.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
     }
     function getRendererFromType(type) {
       switch (type) {
@@ -13755,17 +13755,17 @@ var require_server = __commonJS({
       const renderer = getRendererFromType(params.opts.type);
       return render(renderer.renderToBuffer, text, params);
     };
-    exports2.toFile = function toFile(path16, text, opts, cb) {
-      if (typeof path16 !== "string" || !(typeof text === "string" || typeof text === "object")) {
+    exports2.toFile = function toFile(path18, text, opts, cb) {
+      if (typeof path18 !== "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(path16);
+      const type = params.opts.type || getTypeFromFilename(path18);
       const renderer = getRendererFromType(type);
-      const renderToFile = renderer.renderToFile.bind(null, path16);
+      const renderToFile = renderer.renderToFile.bind(null, path18);
       return render(renderToFile, text, params);
     };
     exports2.toFileStream = function toFileStream(stream, text, opts) {
@@ -16983,8 +16983,8 @@ var require_utils3 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path16) {
-      let input = path16;
+    function removeDotSegments(path18) {
+      let input = path18;
       const output3 = [];
       let nextSlash = -1;
       let len = 0;
@@ -17236,8 +17236,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path16, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
+        const [path18, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path18 && path18 !== "/" ? path18 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -20630,12 +20630,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs6, exportName) {
+    function addFormats(ajv, list, fs8, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs6[f]);
+        ajv.addFormat(f, fs8[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -20644,11 +20644,11 @@ var require_dist = __commonJS({
 });
 
 // src/bin.ts
-var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 var import_node_child_process13 = require("node:child_process");
-var import_node_fs13 = require("node:fs");
-var import_node_os11 = require("node:os");
-var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_fs15 = require("node:fs");
+var import_node_os12 = require("node:os");
+var import_node_path23 = __toESM(require("node:path"), 1);
 
 // src/install-codex.ts
 var import_promises = __toESM(require("node:fs/promises"), 1);
@@ -20656,6 +20656,109 @@ var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path2 = __toESM(require("node:path"), 1);
 var toml = __toESM(require_toml(), 1);
 
+// src/api-base-url.ts
+var DEFAULT_API_BASE_URL = "http://127.0.0.1:8787";
+var STAGING_API_BASE_URL = "https://mrrlin-api-mrrlin2.vercel.app";
+function normalizeUrl(value) {
+  return value.replace(/\/$/, "");
+}
+var RETIRED_API_BASE_URLS = {
+  // Retired 2026-07-28 when staging moved to the mrrlin2 Vercel team; serves a decommissioned
+  // Supabase project and now answers `GET /health` with 402 DEPLOYMENT_DISABLED. Added in 0.3.50.
+  "mrrlin-api-fnnzzz-fnnzzzs-projects.vercel.app": STAGING_API_BASE_URL
+};
+function isSameApiHost(a, b) {
+  const origin = (value) => {
+    try {
+      const url2 = new URL(value.trim());
+      return `${url2.protocol}//${url2.hostname.toLowerCase()}${url2.port ? `:${url2.port}` : ""}`;
+    } catch {
+      return null;
+    }
+  };
+  const originA = origin(a);
+  return originA !== null && originA === origin(b);
+}
+function isStagingApiBaseUrl(input) {
+  return isSameApiHost(input, STAGING_API_BASE_URL);
+}
+function retargetRetiredApiBaseUrl(input) {
+  const normalized = normalizeUrl(input.trim());
+  let hostname3;
+  try {
+    hostname3 = new URL(normalized).hostname.toLowerCase();
+  } catch {
+    return { baseUrl: normalized, retargeted: false };
+  }
+  const successor = RETIRED_API_BASE_URLS[hostname3];
+  if (!successor) return { baseUrl: normalized, retargeted: false };
+  return { baseUrl: successor, retargeted: true };
+}
+function retiredApiHostnames() {
+  return Object.keys(RETIRED_API_BASE_URLS);
+}
+function isLoopbackUrl(input) {
+  try {
+    const url2 = new URL(input);
+    if (url2.protocol !== "http:" && url2.protocol !== "https:") return false;
+    const loopbackHosts = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
+    return loopbackHosts.has(url2.hostname);
+  } catch {
+    return false;
+  }
+}
+function readConfiguredApiBaseUrl(explicit) {
+  const direct = explicit ?? process.env.MRRLIN_API_BASE_URL;
+  if (direct?.trim()) return retargetRetiredApiBaseUrl(direct.trim()).baseUrl;
+  if (process.env.MRRLIN_STAGING === "1") return STAGING_API_BASE_URL;
+  return DEFAULT_API_BASE_URL;
+}
+function isRemoteApiAllowed(apiBaseUrl) {
+  return isLoopbackUrl(apiBaseUrl) || isStagingApiBaseUrl(apiBaseUrl) || process.env.MRRLIN_API_ALLOW_REMOTE === "1" || process.env.MRRLIN_STAGING === "1";
+}
+function readProbeTimeoutMs(env) {
+  const raw = Number((env.MRRLIN_API_PROBE_TIMEOUT_MS ?? "").trim());
+  return Number.isFinite(raw) && raw > 0 ? raw : 500;
+}
+async function probeApiHealth(baseUrl, opts = {}) {
+  return probeLocalHealth(baseUrl, opts.timeoutMs ?? 2e3, opts.fetchImpl ?? fetch);
+}
+async function probeLocalHealth(baseUrl, timeoutMs, fetchImpl) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(`${baseUrl}/health`, { signal: controller.signal });
+    return res.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function resolveApiBaseUrlDynamic(opts = {}) {
+  const env = opts.env ?? process.env;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const direct = opts.explicit ?? env.MRRLIN_API_BASE_URL;
+  if (direct?.trim()) {
+    const { baseUrl, retargeted } = retargetRetiredApiBaseUrl(direct.trim());
+    return { baseUrl, source: retargeted ? "retired-retarget" : "explicit" };
+  }
+  if ((env.MRRLIN_STAGING ?? "").trim() === "1") return { baseUrl: STAGING_API_BASE_URL, source: "staging-env" };
+  const timeoutMs = opts.probeTimeoutMs ?? readProbeTimeoutMs(env);
+  if (await probeLocalHealth(DEFAULT_API_BASE_URL, timeoutMs, fetchImpl)) {
+    return { baseUrl: DEFAULT_API_BASE_URL, source: "local-probe" };
+  }
+  if ((env.MRRLIN_API_AUTODETECT ?? "").trim() === "1") {
+    if (await probeLocalHealth(DEFAULT_API_BASE_URL, timeoutMs, fetchImpl)) {
+      return { baseUrl: DEFAULT_API_BASE_URL, source: "local-probe" };
+    }
+    return { baseUrl: STAGING_API_BASE_URL, source: "staging-autodetect" };
+  }
+  throw new Error(
+    `Local Mrrlin API not reachable at ${DEFAULT_API_BASE_URL}. Start it, or set MRRLIN_STAGING=1 to target staging (or MRRLIN_API_AUTODETECT=1 to auto-fall back to staging when local is down).`
+  );
+}
+
 // src/browser-runtime.ts
 var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
@@ -20739,11 +20842,12 @@ async function installBrowser(opts = {}) {
 // src/install-codex.ts
 function deriveServeEnvFromProcessEnv(env) {
   const out = {};
-  const apiUrl = env.MRRLIN_API_BASE_URL?.trim();
-  if (apiUrl) {
+  const rawApiUrl = env.MRRLIN_API_BASE_URL?.trim();
+  const apiUrl = rawApiUrl ? retargetRetiredApiBaseUrl(rawApiUrl).baseUrl : void 0;
+  if (apiUrl && !isStagingApiBaseUrl(apiUrl)) {
     out.MRRLIN_API_BASE_URL = apiUrl;
     if (env.MRRLIN_API_ALLOW_REMOTE === "1") out.MRRLIN_API_ALLOW_REMOTE = "1";
-  } else if (env.MRRLIN_STAGING === "1") {
+  } else if (apiUrl || env.MRRLIN_STAGING === "1") {
     out.MRRLIN_STAGING = "1";
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -20886,6 +20990,20 @@ function classifyExistingBlock(actual, expected) {
   if (!isCoherentMrrlinEnv(env)) return "conflict";
   return "preserve-env-noop";
 }
+function blockEnvHasRetiredApiUrl(actual) {
+  if (typeof actual !== "object" || actual === null) return false;
+  const env = actual.env;
+  if (typeof env !== "object" || env === null) return false;
+  const pinned = env.MRRLIN_API_BASE_URL;
+  if (typeof pinned !== "string" || !pinned.trim()) return false;
+  let hostname3;
+  try {
+    hostname3 = new URL(pinned.trim()).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return retiredApiHostnames().includes(hostname3);
+}
 function renderEnvPreservedNotice(blockId, envKeys) {
   const keys = [...envKeys].sort().join(", ");
   return `[mrrlin-mcp install-codex] kept your existing [mcp_servers.${blockId}] env keys (${keys}) so your API target is preserved. Re-run with --force to replace or remove it.`;
@@ -20939,6 +21057,21 @@ async function installCodex(options) {
     if (existingTable !== void 0) {
       const classification = classifyExistingBlock(existingTable, block.expected);
       if (classification === "equal") continue;
+      if (blockEnvHasRetiredApiUrl(existingTable)) {
+        const existingEnv = existingTable.env ?? {};
+        const healedEnv = {};
+        for (const [key, value] of Object.entries(existingEnv)) {
+          if (key === "MRRLIN_API_BASE_URL") continue;
+          if (typeof value === "string") healedEnv[key] = value;
+        }
+        healedEnv.MRRLIN_STAGING = "1";
+        delete healedEnv.MRRLIN_API_ALLOW_REMOTE;
+        const healed = { ...block, expected: { ...block.expected, env: healedEnv } };
+        content = replaceBlock(content, block.blockRe, renderBlock(healed));
+        action = "replaced";
+        mutated = true;
+        continue;
+      }
       if (classification === "preserve-env-noop") {
         const env = existingTable.env ?? {};
         preservedEnvBlocks.push({ blockId: block.id, envKeys: Object.keys(env).sort() });
@@ -21020,10 +21153,10 @@ ${block}`;
 }
 
 // src/director-bridge.ts
-var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_fs13 = __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_path14 = __toESM(require("node:path"), 1);
+var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 var import_node_child_process10 = require("node:child_process");
 var import_node_crypto7 = __toESM(require("node:crypto"), 1);
 
@@ -22580,10 +22713,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path16) {
-  if (!path16)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path16.reduce((acc, key) => acc?.[key], obj);
+  return path18.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -22992,11 +23125,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path16, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path16);
+    iss.path.unshift(path18);
     return iss;
   });
 }
@@ -23143,16 +23276,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path16 = []) => {
+  const processError = (error52, path18 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -23179,17 +23312,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path16 = []) => {
+  const processError = (error52, path18 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -23221,8 +23354,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path16) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -35914,13 +36047,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path16 = ref.slice(1).split("/").filter(Boolean);
-  if (path16.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path16[0] === defsKey) {
-    const key = path16[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -36715,10 +36848,13 @@ var mrrlinDeliverablePayloadSchema = external_exports.object({
   contentHash: external_exports.string().min(1),
   format: external_exports.enum(["markdown"])
 });
-var SUPPORTED_EXECUTION_DOMAINS = ["code", "seo"];
-function isExecutionDomainSupported(domain2) {
-  return SUPPORTED_EXECUTION_DOMAINS.includes(domain2);
-}
+var SUPPORTED_EXECUTION_POLICY_BY_DOMAIN = {
+  code: { lane: "code", supported: true },
+  seo: { lane: "low_risk_non_code", supported: true },
+  marketing: { lane: "low_risk_non_code", supported: true },
+  content: { lane: "low_risk_non_code", supported: true }
+};
+var SUPPORTED_EXECUTION_DOMAINS = Object.keys(SUPPORTED_EXECUTION_POLICY_BY_DOMAIN);
 var taxonomyCategorySchema = external_exports.string().min(1).regex(/^[a-z][a-z0-9-]*$/);
 var taxonomySubcategorySchema = external_exports.string().min(1).regex(/^[a-z][a-z0-9-]*$/);
 var mrrlinTaskAssigneeSchema = external_exports.union([external_exports.string().regex(/^@/), external_exports.string().email()]).nullable();
@@ -37539,6 +37675,13 @@ var mrrlinAutonomousStepSchema = external_exports.enum([
   "needs_human",
   "enqueue_spec_draft",
   "enqueue_consensus",
+  // Server-side auto-promotion of spec_ready when consensus is disabled (owner-policy since
+  // 2026-08-03, item 4 of docs/superpowers/specs/2026-08-02-remaining-scheduler-blocks-design.md).
+  // Reported here because `/scheduler/pending` mirrors the decision engine's exact enum for the
+  // /autopilot page — but the tick RE-DERIVES on the same cycle after the CAS write, so a
+  // /scheduler/pending observer will typically only see this step during the tiny window between
+  // the CAS and the re-derivation (or never, if the tick coalesces both into one write).
+  "auto_mark_spec_ready",
   "auto_approve_spec_and_run",
   "create_execution_run"
 ]);
@@ -37554,8 +37697,7 @@ var mrrlinAutonomousStepReasonSchema = external_exports.enum([
   "awaiting_clarification",
   "consensus_blocked",
   "consensus_disabled_spec_not_ready",
-  "spec_approval_pending",
-  "non_code_execution_unsupported"
+  "spec_approval_pending"
 ]);
 var mrrlinAutonomousStepVerdictSchema = external_exports.object({
   step: mrrlinAutonomousStepSchema,
@@ -37913,18 +38055,18 @@ function createMrrlinClient(config2) {
   const customFetch = config2.fetch ?? globalThis.fetch;
   const baseUrl = config2.baseUrl.replace(/\/$/, "");
   const token = config2.token;
-  async function request(path16, init) {
+  async function request(path18, 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}${path16}`, { ...init, headers });
+    const response = await customFetch(`${baseUrl}${path18}`, { ...init, headers });
     if (!response.ok) {
       const body = await response.text();
       let code = `HTTP_${response.status}`;
       let violations = null;
-      let message = `Mrrlin API ${method} ${path16} failed: ${response.status}`;
+      let message = `Mrrlin API ${method} ${path18} failed: ${response.status}`;
       try {
         const parsed = JSON.parse(body);
         const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
@@ -37944,7 +38086,7 @@ function createMrrlinClient(config2) {
       throw new MrrlinApiError({
         code,
         method,
-        path: path16,
+        path: path18,
         responseBody: body,
         status: response.status,
         violations,
@@ -38199,7 +38341,7 @@ function createMrrlinClient(config2) {
       return taskEventListResponseSchema.parse(body).data;
     },
     async listTasks(projectSlug, filters = {}) {
-      const path16 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
+      const path18 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
         assignee: filters.assignee,
         autonomyLevel: filters.autonomyLevel,
         blockedBy: filters.blockedBy,
@@ -38211,7 +38353,7 @@ function createMrrlinClient(config2) {
         subcategory: filters.subcategory,
         type: filters.type
       });
-      const body = await request(path16);
+      const body = await request(path18);
       return taskListResponseSchema.parse(body).data;
     },
     async listTaxonomy(projectSlug) {
@@ -38219,22 +38361,22 @@ function createMrrlinClient(config2) {
       return taxonomyListResponseSchema.parse(body).data;
     },
     async listWikiPages(projectSlug, filters = {}) {
-      const path16 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
+      const path18 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
         folder: filters.folder,
         q: filters.q,
         taskId: filters.taskId
       });
-      const body = await request(path16);
+      const body = await request(path18);
       return wikiPageListResponseSchema.parse(body).data;
     },
     async searchWikiPages(projectSlug, query) {
-      const path16 = appendQuery(`${projectPath(projectSlug)}/wiki/search`, {
+      const path18 = 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(path16);
+      const body = await request(path18);
       return wikiPageSearchResponseSchema.parse(body).data;
     },
     async updatePlan(projectSlug, planId, patch) {
@@ -39117,68 +39259,405 @@ function startCodexProbe(deps = {}) {
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.47";
+var PKG_VERSION = "0.3.50";
 
-// src/api-base-url.ts
-var DEFAULT_API_BASE_URL = "http://127.0.0.1:8787";
-var STAGING_API_BASE_URL = "https://mrrlin-api-mrrlin2.vercel.app";
-function normalizeUrl(value) {
-  return value.replace(/\/$/, "");
+// src/api-base-url-migrate.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
+
+// src/service-paths.ts
+var import_node_path4 = __toESM(require("node:path"), 1);
+function isWorktreePath(p) {
+  const norm = import_node_path4.default.normalize(p).split(import_node_path4.default.sep).join("/");
+  return norm.includes("/.claude/worktrees/");
 }
-function isLoopbackUrl(input) {
+function resolveServiceCwd(opts) {
+  const chosen = (opts.explicit?.trim() || opts.cwd).trim();
+  if (isWorktreePath(chosen)) {
+    return {
+      ok: false,
+      reason: `Refusing to install a service rooted in a disposable worktree (${chosen}). Run install-service from the canonical repo root, or set MRRLIN_DIRECTOR_BRIDGE_CODEX_CWD to a stable path.`
+    };
+  }
+  return { ok: true, cwd: chosen };
+}
+var BRIDGE_APP_NAME = "mrrlin-bridge";
+function renderEcosystemConfig(opts) {
+  const env = {
+    HOME: opts.home,
+    PATH: opts.pathEnv,
+    MRRLIN_DIRECTOR_BRIDGE_LOG: "1"
+  };
+  if (opts.codexHome) env.CODEX_HOME = opts.codexHome;
+  const retargeted = opts.apiBaseUrl ? retargetRetiredApiBaseUrl(opts.apiBaseUrl).baseUrl : void 0;
+  if (opts.staging || retargeted && isStagingApiBaseUrl(retargeted)) env.MRRLIN_STAGING = "1";
+  else if (retargeted) env.MRRLIN_API_BASE_URL = retargeted;
+  const envLines = Object.entries(env).map(([k, v]) => `      ${k}: ${JSON.stringify(v)},`).join("\n");
+  return `module.exports = {
+  apps: [{
+    name: ${JSON.stringify(BRIDGE_APP_NAME)},
+    script: "mrrlin-mcp",
+    args: "director-bridge",
+    interpreter: "none",
+    cwd: ${JSON.stringify(opts.cwd)},
+    autorestart: true,
+    max_restarts: 10,
+    restart_delay: 3000,
+    kill_timeout: 10000,
+    env: {
+${envLines}
+    },
+  }],
+};
+`;
+}
+
+// src/api-base-url-migrate.ts
+function defaultDeps(deps) {
+  const home = deps.home ?? process.env.HOME ?? import_node_os3.default.homedir();
+  return {
+    home,
+    codexHome: deps.codexHome ?? process.env.CODEX_HOME?.trim() ?? import_node_path5.default.join(home, ".codex"),
+    readFile: deps.readFile ?? ((p) => import_node_fs2.default.readFileSync(p, "utf8")),
+    // Temp-file + atomic rename so a concurrent `serve` and `director-bridge` startup can never
+    // interleave partial writes into a config the next start has to parse. Note this normalizes the
+    // file to 0o600 — deliberate, since both files can carry a credential-bearing URL.
+    writeFile: deps.writeFile ?? ((p, c) => {
+      const tmp = `${p}.tmp-${process.pid}`;
+      import_node_fs2.default.writeFileSync(tmp, c, { mode: 384 });
+      import_node_fs2.default.renameSync(tmp, p);
+    }),
+    exists: deps.exists ?? ((p) => import_node_fs2.default.existsSync(p)),
+    log: deps.log ?? ((m) => process.stderr.write(`${m}
+`))
+  };
+}
+function findRetiredHost(text) {
+  return retiredApiHostnames().find((host) => text.toLowerCase().includes(host));
+}
+function isRetiredApiUrl(value) {
+  if (!value?.trim()) return false;
   try {
-    const url2 = new URL(input);
-    if (url2.protocol !== "http:" && url2.protocol !== "https:") return false;
-    const loopbackHosts = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
-    return loopbackHosts.has(url2.hostname);
+    return retiredApiHostnames().includes(new URL(value.trim()).hostname.toLowerCase());
   } catch {
     return false;
   }
 }
-function readConfiguredApiBaseUrl(explicit) {
-  const direct = explicit ?? process.env.MRRLIN_API_BASE_URL;
-  if (direct?.trim()) return normalizeUrl(direct.trim());
-  if (process.env.MRRLIN_STAGING === "1") return STAGING_API_BASE_URL;
-  return DEFAULT_API_BASE_URL;
+function backupOnce(file2, text, deps) {
+  const bak = `${file2}.bak-retired-api-url`;
+  if (!deps.exists(bak)) deps.writeFile(bak, text);
+}
+function migrateEcosystemConfig(deps = {}) {
+  const d = defaultDeps(deps);
+  const file2 = import_node_path5.default.join(d.home, ".mrrlin", "ecosystem.config.cjs");
+  if (!d.exists(file2)) return { file: file2, status: "absent" };
+  const text = d.readFile(file2);
+  if (!findRetiredHost(text)) return { file: file2, status: "clean" };
+  const fields = {
+    cwd: /cwd:\s*"((?:[^"\\]|\\.)*)"/.exec(text)?.[1],
+    home: /HOME:\s*"((?:[^"\\]|\\.)*)"/.exec(text)?.[1],
+    pathEnv: /PATH:\s*"((?:[^"\\]|\\.)*)"/.exec(text)?.[1],
+    codexHome: /CODEX_HOME:\s*"((?:[^"\\]|\\.)*)"/.exec(text)?.[1]
+  };
+  if (fields.cwd && fields.home && fields.pathEnv) {
+    const retiredUrl = /MRRLIN_API_BASE_URL:\s*"((?:[^"\\]|\\.)*)"/.exec(text)?.[1];
+    const legacyShape = retiredUrl && isRetiredApiUrl(retiredUrl) ? renderEcosystemConfigLegacy({
+      cwd: fields.cwd,
+      home: fields.home,
+      pathEnv: fields.pathEnv,
+      codexHome: fields.codexHome,
+      apiBaseUrl: retiredUrl
+    }) : void 0;
+    if (legacyShape && legacyShape === text) {
+      backupOnce(file2, text, d);
+      d.writeFile(
+        file2,
+        renderEcosystemConfig({
+          cwd: fields.cwd,
+          home: fields.home,
+          pathEnv: fields.pathEnv,
+          codexHome: fields.codexHome,
+          staging: true,
+          apiBaseUrl: void 0
+        })
+      );
+      return { file: file2, status: "migrated", detail: "regenerated from the canonical template" };
+    }
+  }
+  const lineRe = /^[ \t]*MRRLIN_API_BASE_URL:\s*"((?:[^"\\]|\\.)*)",?[ \t]*\r?\n/gm;
+  const matches = (text.match(lineRe) ?? []).filter((line) => !line.trimStart().startsWith("//"));
+  const target = matches.length === 1 ? matches[0] : void 0;
+  if (target !== void 0 && isRetiredApiUrl(/"((?:[^"\\]|\\.)*)"/.exec(target)?.[1])) {
+    backupOnce(file2, text, d);
+    const indent = /^[ \t]*/.exec(target)?.[0] ?? "      ";
+    d.writeFile(file2, text.replace(target, () => `${indent}MRRLIN_STAGING: "1",
+`));
+    return { file: file2, status: "migrated", detail: "replaced the pinned URL line with MRRLIN_STAGING" };
+  }
+  return {
+    file: file2,
+    status: "skipped-drifted",
+    detail: matches.length === 0 ? "a retired host appears in the file but no MRRLIN_API_BASE_URL line was found \u2014 fix it by hand or re-run install-service" : `found ${matches.length} MRRLIN_API_BASE_URL lines; refusing to guess \u2014 fix by hand or re-run install-service`
+  };
 }
-function isRemoteApiAllowed(apiBaseUrl) {
-  return isLoopbackUrl(apiBaseUrl) || process.env.MRRLIN_API_ALLOW_REMOTE === "1" || process.env.MRRLIN_STAGING === "1";
+function renderEcosystemConfigLegacy(opts) {
+  return renderEcosystemConfigWithEnv(opts, { MRRLIN_API_BASE_URL: opts.apiBaseUrl });
 }
-function readProbeTimeoutMs(env) {
-  const raw = Number((env.MRRLIN_API_PROBE_TIMEOUT_MS ?? "").trim());
-  return Number.isFinite(raw) && raw > 0 ? raw : 500;
+function renderEcosystemConfigWithEnv(opts, extra) {
+  const env = {
+    HOME: opts.home,
+    PATH: opts.pathEnv,
+    MRRLIN_DIRECTOR_BRIDGE_LOG: "1"
+  };
+  if (opts.codexHome) env.CODEX_HOME = opts.codexHome;
+  Object.assign(env, extra);
+  const envLines = Object.entries(env).map(([k, v]) => `      ${k}: ${JSON.stringify(v)},`).join("\n");
+  return `module.exports = {
+  apps: [{
+    name: "mrrlin-bridge",
+    script: "mrrlin-mcp",
+    args: "director-bridge",
+    interpreter: "none",
+    cwd: ${JSON.stringify(opts.cwd)},
+    autorestart: true,
+    max_restarts: 10,
+    restart_delay: 3000,
+    kill_timeout: 10000,
+    env: {
+${envLines}
+    },
+  }],
+};
+`;
 }
-async function probeLocalHealth(baseUrl, timeoutMs, fetchImpl) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+function migrateCodexConfig(deps = {}) {
+  const d = defaultDeps(deps);
+  const file2 = import_node_path5.default.join(d.codexHome, "config.toml");
+  if (!d.exists(file2)) return { file: file2, status: "absent" };
+  const text = d.readFile(file2);
+  const host = findRetiredHost(text);
+  if (!host) return { file: file2, status: "clean" };
+  const managedBlockRe = /^\[mcp_servers\.mrrlin\][^\n]*\n(?:(?!\[)[^\n]*\n?)*/gm;
+  const blocks = text.match(managedBlockRe) ?? [];
+  if (blocks.length === 0) {
+    return {
+      file: file2,
+      status: "skipped-drifted",
+      detail: "a retired host appears in the file but no [mcp_servers.mrrlin] block was found \u2014 left untouched"
+    };
+  }
+  const assignRe = /MRRLIN_API_BASE_URL\s*=\s*"([^"]*)"/g;
+  let out = text;
+  let changed = 0;
+  for (const block of blocks) {
+    let blockChanged = false;
+    const healedBlock = block.split("\n").map((line) => {
+      if (line.trimStart().startsWith("#")) return line;
+      const healedLine = line.replace(
+        assignRe,
+        (match, url2) => isRetiredApiUrl(url2) ? `MRRLIN_STAGING = "1"` : match
+      );
+      if (healedLine !== line) blockChanged = true;
+      return healedLine;
+    }).join("\n");
+    if (!blockChanged) continue;
+    const deduped = healedBlock.replace(/MRRLIN_STAGING = "1"\s*,\s*MRRLIN_STAGING = "1"/g, `MRRLIN_STAGING = "1"`);
+    out = out.replace(block, () => deduped);
+    changed += 1;
+  }
+  if (changed === 0) {
+    return {
+      file: file2,
+      status: "skipped-drifted",
+      detail: "the retired host is not pinned by a MRRLIN_API_BASE_URL value inside a managed block \u2014 left untouched"
+    };
+  }
+  backupOnce(file2, text, d);
+  d.writeFile(file2, out);
+  return { file: file2, status: "migrated", detail: "swapped the pinned URL for MRRLIN_STAGING" };
+}
+function migrateRetiredApiBaseUrls(deps = {}) {
+  const d = defaultDeps(deps);
+  const results = [];
+  const steps = [
+    { run: migrateEcosystemConfig, file: import_node_path5.default.join(d.home, ".mrrlin", "ecosystem.config.cjs") },
+    { run: migrateCodexConfig, file: import_node_path5.default.join(d.codexHome, "config.toml") }
+  ];
+  for (const step of steps) {
+    try {
+      results.push(step.run(deps));
+    } catch (error51) {
+      const detail = error51 instanceof Error ? error51.message : String(error51);
+      results.push({ file: step.file, status: "failed", detail });
+    }
+  }
+  for (const r of results) {
+    if (r.status === "migrated") {
+      d.log(`[mrrlin-mcp] healed a retired API URL in ${r.file} (${r.detail}).`);
+    } else if (r.status === "skipped-drifted" || r.status === "failed") {
+      d.log(`[mrrlin-mcp] WARNING: could not heal ${r.file}: ${r.detail}`);
+    }
+  }
+  if (results.some((r) => r.status === "migrated" && r.file.endsWith("ecosystem.config.cjs"))) {
+    d.log(
+      "[mrrlin-mcp] the running process is already retargeted in memory; for pm2 to pick up the healed ecosystem file run: pm2 delete mrrlin-bridge && pm2 start ~/.mrrlin/ecosystem.config.cjs && pm2 save"
+    );
+  }
+  return results;
+}
+
+// src/bridge-health.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path6 = __toESM(require("node:path"), 1);
+var SENTINEL_FILE_NAME = "bridge-health-circuit-breaker.json";
+var CRASH_WINDOW_MS = 60 * 60 * 1e3;
+var MAX_CRASHES_PER_WINDOW = 3;
+var DEFAULT_STUCK_MS = 15 * 60 * 1e3;
+var DEFAULT_OPERATION_TIMEOUT_MS = 3e4;
+function isCrashSentinel(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.crashCount === "number" && Number.isInteger(candidate.crashCount) && candidate.crashCount >= 0 && typeof candidate.windowStartedAt === "string";
+}
+async function readCrashSentinel(stateDir, now = Date.now) {
+  const sentinelPath = import_node_path6.default.join(stateDir, SENTINEL_FILE_NAME);
   try {
-    const res = await fetchImpl(`${baseUrl}/health`, { signal: controller.signal });
-    return res.ok;
+    const raw = await import_node_fs3.promises.readFile(sentinelPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (isCrashSentinel(parsed)) return parsed;
   } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
   }
+  return { crashCount: 0, windowStartedAt: new Date(now()).toISOString() };
 }
-async function resolveApiBaseUrlDynamic(opts = {}) {
-  const env = opts.env ?? process.env;
-  const fetchImpl = opts.fetchImpl ?? fetch;
-  const direct = opts.explicit ?? env.MRRLIN_API_BASE_URL;
-  if (direct?.trim()) return { baseUrl: normalizeUrl(direct.trim()), source: "explicit" };
-  if ((env.MRRLIN_STAGING ?? "").trim() === "1") return { baseUrl: STAGING_API_BASE_URL, source: "staging-env" };
-  const timeoutMs = opts.probeTimeoutMs ?? readProbeTimeoutMs(env);
-  if (await probeLocalHealth(DEFAULT_API_BASE_URL, timeoutMs, fetchImpl)) {
-    return { baseUrl: DEFAULT_API_BASE_URL, source: "local-probe" };
+async function writeCrashSentinel(stateDir, sentinel) {
+  await import_node_fs3.promises.mkdir(stateDir, { recursive: true });
+  const sentinelPath = import_node_path6.default.join(stateDir, SENTINEL_FILE_NAME);
+  const tmpPath = `${sentinelPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  await import_node_fs3.promises.writeFile(tmpPath, JSON.stringify(sentinel), "utf8");
+  await import_node_fs3.promises.rename(tmpPath, sentinelPath);
+}
+function withTimeout(fn, ms = DEFAULT_OPERATION_TIMEOUT_MS) {
+  const controller = new AbortController();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      controller.abort();
+      const timeoutError = new Error(`operation timed out after ${ms}ms`);
+      timeoutError.code = "BRIDGE_HEALTH_TIMEOUT";
+      reject(timeoutError);
+    }, ms);
+    fn(controller.signal).then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error51) => {
+        clearTimeout(timer);
+        reject(error51);
+      }
+    );
+  });
+}
+var defaultLogger = {
+  critical(message) {
+    process.stderr.write(`[mrrlin-mcp director-bridge] ${message}
+`);
   }
-  if ((env.MRRLIN_API_AUTODETECT ?? "").trim() === "1") {
-    if (await probeLocalHealth(DEFAULT_API_BASE_URL, timeoutMs, fetchImpl)) {
-      return { baseUrl: DEFAULT_API_BASE_URL, source: "local-probe" };
+};
+var BridgeHealthTracker = class {
+  stateDir;
+  stuckMs;
+  now;
+  processExit;
+  logger;
+  // Initialized to construction time, NOT 0/undefined: a freshly (re)started process — including
+  // one that just restarted BECAUSE this breaker tripped — must not treat its own startup instant
+  // as "ages ago that nothing succeeded." Without this, the very first tracked failure after any
+  // restart would evaluate as instantly stuck, exhausting the crash-loop guard's 3 attempts within
+  // seconds and inverting this mechanism into the outage it exists to prevent.
+  lastSuccessAt;
+  disabled = false;
+  knownCrashCount = null;
+  lastErrorByOperation = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.stateDir = opts.stateDir;
+    this.stuckMs = opts.stuckMs ?? readStuckMsFromEnv() ?? DEFAULT_STUCK_MS;
+    this.now = opts.now ?? Date.now;
+    this.processExit = opts.processExit ?? ((code) => process.exit(code));
+    this.logger = opts.logger ?? defaultLogger;
+    this.lastSuccessAt = this.now();
+  }
+  /** Wraps a tracked operation: applies the hard timeout, records the outcome, and re-throws or
+   *  returns exactly what `fn` produced so the caller's own existing error handling is untouched. */
+  async track(id, fn) {
+    try {
+      const result = await withTimeout(fn);
+      await this.recordSuccess();
+      return result;
+    } catch (error51) {
+      this.recordFailure(id, error51);
+      throw error51;
     }
-    return { baseUrl: STAGING_API_BASE_URL, source: "staging-autodetect" };
   }
-  throw new Error(
-    `Local Mrrlin API not reachable at ${DEFAULT_API_BASE_URL}. Start it, or set MRRLIN_STAGING=1 to target staging (or MRRLIN_API_AUTODETECT=1 to auto-fall back to staging when local is down).`
-  );
+  async recordSuccess() {
+    this.lastSuccessAt = this.now();
+    if (this.knownCrashCount === null) {
+      await this.reconcileCrashCountOnFirstSuccess();
+    }
+  }
+  recordFailure(id, error51) {
+    this.lastErrorByOperation.set(id, error51 instanceof Error ? error51.message : String(error51));
+  }
+  /** True when no tracked operation has succeeded within `stuckMs`. */
+  isStuck() {
+    return this.now() - this.lastSuccessAt >= this.stuckMs;
+  }
+  /** Call after `track()` settles a failure. Exits the process (up to 3 times per rolling hour)
+   *  once stuck; a no-op once the breaker has disabled itself for this process's lifetime. */
+  async maybeCrash() {
+    if (this.disabled) return;
+    if (!this.isStuck()) return;
+    const decision = await this.decideExitOrDisable();
+    if (decision.exit) {
+      this.logger.critical(
+        `bridge health: stuck ${Math.round((this.now() - this.lastSuccessAt) / 1e3)}s (threshold ${Math.round(this.stuckMs / 1e3)}s) \u2014 crashing so pm2 restarts clean. Last errors: ${this.formatLastErrors()}`
+      );
+      this.processExit(1);
+    } else {
+      this.disabled = true;
+      this.logger.critical(
+        "bridge health: circuit breaker disabled after 3 restarts in the last hour \u2014 this looks like a persistent outage, not a stuck process."
+      );
+    }
+  }
+  async decideExitOrDisable() {
+    const nowMs = this.now();
+    let sentinel = await readCrashSentinel(this.stateDir, this.now);
+    const windowStartedMs = Date.parse(sentinel.windowStartedAt);
+    if (!Number.isFinite(windowStartedMs) || nowMs - windowStartedMs > CRASH_WINDOW_MS) {
+      sentinel = { crashCount: 0, windowStartedAt: new Date(nowMs).toISOString() };
+    }
+    sentinel = { ...sentinel, crashCount: sentinel.crashCount + 1 };
+    await writeCrashSentinel(this.stateDir, sentinel);
+    return { exit: sentinel.crashCount <= MAX_CRASHES_PER_WINDOW };
+  }
+  async reconcileCrashCountOnFirstSuccess() {
+    const sentinel = await readCrashSentinel(this.stateDir, this.now);
+    this.knownCrashCount = sentinel.crashCount;
+    if (sentinel.crashCount > 0) {
+      await writeCrashSentinel(this.stateDir, { ...sentinel, crashCount: 0 });
+      this.knownCrashCount = 0;
+    }
+  }
+  formatLastErrors() {
+    if (this.lastErrorByOperation.size === 0) return "none recorded";
+    return Array.from(this.lastErrorByOperation.entries()).map(([id, message]) => `${id}=${message}`).join(", ");
+  }
+};
+function readStuckMsFromEnv(env = process.env) {
+  const raw = (env.MRRLIN_BRIDGE_HEALTH_STUCK_MS ?? "").trim();
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
 }
 
 // src/scheduler-tick.ts
@@ -39219,17 +39698,30 @@ function dispatchTickWork(deps, results) {
   }
 }
 async function fireSchedulerTick(deps) {
+  const bridgeHealth = deps.bridgeHealth;
+  const { nextWakeAt, failed } = await attemptSchedulerTick(deps);
+  if (failed) await bridgeHealth?.maybeCrash();
+  return { nextWakeAt };
+}
+async function attemptSchedulerTick(deps) {
   const fetchImpl = deps.fetchImpl ?? fetch;
+  const bridgeHealth = deps.bridgeHealth;
   try {
-    const response = await fetchImpl(`${deps.apiBaseUrl}/internal/scheduler/run`, { method: "POST" });
+    const parseTick = async (signal) => {
+      const response2 = await fetchImpl(`${deps.apiBaseUrl}/internal/scheduler/run`, { method: "POST", signal });
+      const parsedBody2 = response2.ok ? await response2.json() : null;
+      return { response: response2, parsedBody: parsedBody2 };
+    };
+    const { response, parsedBody } = bridgeHealth ? await withTimeout(parseTick) : await parseTick(new AbortController().signal);
     if (!response.ok) {
       process.stderr.write(
         `[mrrlin-mcp director-bridge] scheduler tick failed: HTTP ${response.status} from /internal/scheduler/run
 `
       );
-      return { nextWakeAt: null };
+      bridgeHealth?.recordFailure("schedulerTick", new Error(`HTTP ${response.status}`));
+      return { nextWakeAt: null, failed: true };
     }
-    const body = await response.json();
+    const body = parsedBody;
     const data = body?.data ?? {};
     const results = Array.isArray(data.results) ? data.results : [];
     deps.logger.logOut({
@@ -39263,13 +39755,15 @@ async function fireSchedulerTick(deps) {
       }
     });
     dispatchTickWork(deps, results);
-    return { nextWakeAt: typeof data.nextWakeAt === "string" ? data.nextWakeAt : null };
+    await bridgeHealth?.recordSuccess();
+    return { nextWakeAt: typeof data.nextWakeAt === "string" ? data.nextWakeAt : null, failed: false };
   } catch (error51) {
     process.stderr.write(
       `[mrrlin-mcp director-bridge] scheduler tick failed: ${error51 instanceof Error ? error51.message : String(error51)}
 `
     );
-    return { nextWakeAt: null };
+    bridgeHealth?.recordFailure("schedulerTick", error51);
+    return { nextWakeAt: null, failed: true };
   }
 }
 function startSchedulerTickLoop(deps) {
@@ -39505,7 +39999,7 @@ function startAgentPoolLoop(deps) {
 // src/execution-consumer.ts
 var import_node_child_process9 = require("node:child_process");
 var import_node_crypto4 = __toESM(require("node:crypto"), 1);
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
 
 // src/consensus/heads.ts
@@ -39514,8 +40008,8 @@ var DOMAINS = ["code", "seo", "marketing", "content"];
 var HEADS_BY_DOMAIN = {
   code: ["plan-reviewer", "architect", "security-analyst", "scope-analyst"],
   seo: ["plan-reviewer", "scope-analyst", "seo-analyst"],
-  marketing: ["plan-reviewer", "scope-analyst", "content-editor"],
-  content: ["plan-reviewer", "scope-analyst", "content-editor"]
+  marketing: ["plan-reviewer", "scope-analyst", "content-editor", "compliance-reviewer"],
+  content: ["plan-reviewer", "scope-analyst", "content-editor", "compliance-reviewer"]
 };
 var SPEC_HEADS = HEADS_BY_DOMAIN.code;
 function normalizeDomain(value) {
@@ -39542,8 +40036,8 @@ function resolveProducerPersona(domain2) {
 
 // src/consensus/wiring.ts
 var import_node_crypto2 = __toESM(require("node:crypto"), 1);
-var import_node_fs2 = __toESM(require("node:fs"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 
 // src/consensus/codex-exec.ts
@@ -39962,15 +40456,15 @@ ${res.stdout}${res.stderr}`);
 var import_meta2 = {};
 function getPersonasDir() {
   if (typeof __dirname !== "undefined") {
-    return import_node_path4.default.join(__dirname, "consensus", "personas");
+    return import_node_path7.default.join(__dirname, "consensus", "personas");
   }
-  return import_node_path4.default.join(import_node_path4.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url)), "personas");
+  return import_node_path7.default.join(import_node_path7.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.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_fs2.default.readFileSync(import_node_path4.default.join(getPersonasDir(), `${name}.md`), "utf8");
+  const content = import_node_fs4.default.readFileSync(import_node_path7.default.join(getPersonasDir(), `${name}.md`), "utf8");
   personaCache.set(name, content);
   return content;
 }
@@ -41097,7 +41591,7 @@ function isDeployGateRunStatus(status) {
 
 // src/turn-deadline.ts
 var DEFAULT_TURN_INTERRUPT_TIMEOUT_MS = 5e3;
-function withTimeout(promise2, ms, message) {
+function withTimeout2(promise2, ms, message) {
   let timer = null;
   const timeout = new Promise((_, reject) => {
     timer = setTimeout(() => reject(new Error(message)), ms);
@@ -41145,7 +41639,7 @@ async function awaitTurnWithDeadline(opts) {
     const isDeadline = message === opts.timeoutMessage || hasIdle && message === opts.idleTimeoutMessage;
     if (isDeadline) {
       try {
-        await withTimeout(
+        await withTimeout2(
           opts.interrupt(),
           opts.interruptTimeoutMs ?? DEFAULT_TURN_INTERRUPT_TIMEOUT_MS,
           "turn.interrupt timed out"
@@ -41161,18 +41655,18 @@ async function awaitTurnWithDeadline(opts) {
 
 // src/worktree.ts
 var import_node_child_process8 = require("node:child_process");
-var import_node_fs4 = require("node:fs");
-var import_node_os3 = require("node:os");
-var import_node_path6 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_os4 = require("node:os");
+var import_node_path9 = require("node:path");
 
 // src/checkout-lock.ts
-var import_node_fs3 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path8 = require("node:path");
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 async function withCheckoutLock(locksDir, slug, fn) {
-  (0, import_node_fs3.mkdirSync)(locksDir, { recursive: true });
-  const target = (0, import_node_path5.join)(locksDir, `${slug}.lock`);
-  if (!(0, import_node_fs3.existsSync)(target)) (0, import_node_fs3.writeFileSync)(target, "");
+  (0, import_node_fs5.mkdirSync)(locksDir, { recursive: true });
+  const target = (0, import_node_path8.join)(locksDir, `${slug}.lock`);
+  if (!(0, import_node_fs5.existsSync)(target)) (0, import_node_fs5.writeFileSync)(target, "");
   const release = await import_proper_lockfile.default.lock(target, {
     retries: { retries: 600, factor: 1, minTimeout: 100, maxTimeout: 100 },
     stale: 5 * 6e4
@@ -41197,12 +41691,12 @@ function git(checkout, args) {
   });
 }
 async function createRunWorktree(opts) {
-  const worktreePath = (0, import_node_path6.join)(opts.worktreeRoot, opts.slug, opts.runId);
+  const worktreePath = (0, import_node_path9.join)(opts.worktreeRoot, opts.slug, opts.runId);
   await withCheckoutLock(opts.locksDir, opts.slug, async () => {
-    (0, import_node_fs4.mkdirSync)(opts.worktreeRoot, { recursive: true });
+    (0, import_node_fs6.mkdirSync)(opts.worktreeRoot, { recursive: true });
     try {
       git(opts.checkout, ["fetch", "origin", opts.defaultBranch]);
-      if (!(0, import_node_fs4.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs6.existsSync)(worktreePath)) {
         git(opts.checkout, [
           "worktree",
           "add",
@@ -41260,15 +41754,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_fs4.mkdtempSync)((0, import_node_path6.join)((0, import_node_os3.tmpdir)(), "mrrlin-push-"));
-  const askpass = (0, import_node_path6.join)(dir, "askpass");
+  const dir = (0, import_node_fs6.mkdtempSync)((0, import_node_path9.join)((0, import_node_os4.tmpdir)(), "mrrlin-push-"));
+  const askpass = (0, import_node_path9.join)(dir, "askpass");
   try {
-    (0, import_node_fs4.writeFileSync)(
+    (0, import_node_fs6.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_fs4.chmodSync)(askpass, 320);
+    (0, import_node_fs6.chmodSync)(askpass, 320);
     execGit(
       [
         "-C",
@@ -41287,18 +41781,18 @@ async function doPushRunBranch(opts, execGit) {
     );
     return { pushedSha: localSha };
   } finally {
-    (0, import_node_fs4.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs6.rmSync)(dir, { recursive: true, force: true });
   }
 }
 async function sweepOrphanWorktrees(opts) {
   const reaped = [];
   const ownedPrefix = (() => {
     try {
-      return (0, import_node_fs4.realpathSync)(opts.worktreeRoot);
+      return (0, import_node_fs6.realpathSync)(opts.worktreeRoot);
     } catch {
       return opts.worktreeRoot;
     }
-  })() + import_node_path6.sep + opts.slug + import_node_path6.sep;
+  })() + import_node_path9.sep + opts.slug + import_node_path9.sep;
   await withCheckoutLock(opts.locksDir, opts.slug, async () => {
     const listing = git(opts.checkout, ["worktree", "list", "--porcelain"]);
     for (const block of listing.split("\n\n")) {
@@ -41559,8 +42053,8 @@ function newArtifactId() {
   return `EA-${import_node_crypto4.default.randomUUID()}`;
 }
 var BLAST_RADIUS_FLOOR_PATTERNS = [/^supabase\/migrations\//, /^packages\/db\/src\/schema\.ts$/];
-function isBlastRadiusFloorPath(path16) {
-  return BLAST_RADIUS_FLOOR_PATTERNS.some((re) => re.test(path16));
+function isBlastRadiusFloorPath(path18) {
+  return BLAST_RADIUS_FLOOR_PATTERNS.some((re) => re.test(path18));
 }
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process9.execFile);
 async function defaultListRunDiffPaths(opts) {
@@ -42185,17 +42679,6 @@ async function writeDeliverablePage(client, projectSlug, task, markdown) {
   throw new Error(`could not allocate a deliverable page id for ${task.id} (last conflict: ${lastConflict})`);
 }
 async function driveNonCodeRun(deps, projectSlug, runId, leaseId, task, domain2) {
-  if (!isExecutionDomainSupported(domain2)) {
-    await failRun(
-      deps,
-      projectSlug,
-      task,
-      runId,
-      leaseId,
-      `non_code_execution_unsupported: task ${task.id} domain "${domain2}" is not in the execution whitelist.`
-    );
-    return;
-  }
   const personaName = resolveProducerPersona(domain2);
   if (!personaName) {
     await failRun(
@@ -42522,8 +43005,8 @@ async function runBackstopSweep(deps, drive = (slug, id) => driveRun(deps, slug,
 function isRunRecoverableByThisBridge(run3, worktreeRoot) {
   if (!worktreeRoot) return true;
   if (!run3.worktreeId) return false;
-  const relative = import_node_path7.default.relative(import_node_path7.default.resolve(worktreeRoot), import_node_path7.default.resolve(run3.worktreeId));
-  return relative === "" || relative.length > 0 && !relative.startsWith("..") && !import_node_path7.default.isAbsolute(relative);
+  const relative = import_node_path10.default.relative(import_node_path10.default.resolve(worktreeRoot), import_node_path10.default.resolve(run3.worktreeId));
+  return relative === "" || relative.length > 0 && !relative.startsWith("..") && !import_node_path10.default.isAbsolute(relative);
 }
 async function deployGateHandoff(deps, projectSlug, task, runId, reason, leaseId) {
   await deps.client.updateExecutionRun(projectSlug, runId, { status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), leaseId: leaseId ?? void 0 }).catch(() => {
@@ -42987,19 +43470,19 @@ function codexIdleMs() {
 }
 
 // src/operator-token.ts
-var import_node_fs5 = require("node:fs");
-var import_node_os4 = __toESM(require("node:os"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs7 = require("node:fs");
+var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 function operatorDir() {
-  const base = process.env.CODEX_HOME ? import_node_path8.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path8.default.join(import_node_os4.default.homedir(), ".mrrlin");
+  const base = process.env.CODEX_HOME ? import_node_path11.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path11.default.join(import_node_os5.default.homedir(), ".mrrlin");
   return base;
 }
 function operatorTokenPath() {
-  return import_node_path8.default.join(operatorDir(), "operator-token");
+  return import_node_path11.default.join(operatorDir(), "operator-token");
 }
 function readOperatorToken() {
   try {
-    const token = (0, import_node_fs5.readFileSync)(operatorTokenPath(), "utf8").trim();
+    const token = (0, import_node_fs7.readFileSync)(operatorTokenPath(), "utf8").trim();
     return token.length > 0 ? token : null;
   } catch {
     return null;
@@ -43007,24 +43490,24 @@ function readOperatorToken() {
 }
 function persistOperatorToken(token) {
   const dir = operatorDir();
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
-  (0, import_node_fs5.writeFileSync)(operatorTokenPath(), `${token.trim()}
+  (0, import_node_fs7.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs7.writeFileSync)(operatorTokenPath(), `${token.trim()}
 `, { encoding: "utf8", mode: 384 });
 }
 function agentCredentialPath() {
-  return import_node_path8.default.join(operatorDir(), "agent-credential");
+  return import_node_path11.default.join(operatorDir(), "agent-credential");
 }
 function persistAgentSecret(secret) {
   const dir = operatorDir();
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
-  (0, import_node_fs5.writeFileSync)(agentCredentialPath(), `${secret.trim()}
+  (0, import_node_fs7.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs7.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_fs5.readFileSync)(agentCredentialPath(), "utf8").trim();
+    const raw = (0, import_node_fs7.readFileSync)(agentCredentialPath(), "utf8").trim();
     return raw || void 0;
   } catch {
     return void 0;
@@ -43032,16 +43515,16 @@ function readAgentSecret() {
 }
 
 // src/thread-index.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs8 = require("node:fs");
+var import_node_path12 = __toESM(require("node:path"), 1);
 function threadIndexPath(stateDir) {
-  return import_node_path9.default.join(stateDir, "threads.json");
+  return import_node_path12.default.join(stateDir, "threads.json");
 }
 function loadThreadIndex(stateDir, ttlMs, now) {
   const result = /* @__PURE__ */ new Map();
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs6.readFileSync)(threadIndexPath(stateDir), "utf8"));
+    parsed = JSON.parse((0, import_node_fs8.readFileSync)(threadIndexPath(stateDir), "utf8"));
   } catch {
     return result;
   }
@@ -43063,8 +43546,8 @@ function loadThreadIndex(stateDir, ttlMs, now) {
   return result;
 }
 function saveThreadIndex(stateDir, entries) {
-  (0, import_node_fs6.mkdirSync)(stateDir, { recursive: true, mode: 448 });
-  (0, import_node_fs6.writeFileSync)(threadIndexPath(stateDir), `${JSON.stringify(Object.fromEntries(entries), null, 2)}
+  (0, import_node_fs8.mkdirSync)(stateDir, { recursive: true, mode: 448 });
+  (0, import_node_fs8.writeFileSync)(threadIndexPath(stateDir), `${JSON.stringify(Object.fromEntries(entries), null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -43150,9 +43633,9 @@ function chatTurnMaxMs() {
 
 // src/worker-token.ts
 var import_node_crypto6 = require("node:crypto");
-var import_node_fs7 = require("node:fs");
-var import_node_os5 = __toESM(require("node:os"), 1);
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs9 = require("node:fs");
+var import_node_os6 = __toESM(require("node:os"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 var DEFAULT_WORKER_PORT = 8792;
 function workerPort() {
   const raw = process.env.MRRLIN_WORKER_PORT;
@@ -43161,15 +43644,15 @@ function workerPort() {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_WORKER_PORT;
 }
 function workerDir() {
-  const base = process.env.CODEX_HOME ? import_node_path10.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path10.default.join(import_node_os5.default.homedir(), ".mrrlin");
-  return import_node_path10.default.join(base, "worker");
+  const base = process.env.CODEX_HOME ? import_node_path13.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path13.default.join(import_node_os6.default.homedir(), ".mrrlin");
+  return import_node_path13.default.join(base, "worker");
 }
 function workerTokenPath() {
-  return import_node_path10.default.join(workerDir(), "token");
+  return import_node_path13.default.join(workerDir(), "token");
 }
 function readWorkerToken() {
   try {
-    const token = (0, import_node_fs7.readFileSync)(workerTokenPath(), "utf8").trim();
+    const token = (0, import_node_fs9.readFileSync)(workerTokenPath(), "utf8").trim();
     return token.length > 0 ? token : null;
   } catch {
     return null;
@@ -43179,18 +43662,18 @@ function readOrCreateWorkerToken() {
   const existing = readWorkerToken();
   if (existing) return existing;
   const dir = workerDir();
-  (0, import_node_fs7.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs9.mkdirSync)(dir, { recursive: true, mode: 448 });
   const token = (0, import_node_crypto6.randomBytes)(32).toString("hex");
-  (0, import_node_fs7.writeFileSync)(workerTokenPath(), `${token}
+  (0, import_node_fs9.writeFileSync)(workerTokenPath(), `${token}
 `, { encoding: "utf8", mode: 384 });
   return token;
 }
 
 // src/remote-phone-relay.ts
 var import_node_events2 = require("node:events");
-var import_node_fs8 = require("node:fs");
-var import_node_os6 = require("node:os");
-var import_node_path11 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_os7 = require("node:os");
+var import_node_path14 = require("node:path");
 
 // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/cryptoNode.js
 var nc = __toESM(require("node:crypto"), 1);
@@ -46761,9 +47244,9 @@ var DirectorRelay = class {
 
 // src/remote-phone-relay.ts
 function loadOrCreateAgentDeviceKey() {
-  const path16 = (0, import_node_path11.join)((0, import_node_os6.homedir)(), ".mrrlin", "agent-device-key");
+  const path18 = (0, import_node_path14.join)((0, import_node_os7.homedir)(), ".mrrlin", "agent-device-key");
   try {
-    const raw = JSON.parse((0, import_node_fs8.readFileSync)(path16, "utf8"));
+    const raw = JSON.parse((0, import_node_fs10.readFileSync)(path18, "utf8"));
     if (typeof raw.priv === "string" && typeof raw.pub === "string") {
       return { privateKey: fromBase64Url(raw.priv), publicKey: fromBase64Url(raw.pub) };
     }
@@ -46771,9 +47254,9 @@ function loadOrCreateAgentDeviceKey() {
   }
   const kp = generateIdentityKeyPair();
   try {
-    (0, import_node_fs8.mkdirSync)((0, import_node_path11.join)((0, import_node_os6.homedir)(), ".mrrlin"), { recursive: true });
-    (0, import_node_fs8.writeFileSync)(
-      path16,
+    (0, import_node_fs10.mkdirSync)((0, import_node_path14.join)((0, import_node_os7.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs10.writeFileSync)(
+      path18,
       JSON.stringify({ priv: toBase64Url(kp.privateKey), pub: toBase64Url(kp.publicKey) }),
       { mode: 384 }
     );
@@ -46781,10 +47264,10 @@ function loadOrCreateAgentDeviceKey() {
   }
   return kp;
 }
-var AGENT_PAIRING_PATH = (0, import_node_path11.join)((0, import_node_os6.homedir)(), ".mrrlin", "agent-pairing.json");
+var AGENT_PAIRING_PATH = (0, import_node_path14.join)((0, import_node_os7.homedir)(), ".mrrlin", "agent-pairing.json");
 function loadAgentPairing() {
   try {
-    const raw = JSON.parse((0, import_node_fs8.readFileSync)(AGENT_PAIRING_PATH, "utf8"));
+    const raw = JSON.parse((0, import_node_fs10.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,
@@ -46799,8 +47282,8 @@ function loadAgentPairing() {
 }
 function saveAgentPairing(record2) {
   try {
-    (0, import_node_fs8.mkdirSync)((0, import_node_path11.join)((0, import_node_os6.homedir)(), ".mrrlin"), { recursive: true });
-    (0, import_node_fs8.writeFileSync)(AGENT_PAIRING_PATH, JSON.stringify(record2), { mode: 384 });
+    (0, import_node_fs10.mkdirSync)((0, import_node_path14.join)((0, import_node_os7.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs10.writeFileSync)(AGENT_PAIRING_PATH, JSON.stringify(record2), { mode: 384 });
   } catch {
   }
 }
@@ -46977,18 +47460,18 @@ async function renderPairingQrSvg(payload) {
 }
 
 // src/checkout-registry.ts
-var import_node_fs9 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path15 = require("node:path");
 var CheckoutRegistry = class {
   file;
   constructor(stateDir) {
-    this.file = (0, import_node_path12.join)(stateDir, "checkouts.json");
-    (0, import_node_fs9.mkdirSync)(stateDir, { recursive: true });
+    this.file = (0, import_node_path15.join)(stateDir, "checkouts.json");
+    (0, import_node_fs11.mkdirSync)(stateDir, { recursive: true });
   }
   read() {
-    if (!(0, import_node_fs9.existsSync)(this.file)) return {};
+    if (!(0, import_node_fs11.existsSync)(this.file)) return {};
     try {
-      return JSON.parse((0, import_node_fs9.readFileSync)(this.file, "utf8"));
+      return JSON.parse((0, import_node_fs11.readFileSync)(this.file, "utf8"));
     } catch {
       return {};
     }
@@ -46996,10 +47479,10 @@ var CheckoutRegistry = class {
   get(slug) {
     return this.read()[slug] ?? null;
   }
-  confirm(slug, path16, now) {
+  confirm(slug, path18, now) {
     const all = this.read();
-    all[slug] = { path: path16, confirmedAt: now };
-    (0, import_node_fs9.writeFileSync)(this.file, JSON.stringify(all, null, 2));
+    all[slug] = { path: path18, confirmedAt: now };
+    (0, import_node_fs11.writeFileSync)(this.file, JSON.stringify(all, null, 2));
   }
 };
 
@@ -47210,8 +47693,8 @@ function extractVerificationSection(markdown) {
 }
 
 // src/bridge-log.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path16 = require("node:path");
 
 // src/redact.ts
 var REDACTED = "[REDACTED]";
@@ -47296,14 +47779,14 @@ function resolvePromptsEnabled(env) {
 }
 function createBridgeLogger(stateDir, env = process.env) {
   if (!resolveBridgeLogEnabled(env)) return NOOP_LOGGER;
-  const logsDir = (0, import_node_path13.join)(stateDir, "logs");
+  const logsDir = (0, import_node_path16.join)(stateDir, "logs");
   try {
-    (0, import_node_fs10.mkdirSync)(logsDir, { recursive: true });
+    (0, import_node_fs12.mkdirSync)(logsDir, { recursive: true });
   } catch {
     return NOOP_LOGGER;
   }
   const includePrompts = resolvePromptsEnabled(env);
-  const fileFor = () => (0, import_node_path13.join)(logsDir, `bridge-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
+  const fileFor = () => (0, import_node_path16.join)(logsDir, `bridge-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
   const write = (dir, rec) => {
     try {
       const line = JSON.stringify({
@@ -47315,7 +47798,7 @@ function createBridgeLogger(stateDir, env = process.env) {
         ...rec.ms !== void 0 ? { ms: rec.ms } : {},
         payload: redactMessage(rec.payload, { includePrompts })
       }) + "\n";
-      (0, import_node_fs10.appendFileSync)(fileFor(), line);
+      (0, import_node_fs12.appendFileSync)(fileFor(), line);
     } catch {
     }
   };
@@ -47333,10 +47816,9 @@ var DEFAULT_DIRECTOR_BRIDGE_ALLOWED_ORIGINS = [
   "http://localhost:*",
   "http://127.0.0.1:*",
   "http://[::1]:*",
-  // Staging Vercel team migrated 2026-07-28 (see docs/reference/deployments.md); the prior
-  // fnnzzz-fnnzzzs-projects alias is kept below for any operator still on an old bridge build.
+  // Staging Vercel team migrated 2026-07-28 (see docs/reference/deployments.md). The prior
+  // fnnzzz-fnnzzzs-projects web alias was dropped once no operator was left on an old build.
   "https://mrrlin-web-mrrlin2.vercel.app",
-  "https://mrrlin-web-fnnzzz-fnnzzzs-projects.vercel.app",
   "https://app.mrrlin.dev",
   "https://mrrlin-web.vercel.app"
 ];
@@ -47385,7 +47867,7 @@ function addBridgeModel(target, model) {
 }
 function readTextIfExists(filePath) {
   try {
-    return import_node_fs11.default.readFileSync(filePath, "utf8");
+    return import_node_fs13.default.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -47396,9 +47878,9 @@ function readKnownGptSlugsFromTomlFile(filePath) {
   return Array.from(raw.matchAll(/^\s*model\s*=\s*"([^"]+)"/gm)).map((match) => match[1]?.trim() ?? "").filter(isSelectableModelSlug);
 }
 function readCodexFallbackModels() {
-  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path14.default.join(import_node_os7.default.homedir(), ".codex");
+  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path17.default.join(import_node_os8.default.homedir(), ".codex");
   const models = /* @__PURE__ */ new Map();
-  const cachePath = import_node_path14.default.join(codexHome, "models_cache.json");
+  const cachePath = import_node_path17.default.join(codexHome, "models_cache.json");
   const cacheRaw = readTextIfExists(cachePath);
   if (cacheRaw) {
     try {
@@ -47448,7 +47930,7 @@ function readCodexFallbackModels() {
       );
     }
   }
-  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path14.default.join(codexHome, "config.toml"))) {
+  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path17.default.join(codexHome, "config.toml"))) {
     addBridgeModel(
       models,
       mapBridgeModel({
@@ -47462,11 +47944,11 @@ function readCodexFallbackModels() {
       })
     );
   }
-  const automationsDir = import_node_path14.default.join(codexHome, "automations");
+  const automationsDir = import_node_path17.default.join(codexHome, "automations");
   try {
-    for (const entry of import_node_fs11.default.readdirSync(automationsDir, { withFileTypes: true })) {
+    for (const entry of import_node_fs13.default.readdirSync(automationsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path14.default.join(automationsDir, entry.name, "automation.toml"))) {
+      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path17.default.join(automationsDir, entry.name, "automation.toml"))) {
         addBridgeModel(
           models,
           mapBridgeModel({
@@ -47486,9 +47968,9 @@ function readCodexFallbackModels() {
   return [...models.values()];
 }
 function neutralCheckoutCwd(stateDir) {
-  const dir = import_node_path14.default.join(stateDir, "no-checkout");
+  const dir = import_node_path17.default.join(stateDir, "no-checkout");
   try {
-    import_node_fs11.default.mkdirSync(dir, { recursive: true });
+    import_node_fs13.default.mkdirSync(dir, { recursive: true });
   } catch {
   }
   return dir;
@@ -47538,7 +48020,7 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "  bullets (`- AND ...` as needed). Scenarios make the spec verifiable.",
     "- Keep behavior contracts in the spec; implementation details belong in `## Implementation Plan`.",
     "- Apply this format ONLY to Specs/{id} pages; do not retro-fit it onto other wiki page types.",
-    "- Spec consensus runs ASYNCHRONOUSLY. Call `run_spec_consensus` for a `Specs/{id}` page; it returns IMMEDIATELY. On `already_converged`, the spec is already marked ready \u2014 proceed straight to `create_execution_run`; do NOT call `mark_spec_ready` and do NOT re-run consensus. On `queued` or `already_running`, tell the user it was launched and END your turn \u2014 do NOT poll or call it again; the result arrives in the inbox (an `info` item on CONVERGED, a `handoff` item if it was blocked/failed). When a consensus `info` item says CONVERGED, proceed to `create_execution_run`. When a `handoff` says it was blocked, address the recorded issues in the spec (any edit re-arms the gate) and call `run_spec_consensus` once more. For a NON-code task (domain seo/marketing/content, ADR 0020): supported domains like `seo` proceed to `create_execution_run` after consensus converges; unsupported domains fail-close with `non_code_execution_unsupported`. Report the spec's review outcome to the operator.",
+    "- Spec consensus runs ASYNCHRONOUSLY. Call `run_spec_consensus` for a `Specs/{id}` page; it returns IMMEDIATELY. On `already_converged`, the spec is already marked ready \u2014 proceed straight to `create_execution_run`; do NOT call `mark_spec_ready` and do NOT re-run consensus. On `queued` or `already_running`, tell the user it was launched and END your turn \u2014 do NOT poll or call it again; the result arrives in the inbox (an `info` item on CONVERGED, a `handoff` item if it was blocked/failed). When a consensus `info` item says CONVERGED, proceed to `create_execution_run`. When a `handoff` says it was blocked, address the recorded issues in the spec (any edit re-arms the gate) and call `run_spec_consensus` once more. For a NON-code task (domain seo/marketing/content, ADR 0020): the low-risk lanes `seo`, `marketing`, and `content` proceed to `create_execution_run` after consensus converges, using the same flow as code tasks. Report the spec's review outcome to the operator.",
     '- When a task needs a browser (login flows, UI verification/clicks, scraping), pass `prerequisites:[{mcp:"mrrlin-browser",reason:"..."}]` to `create_execution_run`. If that run later fails into a handoff, the operator gets a one-click "Launch browser & resume" that brings up the dedicated browser as the turn starts.',
     "- When you actually drive a browser (calling `browser_navigate`, `browser_click`, `browser_snapshot`, `browser_type`, etc.), invoke those tools from the **`mrrlin-browser`** MCP server ONLY. Do NOT use tools from any other browser MCP (`playwright`, `chrome-devtools`, `puppeteer`, etc.) even if they are also connected on this operator's box \u2014 those use a shared/default Playwright profile that is fragile across runs. Only `mrrlin-browser` uses this project's dedicated Chromium + persistent operator profile (`~/.mrrlin/browser/profile`). If your host exposes multiple browser MCPs with overlapping tool names, prefer the `mrrlin-browser` server unconditionally.",
     "",
@@ -47804,7 +48286,7 @@ async function runOrphanWorktreeSweep(client, opts) {
   const cutoff = Date.now() - worktreeRetentionMs();
   const isReapable = (worktreePath) => {
     try {
-      return import_node_fs11.default.statSync(worktreePath).mtimeMs < cutoff;
+      return import_node_fs13.default.statSync(worktreePath).mtimeMs < cutoff;
     } catch {
       return false;
     }
@@ -47842,8 +48324,8 @@ async function runOrphanWorktreeSweep(client, opts) {
   }
 }
 function readStateDir() {
-  if (process.env.CODEX_HOME) return import_node_path14.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
-  return import_node_path14.default.join(import_node_os7.default.homedir(), ".mrrlin", "director-bridge");
+  if (process.env.CODEX_HOME) return import_node_path17.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
+  return import_node_path17.default.join(import_node_os8.default.homedir(), ".mrrlin", "director-bridge");
 }
 function readAllowedOrigins() {
   const raw = (process.env.MRRLIN_DIRECTOR_BRIDGE_ALLOWED_ORIGINS ?? "").trim();
@@ -48378,7 +48860,7 @@ function createBridgeMessageHandler(deps) {
           }
         }
         takenOver.cancel?.();
-        void withTimeout(
+        void withTimeout2(
           codexClient.turn.interrupt({ threadId: takenOver.threadId }),
           DEFAULT_TURN_INTERRUPT_TIMEOUT_MS,
           "interrupt timed out"
@@ -48580,7 +49062,7 @@ function createBridgeMessageHandler(deps) {
                   reason === "idle" ? `Director turn stalled \u2014 no activity for ${Math.round(idleMs / 1e3)}s. Stopping; try again.` : `Director turn exceeded the ${Math.round(maxMs / 1e3)}s ceiling. Stopping; try again.`
                 )
               );
-              void withTimeout(codexClient.turn.interrupt({ threadId }), DEFAULT_TURN_INTERRUPT_TIMEOUT_MS, "interrupt timed out").catch(
+              void withTimeout2(codexClient.turn.interrupt({ threadId }), DEFAULT_TURN_INTERRUPT_TIMEOUT_MS, "interrupt timed out").catch(
                 () => {
                   if (deps.threads.get(directorSessionId) === thread) {
                     deps.threads.delete(directorSessionId);
@@ -48791,6 +49273,10 @@ async function startDirectorBridge() {
   const codexProbeHandle = startCodexProbe();
   const consumerState = { inFlightRunId: null, lastClaimAt: null };
   const health = createServiceHealth();
+  try {
+    migrateRetiredApiBaseUrls();
+  } catch {
+  }
   const apiBaseUrl = readConfiguredApiBaseUrl();
   if (!isRemoteApiAllowed(apiBaseUrl)) {
     throw new Error(
@@ -48870,8 +49356,8 @@ async function startDirectorBridge() {
     codexCwd: config2.codexCwd,
     codexExecutable: config2.codexExecutable,
     checkoutRegistry,
-    worktreeRoot: import_node_path14.default.join(config2.stateDir, "worktrees"),
-    locksDir: import_node_path14.default.join(config2.stateDir, "locks"),
+    worktreeRoot: import_node_path17.default.join(config2.stateDir, "worktrees"),
+    locksDir: import_node_path17.default.join(config2.stateDir, "locks"),
     // Wire the executor server for code-execution runs. Each run gets its own app-server
     // process at the run worktree, running UNRESTRICTED from the real ~/.codex (owner
     // no-sandbox decision — auth + mrrlin MCP come from the operator config).
@@ -48907,13 +49393,13 @@ async function startDirectorBridge() {
         // egressDomains is retained in the seam signature (verification-turn.ts still computes the
         // env host) but no longer constrains anything — the executor is unrestricted.
         startSandbox: async (_egressDomains) => {
-          const cwd = import_node_fs11.default.mkdtempSync(import_node_path14.default.join(import_node_os7.default.tmpdir(), "mrrlin-verify-"));
+          const cwd = import_node_fs13.default.mkdtempSync(import_node_path17.default.join(import_node_os8.default.tmpdir(), "mrrlin-verify-"));
           let handle;
           try {
             handle = await startExecutorServer({ worktree: cwd });
           } catch (error51) {
             try {
-              import_node_fs11.default.rmSync(cwd, { recursive: true, force: true });
+              import_node_fs13.default.rmSync(cwd, { recursive: true, force: true });
             } catch {
             }
             throw error51;
@@ -48924,7 +49410,7 @@ async function startDirectorBridge() {
             dispose: () => {
               handle.dispose();
               try {
-                import_node_fs11.default.rmSync(cwd, { recursive: true, force: true });
+                import_node_fs13.default.rmSync(cwd, { recursive: true, force: true });
               } catch {
               }
             }
@@ -49132,7 +49618,7 @@ async function startDirectorBridge() {
   const bridgeLogger = createBridgeLogger(config2.stateDir, process.env);
   let bridgeBinShaShort = "unknown00000";
   try {
-    bridgeBinShaShort = import_node_crypto7.default.createHash("sha256").update(import_node_fs11.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
+    bridgeBinShaShort = import_node_crypto7.default.createHash("sha256").update(import_node_fs13.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
   } catch {
   }
   attachBridgeWss(server, {
@@ -49219,34 +49705,50 @@ async function startDirectorBridge() {
     dispatchServer.on("error", reject);
     dispatchServer.listen(workerPort(), "127.0.0.1", () => resolve());
   });
+  const bridgeHealth = new BridgeHealthTracker({ stateDir: config2.stateDir });
+  const runTrackedSweep = async (id, label, fn) => {
+    try {
+      await fn();
+      await bridgeHealth.recordSuccess();
+    } catch (error51) {
+      process.stderr.write(
+        `[mrrlin-mcp director-bridge] ${label} failed: ${error51 instanceof Error ? error51.message : String(error51)}
+`
+      );
+      bridgeHealth.recordFailure(id, error51);
+      await bridgeHealth.maybeCrash();
+    }
+  };
   let claimLoopStopped = false;
   let claimTimer = null;
   const scheduleClaimLoop = () => {
     if (claimLoopStopped) return;
     claimTimer = setTimeout(() => {
       enqueueRun(
-        () => runBackstopSweep(consumerDeps, (slug, runId) => {
-          driveTracked(slug, runId);
-          return Promise.resolve();
-        }).catch((error51) => {
-          process.stderr.write(`[mrrlin-mcp director-bridge] claim sweep failed: ${error51 instanceof Error ? error51.message : String(error51)}
-`);
-        })
+        () => runTrackedSweep(
+          "claimSweep",
+          "claim sweep",
+          () => runBackstopSweep(consumerDeps, (slug, runId) => {
+            driveTracked(slug, runId);
+            return Promise.resolve();
+          })
+        )
       );
       enqueueRun(
-        () => runAsyncBackstopSweep(asyncConsumerDeps, (slug, jobId) => {
-          driveAsyncTracked(slug, jobId);
-          return Promise.resolve();
-        }).catch((error51) => {
-          process.stderr.write(`[mrrlin-mcp director-bridge] async sweep failed: ${error51 instanceof Error ? error51.message : String(error51)}
-`);
-        })
+        () => runTrackedSweep(
+          "asyncSweep",
+          "async sweep",
+          () => runAsyncBackstopSweep(asyncConsumerDeps, (slug, jobId) => {
+            driveAsyncTracked(slug, jobId);
+            return Promise.resolve();
+          })
+        )
       );
       enqueueRun(
         () => runOrphanWorktreeSweep(client, {
           checkoutRegistry,
-          worktreeRoot: import_node_path14.default.join(config2.stateDir, "worktrees"),
-          locksDir: import_node_path14.default.join(config2.stateDir, "locks")
+          worktreeRoot: import_node_path17.default.join(config2.stateDir, "worktrees"),
+          locksDir: import_node_path17.default.join(config2.stateDir, "locks")
         })
       );
       enqueueRun(async () => {
@@ -49307,6 +49809,7 @@ async function startDirectorBridge() {
       apiBaseUrl,
       fetchImpl: authedFetch,
       logger: bridgeLogger,
+      bridgeHealth,
       dispatchEnqueued: (projectSlug, work) => {
         if (work.kind === "execution_run") driveRunNow(projectSlug, work.runId);
         else driveAsyncNow(projectSlug, work.jobId);
@@ -49507,15 +50010,15 @@ function readDispatchBody(req) {
 function readOrCreateBridgeToken(stateDir) {
   const explicit = (process.env.MRRLIN_DIRECTOR_BRIDGE_TOKEN ?? "").trim();
   if (explicit) return explicit;
-  const tokenPath = import_node_path14.default.join(stateDir, "token.txt");
+  const tokenPath = import_node_path17.default.join(stateDir, "token.txt");
   try {
-    const existing = import_node_fs11.default.readFileSync(tokenPath, "utf8").trim();
+    const existing = import_node_fs13.default.readFileSync(tokenPath, "utf8").trim();
     if (existing) return existing;
   } catch {
   }
-  import_node_fs11.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
+  import_node_fs13.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
   const token = import_node_crypto7.default.randomBytes(32).toString("base64url");
-  import_node_fs11.default.writeFileSync(tokenPath, `${token}
+  import_node_fs13.default.writeFileSync(tokenPath, `${token}
 `, { mode: 384 });
   return token;
 }
@@ -52899,17 +53402,17 @@ var StdioServerTransport = class {
 // src/tools.ts
 var import_node_crypto10 = require("node:crypto");
 var import_promises3 = require("node:fs/promises");
-var import_node_fs12 = require("node:fs");
-var import_node_path16 = __toESM(require("node:path"), 1);
-var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_fs14 = require("node:fs");
+var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_os9 = __toESM(require("node:os"), 1);
 var import_node_child_process12 = require("node:child_process");
 
 // ../../packages/wiki/dist/index.js
 var import_promises2 = __toESM(require("node:fs/promises"), 1);
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path18 = __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_path15.default.sep).join("/");
+  return input.split(import_node_path18.default.sep).join("/");
 }
 function slugifyWikiSegment(input) {
   return input.trim().toLowerCase().replace(/`/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -52923,12 +53426,12 @@ async function pathExists2(input) {
   }
 }
 async function findWorkspaceRoot(start = process.cwd()) {
-  let current = import_node_path15.default.resolve(start);
+  let current = import_node_path18.default.resolve(start);
   while (true) {
-    if (await pathExists2(import_node_path15.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path15.default.join(current, "docs"))) {
+    if (await pathExists2(import_node_path18.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path18.default.join(current, "docs"))) {
       return current;
     }
-    const parent = import_node_path15.default.dirname(current);
+    const parent = import_node_path18.default.dirname(current);
     if (parent === current) {
       throw new Error(`Unable to find Mrrlin workspace root from ${start}`);
     }
@@ -52937,28 +53440,28 @@ async function findWorkspaceRoot(start = process.cwd()) {
 }
 async function resolveDocsRoot(input) {
   if (input) {
-    return import_node_path15.default.resolve(input);
+    return import_node_path18.default.resolve(input);
   }
   if (process.env.MRRLIN_DOCS_ROOT) {
-    return import_node_path15.default.resolve(process.env.MRRLIN_DOCS_ROOT);
+    return import_node_path18.default.resolve(process.env.MRRLIN_DOCS_ROOT);
   }
-  return import_node_path15.default.join(await findWorkspaceRoot(), "docs");
+  return import_node_path18.default.join(await findWorkspaceRoot(), "docs");
 }
 async function resolveIndexPath(input) {
   if (input) {
-    return import_node_path15.default.resolve(input);
+    return import_node_path18.default.resolve(input);
   }
   if (process.env.MRRLIN_WIKI_INDEX_PATH) {
-    return import_node_path15.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
+    return import_node_path18.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
   }
   const workspaceRoot = await findWorkspaceRoot();
-  return import_node_path15.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
+  return import_node_path18.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_path15.default.join(dir, entry.name);
+    const absolute = import_node_path18.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkMarkdownFiles(root, absolute));
       continue;
@@ -52977,7 +53480,7 @@ function parseTitle(markdown, sourcePath) {
   return title;
 }
 function documentFromFile(docsRoot, absolutePath, markdown) {
-  const relativePath = toPosixPath(import_node_path15.default.relative(docsRoot, absolutePath));
+  const relativePath = toPosixPath(import_node_path18.default.relative(docsRoot, absolutePath));
   const [section, fileName] = relativePath.split("/");
   if (!section || !fileName || !INCLUDED_DOC_FOLDERS.has(section)) {
     return null;
@@ -54875,7 +55378,7 @@ var mcpToolDescriptions = {
   [mcpToolNames.resetDirectorThread]: "Clear a task's persisted Director execution thread handle so the next execution run starts a fresh provider thread. Records a director_thread_reset task event.",
   [mcpToolNames.updateWikiPage]: "Update a markdown Wiki page.",
   [mcpToolNames.markSpecReady]: "Mark a wiki page (folder=Specs) as ready (or not) for execution-run gating. The Director sets this true after validating the spec; any edit to the page's markdown auto-resets it to false.",
-  [mcpToolNames.runSpecConsensus]: 'Enqueue the consensus review gate over a Specs/{id} page. Returns IMMEDIATELY with one of: already_converged (a CONVERGED review already exists for the current content \u2014 proceed straight to create_execution_run, do NOT call mark_spec_ready, it is already set), already_reviewed (a terminal CONSENSUS_BLOCKED for this content), already_running (a consensus job is in flight), or queued (a new job was launched). The review runs in the background; its result/blocker arrives in the inbox (info on CONVERGED, handoff on failure) and is surfaced into the open chat. Do NOT call again for the same spec and do NOT poll. On queued/already_running, tell the user it was launched and end the turn. Pass extraHeads: ["researcher"] for specs referencing external libraries/APIs, or ["debugger"] for root-cause/investigation specs to add opt-in specialist reviewers on top of the fixed four. For a NON-code task (domain seo/marketing/content, ADR 0020): supported domains like `seo` proceed to `create_execution_run` after consensus; unsupported domains fail-close with `non_code_execution_unsupported`. Report the spec\'s review outcome to the operator.',
+  [mcpToolNames.runSpecConsensus]: 'Enqueue the consensus review gate over a Specs/{id} page. Returns IMMEDIATELY with one of: already_converged (a CONVERGED review already exists for the current content \u2014 proceed straight to create_execution_run, do NOT call mark_spec_ready, it is already set), already_reviewed (a terminal CONSENSUS_BLOCKED for this content), already_running (a consensus job is in flight), or queued (a new job was launched). The review runs in the background; its result/blocker arrives in the inbox (info on CONVERGED, handoff on failure) and is surfaced into the open chat. Do NOT call again for the same spec and do NOT poll. On queued/already_running, tell the user it was launched and end the turn. Pass extraHeads: ["researcher"] for specs referencing external libraries/APIs, or ["debugger"] for root-cause/investigation specs to add opt-in specialist reviewers on top of the fixed four. For a NON-code task (domain seo/marketing/content, ADR 0020): the low-risk lanes `seo`, `marketing`, and `content` proceed to `create_execution_run` after consensus, using the same flow as code tasks. Report the spec\'s review outcome to the operator.',
   [mcpToolNames.runCodeReviewerGate]: `Review the current branch's code diff (vs baseRef) with a Code Reviewer gate \u2014 independent reviewers iterate review\u2192fix\u2192re-check (checkpoint, scope-limited reviser edits, typecheck/build fast-gate, rollback) until the diff converges or is blocked. Run before opening a PR. Pass extraHeads: ["security-analyst"] for sensitive diffs (auth, secrets, input handling, new endpoints).`,
   [mcpToolNames.appendExecutionArtifact]: "Append a durable artifact (plan, checkpoint, command output, test result, diff summary, self-review, error, deploy attempt, or handoff judgement) to an execution run.",
   [mcpToolNames.recordProducedUrl]: 'Call this after publishing each web page produced by the task, so the UI link opens the page itself instead of the deployed site root. Pass the page\'s full https URL (for external pages, e.g. "https://dev.to/<slug>") OR a path starting with "/" for the deploy environment (e.g. "/blog/<slug>") \u2014 paths are resolved against the run\'s deployed env URL at render time. Optional `label` (\u226440 chars) is shown next to the link; omit and the UI defaults to the page title. Call once per page; multiple calls dedupe by resolved URL in the UI.',
@@ -55325,7 +55828,7 @@ function createMrrlinTools(options) {
         if (!config2.consensusEnabled) {
           throw new McpToolCodedError(
             "SPEC_CONSENSUS_REQUIRED",
-            `Spec ${pageId} cannot be marked ready by the Director while consensus is disabled for this project \u2014 an operator must approve it (web wiki / markSpecReady route). Autonomy is a landing gate, not a license to self-promote.`
+            `Spec ${pageId} cannot be marked ready by the Director-LLM while consensus is disabled for this project \u2014 an operator must approve it (web wiki / markSpecReady route). The scheduler tick may auto-promote server-side under the consensus-off policy; that is a different code path with different trust assumptions.`
           );
         }
         const page = await c.getWikiPage(projectSlug, pageId);
@@ -55532,7 +56035,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_path16.default.extname(filePath).toLowerCase();
+        const extension2 = import_node_path19.default.extname(filePath).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -55560,7 +56063,7 @@ function createMrrlinTools(options) {
             "Artifact exceeds 5MB; split or summarize instead."
           );
         }
-        const filename = import_node_path16.default.basename(filePath);
+        const filename = import_node_path19.default.basename(filePath);
         const created = await c.createArtifactFile(projectSlug, {
           class: artifactClass,
           contentType,
@@ -55643,7 +56146,7 @@ function createMrrlinTools(options) {
       "Unable to register local checkout.",
       async (_c, { projectSlug, path: checkoutPath, repo }) => {
         const trimmedPath = checkoutPath.trim();
-        if (!import_node_path16.default.isAbsolute(trimmedPath)) {
+        if (!import_node_path19.default.isAbsolute(trimmedPath)) {
           throw new McpToolCodedError(
             "LOCAL_CHECKOUT_PATH_NOT_ABSOLUTE",
             `Path must be absolute, got: ${trimmedPath}`
@@ -55651,7 +56154,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",
@@ -55678,7 +56181,7 @@ function createMrrlinTools(options) {
             `Origin remote ${remoteUrl} does not match repo ${repo}.`
           );
         }
-        const stateDir = process.env.CODEX_HOME ? import_node_path16.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path16.default.join(import_node_os8.default.homedir(), ".mrrlin", "director-bridge");
+        const stateDir = process.env.CODEX_HOME ? import_node_path19.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path19.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);
@@ -55853,14 +56356,29 @@ function createMrrlinMcpServer(options = {}) {
 async function startStdioServer(options = {}) {
   let effective = options;
   if (!options.apiBaseUrl) {
+    try {
+      migrateRetiredApiBaseUrls();
+    } catch {
+    }
     const { baseUrl, source } = await resolveApiBaseUrlDynamic();
     effective = {
       ...options,
       apiBaseUrl: baseUrl,
-      allowRemoteApi: source === "staging-env" || source === "staging-autodetect"
+      allowRemoteApi: source === "staging-env" || source === "staging-autodetect" || source === "retired-retarget"
     };
     process.stderr.write(`[mrrlin-mcp] API resolved: ${redactUrlForLog(baseUrl)} (source=${source})
 `);
+    if (source === "retired-retarget") {
+      process.stderr.write(
+        "[mrrlin-mcp] your configured API URL names a RETIRED host; retargeted to the current staging target for this process. Re-run install-service/install-codex to persist the fix.\n"
+      );
+    }
+    if (!await probeApiHealth(baseUrl)) {
+      process.stderr.write(
+        `[mrrlin-mcp] WARNING: ${redactUrlForLog(baseUrl)}/health did not answer OK (source=${source}). If source=explicit, the URL comes from MRRLIN_API_BASE_URL in ~/.mrrlin/ecosystem.config.cjs or the [mcp_servers.mrrlin] env in ~/.codex/config.toml.
+`
+      );
+    }
   }
   const { resolved, server } = createMrrlinMcpServer(effective);
   const transport = new StdioServerTransport();
@@ -55885,56 +56403,8 @@ function runSetCredential(args) {
 }
 
 // src/install-service.ts
-var import_node_os9 = __toESM(require("node:os"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
-
-// src/service-paths.ts
-var import_node_path17 = __toESM(require("node:path"), 1);
-function isWorktreePath(p) {
-  const norm = import_node_path17.default.normalize(p).split(import_node_path17.default.sep).join("/");
-  return norm.includes("/.claude/worktrees/");
-}
-function resolveServiceCwd(opts) {
-  const chosen = (opts.explicit?.trim() || opts.cwd).trim();
-  if (isWorktreePath(chosen)) {
-    return {
-      ok: false,
-      reason: `Refusing to install a service rooted in a disposable worktree (${chosen}). Run install-service from the canonical repo root, or set MRRLIN_DIRECTOR_BRIDGE_CODEX_CWD to a stable path.`
-    };
-  }
-  return { ok: true, cwd: chosen };
-}
-var BRIDGE_APP_NAME = "mrrlin-bridge";
-function renderEcosystemConfig(opts) {
-  const env = {
-    HOME: opts.home,
-    PATH: opts.pathEnv,
-    MRRLIN_DIRECTOR_BRIDGE_LOG: "1"
-  };
-  if (opts.codexHome) env.CODEX_HOME = opts.codexHome;
-  if (opts.staging) env.MRRLIN_STAGING = "1";
-  else if (opts.apiBaseUrl) env.MRRLIN_API_BASE_URL = opts.apiBaseUrl;
-  const envLines = Object.entries(env).map(([k, v]) => `      ${k}: ${JSON.stringify(v)},`).join("\n");
-  return `module.exports = {
-  apps: [{
-    name: ${JSON.stringify(BRIDGE_APP_NAME)},
-    script: "mrrlin-mcp",
-    args: "director-bridge",
-    interpreter: "none",
-    cwd: ${JSON.stringify(opts.cwd)},
-    autorestart: true,
-    max_restarts: 10,
-    restart_delay: 3000,
-    kill_timeout: 10000,
-    env: {
-${envLines}
-    },
-  }],
-};
-`;
-}
-
-// src/install-service.ts
+var import_node_os10 = __toESM(require("node:os"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 function installService(deps) {
   if (!deps.hasSecret()) {
     deps.log("No agent credential found. Issue one in Settings, then run: mrrlin-mcp set-credential '<secret>'.");
@@ -55945,7 +56415,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.");
@@ -55956,7 +56426,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_path18.default.dirname(b)))).join(":");
+  const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path20.default.dirname(b)))).join(":");
   const text = renderEcosystemConfig({
     cwd: resolved.cwd,
     home,
@@ -55965,7 +56435,7 @@ function installService(deps) {
     staging: deps.env.MRRLIN_STAGING === "1",
     apiBaseUrl: deps.env.MRRLIN_API_BASE_URL?.trim() || void 0
   });
-  const ecoPath = import_node_path18.default.join(home, ".mrrlin", "ecosystem.config.cjs");
+  const ecoPath = import_node_path20.default.join(home, ".mrrlin", "ecosystem.config.cjs");
   deps.writeFile(ecoPath, text);
   const start = deps.runPm2(["startOrReload", ecoPath]);
   if (start.code !== 0) {
@@ -55996,13 +56466,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_path19 = __toESM(require("node:path"), 1);
+var import_node_os11 = __toESM(require("node:os"), 1);
+var import_node_path21 = __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_path19.default.join(options.homeDir ?? import_node_os10.default.homedir(), ".codex");
+  return import_node_path21.default.join(options.homeDir ?? import_node_os11.default.homedir(), ".codex");
 }
 async function pathExists3(target) {
   try {
@@ -56015,7 +56485,7 @@ async function pathExists3(target) {
 var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.(?:mrrlin(?:-browser)?|external-agents)(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
 async function uninstallCodex(options = {}) {
   const codexHome = resolveCodexHome2(options);
-  const configPath = import_node_path19.default.join(codexHome, "config.toml");
+  const configPath = import_node_path21.default.join(codexHome, "config.toml");
   const removePrompts = async () => uninstallPrompts(codexHome, options.promptNames ?? []);
   if (!await pathExists3(configPath)) {
     return { action: "missing", configPath, prompts: await removePrompts() };
@@ -56043,10 +56513,10 @@ async function uninstallCodex(options = {}) {
 }
 async function uninstallPrompts(codexHome, names) {
   if (names.length === 0) return [];
-  const promptsDir = import_node_path19.default.join(codexHome, "prompts");
+  const promptsDir = import_node_path21.default.join(codexHome, "prompts");
   const out = [];
   for (const name of names) {
-    const promptPath = import_node_path19.default.join(promptsDir, `${name}.md`);
+    const promptPath = import_node_path21.default.join(promptsDir, `${name}.md`);
     try {
       await import_promises4.default.unlink(promptPath);
       out.push({ name, action: "removed", promptPath });
@@ -56299,8 +56769,8 @@ async function main() {
         }
       }
       try {
-        const codexHome = process.env.CODEX_HOME ?? import_node_path21.default.join(process.env.HOME ?? (0, import_node_os11.homedir)(), ".codex");
-        (0, import_node_fs13.rmSync)(import_node_path21.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
+        const codexHome = process.env.CODEX_HOME ?? import_node_path23.default.join(process.env.HOME ?? (0, import_node_os12.homedir)(), ".codex");
+        (0, import_node_fs15.rmSync)(import_node_path23.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
       } catch {
       }
       return;
@@ -56330,8 +56800,8 @@ async function main() {
         env: process.env,
         cwd: process.cwd(),
         writeFile: (p, c) => {
-          (0, import_node_fs13.mkdirSync)(import_node_path21.default.dirname(p), { recursive: true, mode: 448 });
-          (0, import_node_fs13.writeFileSync)(p, c, { mode: 384 });
+          (0, import_node_fs15.mkdirSync)(import_node_path23.default.dirname(p), { recursive: true, mode: 448 });
+          (0, import_node_fs15.writeFileSync)(p, c, { mode: 384 });
         },
         runPm2: pm2Runner,
         which: whichBin,
@@ -56348,35 +56818,35 @@ async function main() {
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs13.rmSync)(p, { force: true });
+            (0, import_node_fs15.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: purge,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path21.default.join(process.env.HOME ?? (0, import_node_os11.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path23.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_fs13.rmSync)(p, { force: true });
+            (0, import_node_fs15.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: true,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path21.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path23.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
         log
       });
       let codexOk = true;
@@ -56396,7 +56866,7 @@ async function main() {
         log(`codex config NOT modified: ${error51 instanceof Error ? error51.message : String(error51)}`);
       }
       try {
-        (0, import_node_fs13.rmSync)(import_node_path21.default.join(home, ".mrrlin"), { recursive: true, force: true });
+        (0, import_node_fs15.rmSync)(import_node_path23.default.join(home, ".mrrlin"), { recursive: true, force: true });
       } catch {
       }
       log("removed ~/.mrrlin");
@@ -56437,7 +56907,7 @@ ${HELP_TEXT}`);
   }
 }
 function resolveSelfBinPath() {
-  return import_node_path20.default.resolve(process.argv[1] ?? process.execPath);
+  return import_node_path22.default.resolve(process.argv[1] ?? process.execPath);
 }
 main().catch((error51) => {
   process.stderr.write(`mrrlin-mcp fatal error: ${error51 instanceof Error ? error51.message : String(error51)}