@mrrlin-dev/mcp 0.3.2 → 0.3.5

package/dist/bin.cjs

@@ -4273,7 +4273,7 @@ var require_websocket = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash2 } = require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash3 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -4941,7 +4941,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -5310,7 +5310,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter3 = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash2 } = require("crypto");
+    var { createHash: createHash3 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -5617,7 +5617,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -7703,54 +7703,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs6) {
+    function patch(fs7) {
       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(path15, mode, cb) {
+        patchLchmod(fs7);
+      }
+      if (!fs7.lutimes) {
+        patchLutimes(fs7);
+      }
+      fs7.chown = chownFix(fs7.chown);
+      fs7.fchown = chownFix(fs7.fchown);
+      fs7.lchown = chownFix(fs7.lchown);
+      fs7.chmod = chmodFix(fs7.chmod);
+      fs7.fchmod = chmodFix(fs7.fchmod);
+      fs7.lchmod = chmodFix(fs7.lchmod);
+      fs7.chownSync = chownFixSync(fs7.chownSync);
+      fs7.fchownSync = chownFixSync(fs7.fchownSync);
+      fs7.lchownSync = chownFixSync(fs7.lchownSync);
+      fs7.chmodSync = chmodFixSync(fs7.chmodSync);
+      fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
+      fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
+      fs7.stat = statFix(fs7.stat);
+      fs7.fstat = statFix(fs7.fstat);
+      fs7.lstat = statFix(fs7.lstat);
+      fs7.statSync = statFixSync(fs7.statSync);
+      fs7.fstatSync = statFixSync(fs7.fstatSync);
+      fs7.lstatSync = statFixSync(fs7.lstatSync);
+      if (fs7.chmod && !fs7.lchmod) {
+        fs7.lchmod = function(path16, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchmodSync = function() {
+        fs7.lchmodSync = function() {
         };
       }
-      if (fs6.chown && !fs6.lchown) {
-        fs6.lchown = function(path15, uid, gid, cb) {
+      if (fs7.chown && !fs7.lchown) {
+        fs7.lchown = function(path16, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs6.lchownSync = function() {
+        fs7.lchownSync = function() {
         };
       }
       if (platform2 === "win32") {
-        fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) {
+        fs7.rename = typeof fs7.rename !== "function" ? fs7.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) {
+                  fs7.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);
+        }(fs7.rename);
       }
-      fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) {
+      fs7.read = typeof fs7.read !== "function" ? fs7.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(fs7, 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(fs7, 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) {
+      }(fs7.read);
+      fs7.readSync = typeof fs7.readSync !== "function" ? fs7.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(fs7, 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(path15, mode, callback) {
-          fs7.open(
-            path15,
+      }(fs7.readSync);
+      function patchLchmod(fs8) {
+        fs8.lchmod = function(path16, mode, callback) {
+          fs8.open(
+            path16,
             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) {
+              fs8.fchmod(fd, mode, function(err2) {
+                fs8.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs7.lchmodSync = function(path15, mode) {
-          var fd = fs7.openSync(path15, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs8.lchmodSync = function(path16, mode) {
+          var fd = fs8.openSync(path16, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs7.fchmodSync(fd, mode);
+            ret = fs8.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs7.closeSync(fd);
+              fs8.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs7) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) {
-          fs7.lutimes = function(path15, at, mt, cb) {
-            fs7.open(path15, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs8) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
+          fs8.lutimes = function(path16, at, mt, cb) {
+            fs8.open(path16, 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) {
+              fs8.futimes(fd, at, mt, function(er2) {
+                fs8.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs7.lutimesSync = function(path15, at, mt) {
-            var fd = fs7.openSync(path15, constants.O_SYMLINK);
+          fs8.lutimesSync = function(path16, at, mt) {
+            var fd = fs8.openSync(path16, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs7.futimesSync(fd, at, mt);
+              ret = fs8.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs7.closeSync(fd);
+                  fs8.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs7.closeSync(fd);
+                fs8.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs7.futimes) {
-          fs7.lutimes = function(_a3, _b, _c, cb) {
+        } else if (fs8.futimes) {
+          fs8.lutimes = function(_a3, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs7.lutimesSync = function() {
+          fs8.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(fs7, 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(fs7, 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(fs7, 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(fs7, 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(fs7, target, options, callback) : orig.call(fs7, 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(fs7, target, options) : orig.call(fs7, 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(fs7) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path15, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path15, options);
+      function ReadStream(path16, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path16, options);
         Stream.call(this);
         var self = this;
-        this.path = path15;
+        this.path = path16;
         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) {
+        fs7.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(path15, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path15, options);
+      function WriteStream(path16, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path16, options);
         Stream.call(this);
-        this.path = path15;
+        this.path = path16;
         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 = fs7.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 fs7 = 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 (!fs7[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs6, queue);
-      fs6.close = function(fs$close) {
+      publishQueue(fs7, queue);
+      fs7.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs6, fd, function(err) {
+          return fs$close.call(fs7, 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) {
+      }(fs7.close);
+      fs7.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs6, arguments);
+          fs$closeSync.apply(fs7, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs6.closeSync);
+      }(fs7.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(fs7[gracefulQueue]);
+          require("assert").equal(fs7[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(path15, options, cb) {
+      publishQueue(global, fs7[gracefulQueue]);
+    }
+    module2.exports = patch(clone2(fs7));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
+      module2.exports = patch(fs7);
+      fs7.__patched = true;
+    }
+    function patch(fs8) {
+      polyfills(fs8);
+      fs8.gracefulify = patch;
+      fs8.createReadStream = createReadStream;
+      fs8.createWriteStream = createWriteStream;
+      var fs$readFile = fs8.readFile;
+      fs8.readFile = readFile2;
+      function readFile2(path16, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path15, options, cb);
-        function go$readFile(path16, options2, cb2, startTime) {
-          return fs$readFile(path16, options2, function(err) {
+        return go$readFile(path16, options, cb);
+        function go$readFile(path17, options2, cb2, startTime) {
+          return fs$readFile(path17, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path16, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path17, 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(path15, data, options, cb) {
+      var fs$writeFile = fs8.writeFile;
+      fs8.writeFile = writeFile;
+      function writeFile(path16, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path15, data, options, cb);
-        function go$writeFile(path16, data2, options2, cb2, startTime) {
-          return fs$writeFile(path16, data2, options2, function(err) {
+        return go$writeFile(path16, data, options, cb);
+        function go$writeFile(path17, data2, options2, cb2, startTime) {
+          return fs$writeFile(path17, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path17, 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 = fs8.appendFile;
       if (fs$appendFile)
-        fs7.appendFile = appendFile;
-      function appendFile(path15, data, options, cb) {
+        fs8.appendFile = appendFile;
+      function appendFile(path16, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path15, data, options, cb);
-        function go$appendFile(path16, data2, options2, cb2, startTime) {
-          return fs$appendFile(path16, data2, options2, function(err) {
+        return go$appendFile(path16, data, options, cb);
+        function go$appendFile(path17, data2, options2, cb2, startTime) {
+          return fs$appendFile(path17, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path16, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path17, 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 = fs8.copyFile;
       if (fs$copyFile)
-        fs7.copyFile = copyFile;
+        fs8.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 = readdir;
+      var fs$readdir = fs8.readdir;
+      fs8.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path15, options, cb) {
+      function readdir2(path16, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path16, options2, cb2, startTime) {
-          return fs$readdir(path16, fs$readdirCallback(
-            path16,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) {
+          return fs$readdir(path17, fs$readdirCallback(
+            path17,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path16, options2, cb2, startTime) {
-          return fs$readdir(path16, options2, fs$readdirCallback(
-            path16,
+        } : function go$readdir2(path17, options2, cb2, startTime) {
+          return fs$readdir(path17, options2, fs$readdirCallback(
+            path17,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path15, options, cb);
-        function fs$readdirCallback(path16, options2, cb2, startTime) {
+        return go$readdir(path16, options, cb);
+        function fs$readdirCallback(path17, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path16, options2, cb2],
+                [path17, 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(fs8);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs7.ReadStream;
+      var fs$ReadStream = fs8.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs7.WriteStream;
+      var fs$WriteStream = fs8.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs7, "ReadStream", {
+      Object.defineProperty(fs8, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -8306,7 +8306,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs7, "WriteStream", {
+      Object.defineProperty(fs8, "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(fs8, "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(fs8, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -8338,7 +8338,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path15, options) {
+      function ReadStream(path16, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -8358,7 +8358,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path15, options) {
+      function WriteStream(path16, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -8376,22 +8376,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path15, options) {
-        return new fs7.ReadStream(path15, options);
+      function createReadStream(path16, options) {
+        return new fs8.ReadStream(path16, options);
       }
-      function createWriteStream(path15, options) {
-        return new fs7.WriteStream(path15, options);
+      function createWriteStream(path16, options) {
+        return new fs8.WriteStream(path16, options);
       }
-      var fs$open = fs7.open;
-      fs7.open = open;
-      function open(path15, flags, mode, cb) {
+      var fs$open = fs8.open;
+      fs8.open = open;
+      function open(path16, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path15, flags, mode, cb);
-        function go$open(path16, flags2, mode2, cb2, startTime) {
-          return fs$open(path16, flags2, mode2, function(err, fd) {
+        return go$open(path16, flags, mode, cb);
+        function go$open(path17, flags2, mode2, cb2, startTime) {
+          return fs$open(path17, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path16, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path17, 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 fs8;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs6[gracefulQueue].push(elem);
+      fs7[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 < fs7[gracefulQueue].length; ++i) {
+        if (fs7[gracefulQueue][i].length > 2) {
+          fs7[gracefulQueue][i][3] = now;
+          fs7[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 (fs7[gracefulQueue].length === 0)
         return;
-      var elem = fs6[gracefulQueue].shift();
+      var elem = fs7[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);
+          fs7[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, fs7, callback) {
+      const cachedPrecision = fs7[cacheSymbol];
       if (cachedPrecision) {
-        return fs6.stat(file2, (err, stat2) => {
+        return fs7.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) => {
+      fs7.utimes(file2, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs6.stat(file2, (err2, stat2) => {
+        fs7.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(fs7, 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 path15 = require("path");
-    var fs6 = require_graceful_fs();
+    var path16 = require("path");
+    var fs7 = 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, path15.resolve(file2));
+        return callback(null, path16.resolve(file2));
       }
       options.fs.realpath(file2, callback);
     }
@@ -9052,7 +9052,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs6,
+        fs: fs7,
         onCompromised: (err) => {
           throw err;
         },
@@ -9096,7 +9096,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file2, options, callback) {
       options = {
-        fs: fs6,
+        fs: fs7,
         realpath: true,
         ...options
       };
@@ -9118,7 +9118,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs6,
+        fs: fs7,
         ...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 fs7 = require_graceful_fs();
+    function createSyncFs(fs8) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs7 };
+      const newFs = { ...fs8 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs7[`${method}Sync`](...args);
+            ret = fs8[`${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 || fs7);
       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 path15 = dijkstra.find_path(graph.map, "start", "end");
+      const path16 = dijkstra.find_path(graph.map, "start", "end");
       const optimizedSegs = [];
-      for (let i = 1; i < path15.length - 1; i++) {
-        optimizedSegs.push(graph.table[path15[i]].node);
+      for (let i = 1; i < path16.length - 1; i++) {
+        optimizedSegs.push(graph.table[path16[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 fs7 = 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(path15, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path16, 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(path15);
+      const stream = fs7.createWriteStream(path16);
       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(path15, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path16, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs6 = require("fs");
+      const fs7 = require("fs");
       const utf8 = exports2.render(qrData, options);
-      fs6.writeFile(path15, utf8, cb);
+      fs7.writeFile(path16, utf8, cb);
     };
   }
 });
@@ -13476,7 +13476,7 @@ var require_svg_tag = __commonJS({
       return str;
     }
     function qrToPath(data, size, margin) {
-      let path15 = "";
+      let path16 = "";
       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])) {
-            path15 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+            path16 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
             moveBy = 0;
             newRow = false;
           }
           if (!(col + 1 < size && data[i + 1])) {
-            path15 += svgCmd("h", lineLength);
+            path16 += svgCmd("h", lineLength);
             lineLength = 0;
           }
         } else {
           moveBy++;
         }
       }
-      return path15;
+      return path16;
     }
     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 path15 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+      const path16 = "<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 + path15 + "</svg>\n";
+      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path16 + "</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(path15, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path16, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs6 = require("fs");
+      const fs7 = 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(path15, xmlStr, cb);
+      fs7.writeFile(path16, xmlStr, cb);
     };
   }
 });
@@ -13690,8 +13690,8 @@ var require_server = __commonJS({
         cb
       };
     }
-    function getTypeFromFilename(path15) {
-      return path15.slice((path15.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
+    function getTypeFromFilename(path16) {
+      return path16.slice((path16.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(path15, text, opts, cb) {
-      if (typeof path15 !== "string" || !(typeof text === "string" || typeof text === "object")) {
+    exports2.toFile = function toFile(path16, text, opts, cb) {
+      if (typeof path16 !== "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(path15);
+      const type = params.opts.type || getTypeFromFilename(path16);
       const renderer = getRendererFromType(type);
-      const renderToFile = renderer.renderToFile.bind(null, path15);
+      const renderToFile = renderer.renderToFile.bind(null, path16);
       return render(renderToFile, text, params);
     };
     exports2.toFileStream = function toFileStream(stream, text, opts) {
@@ -16983,8 +16983,8 @@ var require_utils3 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path15) {
-      let input = path15;
+    function removeDotSegments(path16) {
+      let input = path16;
       const output3 = [];
       let nextSlash = -1;
       let len = 0;
@@ -17236,8 +17236,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path15, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
+        const [path16, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path16 && path16 !== "/" ? path16 : 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, fs7, 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, fs7[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -20644,59 +20644,142 @@ var require_dist = __commonJS({
 });
 
 // src/bin.ts
-var import_node_path20 = __toESM(require("node:path"), 1);
-var import_node_child_process8 = require("node:child_process");
-var import_node_fs16 = require("node:fs");
-var import_node_os12 = require("node:os");
 var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_child_process9 = require("node:child_process");
+var import_node_fs16 = require("node:fs");
+var import_node_os13 = require("node:os");
+var import_node_path22 = __toESM(require("node:path"), 1);
 
 // src/install-codex.ts
 var import_promises = __toESM(require("node:fs/promises"), 1);
+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/browser-runtime.ts
 var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
-var toml = __toESM(require_toml(), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var import_node_child_process = require("node:child_process");
+var import_node_module = require("node:module");
+var import_node_url = require("node:url");
+var import_meta = {};
+function moduleRequire() {
+  const base = typeof __dirname !== "undefined" ? import_node_path.default.join(__dirname, "browser-runtime.js") : (0, import_node_url.fileURLToPath)(import_meta.url);
+  return (0, import_node_module.createRequire)(base);
+}
+function browserPaths(homeDir = import_node_os.default.homedir()) {
+  const root = import_node_path.default.join(homeDir, ".mrrlin", "browser");
+  return { root, browsersPath: import_node_path.default.join(root, "browsers"), profilePath: import_node_path.default.join(root, "profile") };
+}
+function resolvePackageBin(pkg) {
+  const require2 = moduleRequire();
+  const pkgJsonPath = require2.resolve(`${pkg}/package.json`);
+  const pkgJson = require2(`${pkg}/package.json`);
+  const bin = pkgJson.bin;
+  const rel = typeof bin === "string" ? bin : bin ? Object.values(bin)[0] : void 0;
+  if (!rel) throw new Error(`${pkg} has no bin entry to resolve a CLI from`);
+  return import_node_path.default.join(import_node_path.default.dirname(pkgJsonPath), rel);
+}
+function browserServeArgs(homeDir = import_node_os.default.homedir()) {
+  const { browsersPath, profilePath } = browserPaths(homeDir);
+  const cli = resolvePackageBin("@playwright/mcp");
+  return {
+    command: process.execPath,
+    // node
+    args: [cli, "--browser", "chromium", "--user-data-dir", profilePath],
+    env: { PLAYWRIGHT_BROWSERS_PATH: browsersPath }
+  };
+}
+async function installBrowser(opts = {}) {
+  const homeDir = opts.homeDir ?? import_node_os.default.homedir();
+  const { browsersPath } = browserPaths(homeDir);
+  const alreadyInstalled = opts.alreadyInstalled ?? (async (candidateBrowsersPath) => {
+    try {
+      const entries = await fs.readdir(candidateBrowsersPath);
+      return entries.some((entry) => entry.startsWith("chromium"));
+    } catch (error51) {
+      if (error51.code === "ENOENT") {
+        return false;
+      }
+      throw error51;
+    }
+  });
+  if (await alreadyInstalled(browsersPath)) {
+    return { action: "noop", browsersPath };
+  }
+  const run2 = opts.run ?? (async (cmd, args, env2) => {
+    const r = (0, import_node_child_process.spawnSync)(cmd, args, { encoding: "utf8", env: env2, stdio: ["ignore", "inherit", "pipe"] });
+    return { code: r.status ?? 1, stderr: r.stderr ?? "" };
+  });
+  const playwrightCli = resolvePackageBin("playwright-core");
+  const env = { ...process.env, PLAYWRIGHT_BROWSERS_PATH: browsersPath };
+  const result = await run2(process.execPath, [playwrightCli, "install", "chromium"], env);
+  if (result.code !== 0) {
+    throw new Error(
+      `install-browser failed (exit ${result.code}). Fix the issue (often network/proxy), then re-run \`mrrlin-mcp install-browser\`: ${result.stderr.trim()}`
+    );
+  }
+  return { action: "installed", browsersPath };
+}
+
+// src/install-codex.ts
 function resolveCodexHome(options) {
   if (options.codexHome) return options.codexHome;
   if (process.env.CODEX_HOME) return process.env.CODEX_HOME;
-  return import_node_path.default.join(options.homeDir ?? import_node_os.default.homedir(), ".codex");
+  return import_node_path2.default.join(options.homeDir ?? import_node_os2.default.homedir(), ".codex");
 }
-function expectedTable(binPath, distribution) {
-  if (distribution === "npm") {
-    return {
-      args: ["serve"],
-      command: "mrrlin-mcp",
-      startup_timeout_sec: 30
-    };
-  }
-  return {
-    args: [binPath, "serve"],
-    command: "node",
-    startup_timeout_sec: 30
-  };
+function mrrlinTable(binPath, distribution) {
+  if (distribution === "npm") return { command: "mrrlin-mcp", args: ["serve"], startup_timeout_sec: 30 };
+  return { command: "node", args: [binPath, "serve"], startup_timeout_sec: 30 };
+}
+function browserTable(binPath, distribution, homeDir) {
+  const base = distribution === "npm" ? { command: "mrrlin-mcp", args: ["browser-serve"] } : { command: "node", args: [binPath, "browser-serve"] };
+  return { ...base, startup_timeout_sec: 30, env: { PLAYWRIGHT_BROWSERS_PATH: browserPaths(homeDir).browsersPath } };
+}
+function blockRegex(id) {
+  const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|\\n)\\[mcp_servers\\.${escaped}\\][\\s\\S]*?(?=\\n\\[|$)`);
+}
+function managedBlocks(options, distribution) {
+  const homeDir = options.homeDir ?? import_node_os2.default.homedir();
+  return [
+    { id: "mrrlin", expected: mrrlinTable(options.binPath, distribution), blockRe: blockRegex("mrrlin") },
+    {
+      id: "mrrlin-browser",
+      expected: browserTable(options.binPath, distribution, homeDir),
+      blockRe: blockRegex("mrrlin-browser")
+    }
+  ];
 }
 async function detectInstallDistribution(options) {
   if (options.distribution && options.distribution !== "auto") return options.distribution;
-  let current = import_node_path.default.dirname(options.binPath);
+  let current = import_node_path2.default.dirname(options.binPath);
   while (true) {
-    if (await pathExists(import_node_path.default.join(current, "pnpm-workspace.yaml"))) {
+    if (await pathExists(import_node_path2.default.join(current, "pnpm-workspace.yaml"))) {
       return "local";
     }
-    const parent = import_node_path.default.dirname(current);
+    const parent = import_node_path2.default.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   return "npm";
 }
-function renderBlock(binPath, distribution) {
-  const expected = expectedTable(binPath, distribution);
-  return [
+function renderBlock(block) {
+  const { id, expected } = block;
+  const lines2 = [
     "",
-    "[mcp_servers.mrrlin]",
-    `command = "${expected.command}"`,
+    `[mcp_servers.${id}]`,
+    `command = ${JSON.stringify(expected.command)}`,
     `args = [${expected.args.map((value) => JSON.stringify(value)).join(", ")}]`,
-    `startup_timeout_sec = ${expected.startup_timeout_sec}`,
-    ""
-  ].join("\n");
+    `startup_timeout_sec = ${expected.startup_timeout_sec}`
+  ];
+  if (expected.env && Object.keys(expected.env).length > 0) {
+    const inline = Object.entries(expected.env).map(([key, value]) => `${key} = ${JSON.stringify(value)}`).join(", ");
+    lines2.push(`env = { ${inline} }`);
+  }
+  lines2.push("");
+  return lines2.join("\n");
 }
 function tablesEqual(actual, expected) {
   if (typeof actual !== "object" || actual === null) return false;
@@ -20710,6 +20793,13 @@ function tablesEqual(actual, expected) {
   if (candidate.startup_timeout_sec !== void 0 && candidate.startup_timeout_sec !== expected.startup_timeout_sec) {
     return false;
   }
+  const expectedEnv = expected.env ?? {};
+  const actualEnv = candidate.env && typeof candidate.env === "object" ? candidate.env : {};
+  const expectedKeys = Object.keys(expectedEnv);
+  if (expectedKeys.length !== Object.keys(actualEnv).length) return false;
+  for (const key of expectedKeys) {
+    if (actualEnv[key] !== expectedEnv[key]) return false;
+  }
   return true;
 }
 async function pathExists(target) {
@@ -20729,19 +20819,21 @@ async function resolveRealConfigPath(configPath) {
 }
 async function installCodex(options) {
   const codexHome = resolveCodexHome(options);
-  const configPath = import_node_path.default.join(codexHome, "config.toml");
+  const configPath = import_node_path2.default.join(codexHome, "config.toml");
   const distribution = await detectInstallDistribution(options);
   await import_promises.default.mkdir(codexHome, { recursive: true, mode: 448 });
   const writePrompts = async () => installPrompts(codexHome, options.prompts ?? [], options.forcePrompts === true);
+  const blocks = managedBlocks(options, distribution);
   if (!await pathExists(configPath)) {
-    await import_promises.default.writeFile(configPath, renderBlock(options.binPath, distribution).replace(/^\n/, ""), { mode: 384 });
+    const content2 = blocks.map(renderBlock).join("").replace(/^\n/, "");
+    await import_promises.default.writeFile(configPath, content2, { mode: 384 });
     return { action: "created", configPath, prompts: await writePrompts() };
   }
   const realPath = await resolveRealConfigPath(configPath);
-  const existing = await import_promises.default.readFile(realPath, "utf8");
+  let content = await import_promises.default.readFile(realPath, "utf8");
   let parsed = null;
   try {
-    parsed = toml.parse(existing);
+    parsed = toml.parse(content);
   } catch (error51) {
     const detail = error51 instanceof Error ? error51.message : String(error51);
     const err = {
@@ -20751,34 +20843,38 @@ async function installCodex(options) {
     };
     throw Object.assign(new Error(err.detail), err);
   }
-  const existingTable = parsed?.mcp_servers?.["mrrlin"];
-  if (existingTable !== void 0) {
-    if (tablesEqual(existingTable, expectedTable(options.binPath, distribution))) {
-      return { action: "noop", configPath: realPath, prompts: await writePrompts() };
-    }
-    if (!options.force) {
-      const err = {
-        code: "CODEX_CONFIG_CONFLICT",
-        configPath: realPath,
-        detail: "An [mcp_servers.mrrlin] block already exists with different settings. Re-run with --force to replace it, or remove it manually."
-      };
-      throw Object.assign(new Error(err.detail), err);
+  let action = "noop";
+  for (const block of blocks) {
+    const existingTable = parsed?.mcp_servers?.[block.id];
+    if (existingTable !== void 0) {
+      if (tablesEqual(existingTable, block.expected)) continue;
+      if (!options.force) {
+        const err = {
+          code: "CODEX_CONFIG_CONFLICT",
+          configPath: realPath,
+          detail: `An [mcp_servers.${block.id}] block already exists with different settings. Re-run with --force to replace it, or remove it manually.`
+        };
+        throw Object.assign(new Error(err.detail), err);
+      }
+      content = replaceBlock(content, block.blockRe, renderBlock(block));
+      action = "replaced";
+    } else {
+      content = appendBlock(content, renderBlock(block));
+      if (action !== "replaced") action = "appended";
     }
-    const replaced = replaceMrrlinBlock(existing, renderBlock(options.binPath, distribution));
-    await import_promises.default.writeFile(realPath, replaced, { mode: 384 });
-    return { action: "replaced", configPath: realPath, prompts: await writePrompts() };
   }
-  const appended = appendMrrlinBlock(existing, renderBlock(options.binPath, distribution));
-  await import_promises.default.writeFile(realPath, appended, { mode: 384 });
-  return { action: "appended", configPath: realPath, prompts: await writePrompts() };
+  if (action !== "noop") {
+    await import_promises.default.writeFile(realPath, content, { mode: 384 });
+  }
+  return { action, configPath: realPath, prompts: await writePrompts() };
 }
 async function installPrompts(codexHome, prompts, forcePrompts) {
   if (prompts.length === 0) return [];
-  const promptsDir2 = import_node_path.default.join(codexHome, "prompts");
+  const promptsDir2 = import_node_path2.default.join(codexHome, "prompts");
   await import_promises.default.mkdir(promptsDir2, { recursive: true, mode: 448 });
   const out = [];
   for (const prompt of prompts) {
-    const promptPath = import_node_path.default.join(promptsDir2, `${prompt.name}.md`);
+    const promptPath = import_node_path2.default.join(promptsDir2, `${prompt.name}.md`);
     let existing = null;
     try {
       existing = await import_promises.default.readFile(promptPath, "utf8");
@@ -20803,17 +20899,16 @@ async function installPrompts(codexHome, prompts, forcePrompts) {
   }
   return out;
 }
-function appendMrrlinBlock(existing, block) {
+function appendBlock(existing, block) {
   const trimmed = existing.replace(/\s+$/, "");
   return `${trimmed}
 ${block.startsWith("\n") ? block : `
 ${block}`}`.replace(/\n{3,}/g, "\n\n");
 }
-var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.mrrlin\][\s\S]*?(?=\n\[|$)/;
-function replaceMrrlinBlock(existing, block) {
+function replaceBlock(existing, blockRe, block) {
   const replacement = block.startsWith("\n") ? block : `
 ${block}`;
-  return existing.replace(MRRLIN_BLOCK_RE, (match) => {
+  return existing.replace(blockRe, (match) => {
     const prefix = match.startsWith("\n") ? "\n" : "";
     return `${prefix}${replacement.replace(/^\n+/, "")}`;
   });
@@ -20822,11 +20917,203 @@ ${block}`;
 // src/director-bridge.ts
 var import_node_fs12 = __toESM(require("node:fs"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
-var import_node_os8 = __toESM(require("node:os"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
-var import_node_child_process4 = require("node:child_process");
+var import_node_os9 = __toESM(require("node:os"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_child_process5 = require("node:child_process");
 var import_node_crypto5 = __toESM(require("node:crypto"), 1);
 
+// src/turn-replay-buffer.ts
+var DEFAULT_GRACE_MS = 3e4;
+var DEFAULT_MAX_EVENTS = 2e3;
+var DEFAULT_MAX_BYTES = 4e6;
+var DEFAULT_POST_COMPLETION_TTL_MS = 1e4;
+function createReplayBuffer(opts) {
+  return {
+    turnId: opts.turnId,
+    spanId: opts.spanId,
+    bindEpoch: opts.bindEpoch ?? 0,
+    events: [],
+    lastSeq: 0,
+    state: "live",
+    terminalDelivered: false,
+    replaying: false,
+    outboundQueue: [],
+    graceTimer: null,
+    finishedAt: null,
+    bytesUsed: 0,
+    graceMs: opts.graceMs ?? DEFAULT_GRACE_MS,
+    maxEvents: opts.maxEvents ?? DEFAULT_MAX_EVENTS,
+    maxBytes: opts.maxBytes ?? DEFAULT_MAX_BYTES,
+    postCompletionTtlMs: opts.postCompletionTtlMs ?? DEFAULT_POST_COMPLETION_TTL_MS,
+    triggerGrace: null
+  };
+}
+function recordOutgoing(buf, msg) {
+  const seq = ++buf.lastSeq;
+  const entry = { seq, msg };
+  buf.events.push(entry);
+  buf.bytesUsed += approxByteSize(msg);
+  while ((buf.events.length > buf.maxEvents || buf.bytesUsed > buf.maxBytes) && buf.events.length > 0) {
+    const dropped = buf.events.shift();
+    if (!dropped) break;
+    buf.bytesUsed -= approxByteSize(dropped.msg);
+  }
+  return entry;
+}
+function eventsAfter(buf, lastSeq) {
+  const first = buf.events[0];
+  if (first && lastSeq < first.seq - 1) return null;
+  return buf.events.filter((e) => e.seq > lastSeq);
+}
+function enterGrace(buf, onExpire) {
+  if (buf.graceTimer !== null) return;
+  buf.state = "grace";
+  buf.graceTimer = setTimeout(onExpire, buf.graceMs);
+}
+function cancelGrace(buf) {
+  if (buf.graceTimer !== null) {
+    clearTimeout(buf.graceTimer);
+    buf.graceTimer = null;
+  }
+  if (buf.state === "grace") buf.state = "live";
+}
+function recordInterrupted(buf) {
+  if (buf.terminalDelivered) return null;
+  const msg = {
+    type: "event",
+    event: { type: "result", subtype: "interrupted" }
+  };
+  const entry = recordOutgoing(buf, msg);
+  buf.terminalDelivered = true;
+  return entry;
+}
+function markCompleted(buf, now) {
+  buf.state = "completed";
+  buf.finishedAt = now;
+}
+function shouldGc(buf, now) {
+  if (buf.state !== "completed") return false;
+  if (buf.finishedAt === null) return false;
+  return now - buf.finishedAt > buf.postCompletionTtlMs;
+}
+function incrementBindEpoch(buf) {
+  return ++buf.bindEpoch;
+}
+function isTerminalEvent(msg) {
+  if (typeof msg !== "object" || msg === null) return false;
+  const outer = msg;
+  if (outer.type !== "event") return false;
+  if (typeof outer.event !== "object" || outer.event === null) return false;
+  const inner = outer.event;
+  return inner.type === "result";
+}
+function approxByteSize(msg) {
+  try {
+    return JSON.stringify(msg).length;
+  } catch {
+    return 0;
+  }
+}
+
+// src/replay-state-machine.ts
+function transition(state, event) {
+  if (event.kind === "resume" && !event.epochMatch) return { next: "invalid" };
+  switch (state) {
+    case "live":
+      switch (event.kind) {
+        case "socket_close":
+          return { next: "grace", sideEffects: ["start_grace_timer"] };
+        case "codex_terminal":
+          return { next: "completed", sideEffects: ["mark_finished"] };
+        case "stop":
+          return {
+            next: "interrupted",
+            sideEffects: ["record_interrupted", "fire_turn_interrupt"]
+          };
+        default:
+          return { next: "invalid" };
+      }
+    case "grace":
+      switch (event.kind) {
+        case "resume":
+          return {
+            next: "live",
+            sideEffects: [
+              "cancel_grace_timer",
+              "rebind_sink_increment_epoch",
+              "replay_drain"
+            ]
+          };
+        case "grace_expire":
+          return {
+            next: "interrupted",
+            sideEffects: ["record_interrupted", "fire_turn_interrupt"]
+          };
+        case "stop":
+          return {
+            next: "interrupted",
+            sideEffects: [
+              "cancel_grace_timer",
+              "record_interrupted",
+              "fire_turn_interrupt"
+            ]
+          };
+        case "codex_terminal":
+          return {
+            next: "completed",
+            sideEffects: ["cancel_grace_timer", "mark_finished"]
+          };
+        default:
+          return { next: "invalid" };
+      }
+    case "interrupted":
+      switch (event.kind) {
+        case "resume":
+          return {
+            next: "interrupted",
+            sideEffects: ["rebind_sink_increment_epoch", "replay_drain"]
+          };
+        case "codex_terminal":
+          return { next: "interrupted", sideEffects: ["drop_with_warn"] };
+        case "result_delivered_to_client":
+          return { next: "completed", sideEffects: ["mark_finished"] };
+        default:
+          return { next: "invalid" };
+      }
+    case "completed":
+      if (event.kind === "resume") {
+        return {
+          next: "completed",
+          sideEffects: ["rebind_sink_increment_epoch", "replay_drain"]
+        };
+      }
+      return { next: "completed", sideEffects: [] };
+  }
+}
+
+// src/bridge-tombstone.ts
+var DEFAULT_TOMBSTONE_TTL_MS = 36e5;
+function writeTombstone(tombstones, directorSessionId, buf, now) {
+  tombstones.set(directorSessionId, {
+    turnId: buf.turnId,
+    lastSeq: buf.lastSeq,
+    expiredAt: now
+  });
+}
+function lookupTombstone(tombstones, directorSessionId) {
+  return tombstones.get(directorSessionId) ?? null;
+}
+function sweepExpiredTombstones(tombstones, now, ttlMs = DEFAULT_TOMBSTONE_TTL_MS) {
+  let removed = 0;
+  for (const [sid, t] of tombstones) {
+    if (now - t.expiredAt > ttlMs) {
+      tombstones.delete(sid);
+      removed += 1;
+    }
+  }
+  return removed;
+}
+
 // ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
 var import_extension = __toESM(require_extension(), 1);
@@ -20948,7 +21235,7 @@ var CodexJsonRpcClient = class {
 };
 
 // ../../packages/codex-client/dist/server-manager.js
-var import_node_child_process = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var CodexServerManager = class {
   client = null;
   process = null;
@@ -20989,7 +21276,7 @@ var CodexServerManager = class {
   }
   async startServer(config2) {
     const executable = config2?.codexExecutable ?? "codex";
-    const spawnFn = config2?.spawn ?? import_node_child_process.spawn;
+    const spawnFn = config2?.spawn ?? import_node_child_process2.spawn;
     const child = spawnFn(executable, ["app-server"], {
       stdio: ["pipe", "pipe", "pipe"],
       cwd: config2?.cwd,
@@ -22134,10 +22421,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path16) {
+  if (!path16)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path16.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -22546,11 +22833,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path16, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path16);
     return iss;
   });
 }
@@ -22697,16 +22984,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path15 = []) => {
+  const processError = (error52, path16 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else {
-        const fullpath = [...path15, ...issue2.path];
+        const fullpath = [...path16, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -22733,17 +23020,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path15 = []) => {
+  const processError = (error52, path16 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else {
-        const fullpath = [...path15, ...issue2.path];
+        const fullpath = [...path16, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -22775,8 +23062,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path15) {
+  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path16) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -35468,13 +35755,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path15 = ref.slice(1).split("/").filter(Boolean);
-  if (path15.length === 0) {
+  const path16 = ref.slice(1).split("/").filter(Boolean);
+  if (path16.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path15[0] === defsKey) {
-    const key = path15[1];
+  if (path16[0] === defsKey) {
+    const key = path16[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -35888,6 +36175,7 @@ var openApiOperationIds = {
   archivePlan: "archivePlan",
   bindProjectGithubRepo: "bindProjectGithubRepo",
   createExecutionRun: "createExecutionRun",
+  createExecutionRunHandoff: "createExecutionRunHandoff",
   createAsyncJob: "createAsyncJob",
   getAsyncJob: "getAsyncJob",
   getActiveAsyncJob: "getActiveAsyncJob",
@@ -35987,7 +36275,7 @@ var operatorSessionSchema = external_exports.object({
   issuedAt: external_exports.number().int().positive(),
   kind: external_exports.enum(["web", "agent"]).default("web"),
   login: external_exports.string().min(1),
-  projectSlug: external_exports.string().min(1),
+  projectSlug: external_exports.string().min(1).optional(),
   provider: external_exports.literal("github"),
   repo: external_exports.string().min(1).nullable(),
   // ADR 0016: `scope` distinguishes project-pinned agent tokens (legacy, default) from
@@ -35996,7 +36284,7 @@ var operatorSessionSchema = external_exports.object({
   // cleanly into the project branch of the middleware (which mirrors today's behavior).
   scope: external_exports.enum(["project", "operator"]).default("project")
 });
-var AGENT_SESSION_TTL_MS = 1e3 * 60 * 60;
+var AGENT_SESSION_TTL_MS = 1e3 * 60 * 15;
 
 // ../../packages/schemas/dist/github-state.js
 var TTL_MS = 10 * 6e4;
@@ -36114,6 +36402,7 @@ var mrrlinTaskTypeSchema = external_exports.enum(["task", "bug"]);
 var mrrlinTaskImpactSchema = external_exports.enum(["low", "medium", "high"]);
 var mrrlinAutonomyLevelSchema = external_exports.enum(["auto", "minimal_human", "human_only"]);
 var mrrlinAutoDeploySchema = external_exports.enum(["off", "dev", "prod"]);
+var mrrlinSpecApprovedSchema = external_exports.enum(["pending", "approved", "skipped", "skipped_legacy"]);
 var mrrlinTaskSourceSchema = external_exports.enum(["fixture-import", "api"]);
 var mrrlinPlanStatusSchema = external_exports.enum(["active", "paused", "done", "archived"]);
 var mrrlinTaskEventTypeSchema = external_exports.enum(["autonomy_set", "director_thread_reset", "note"]);
@@ -36204,7 +36493,13 @@ var mrrlinTaskSchema = external_exports.object({
   latestJudgementAt: external_exports.string().datetime().nullable().default(null),
   latestJudgementKind: external_exports.enum(["autonomy", "handoff"]).nullable().default(null),
   notes: external_exports.string().nullable().default(null),
+  // Raw operator request captured at task creation (operator-authored ONLY, never Director-generated).
+  // The intent-aware spec gate judges the spec against this; null/absent ⇒ the gate fail-closes.
+  // Output-optional (not .default) so existing task fixtures need no churn; DB rows always resolve it
+  // to `string | null` via taskRowToTask.
+  operatorSeedRequest: external_exports.string().max(8e3).nullable().optional(),
   planId: mrrlinPlanIdSchema.nullable(),
+  specApproved: mrrlinSpecApprovedSchema.optional(),
   specWikiPageId: mrrlinWikiPageIdSchema.nullable(),
   status: mrrlinTaskStatusSchema,
   subcategory: taxonomySubcategorySchema,
@@ -36220,6 +36515,7 @@ var mrrlinPlanSchema = external_exports.object({
   id: mrrlinPlanIdSchema,
   name: external_exports.string().min(1),
   progress: external_exports.number().min(0).max(1),
+  specWikiPageId: external_exports.string().nullable().default(null),
   status: mrrlinPlanStatusSchema,
   taskCount: external_exports.number().int().nonnegative()
 });
@@ -36344,6 +36640,7 @@ var mrrlinTaskCreateSchema = external_exports.object({
   id: mrrlinTaskIdSchema,
   impact: mrrlinTaskImpactSchema.default("medium"),
   notes: external_exports.string().nullable().optional(),
+  operatorSeedRequest: external_exports.string().max(8e3).nullable().optional(),
   planId: mrrlinPlanIdSchema.nullable().optional(),
   specWikiPageId: mrrlinWikiPageIdSchema.nullable().optional(),
   tags: mrrlinTaskTagsSchema.optional(),
@@ -36367,6 +36664,7 @@ var mrrlinTaskUpdateSchema = external_exports.object({
   impact: mrrlinTaskImpactSchema.optional(),
   notes: external_exports.string().nullable().optional(),
   planId: mrrlinPlanIdSchema.nullable().optional(),
+  specApproved: mrrlinSpecApprovedSchema.optional(),
   specWikiPageId: mrrlinWikiPageIdSchema.nullable().optional(),
   status: mrrlinTaskStatusSchema.optional(),
   subcategory: taxonomySubcategorySchema.optional(),
@@ -36374,7 +36672,7 @@ var mrrlinTaskUpdateSchema = external_exports.object({
   type: mrrlinTaskTypeSchema.optional(),
   followUpAt: external_exports.string().datetime().nullable().optional(),
   verificationDueAt: external_exports.string().datetime().nullable().optional()
-}).refine((value) => value.assignee !== void 0 || value.autoDeploy !== void 0 || value.autonomyLevel !== void 0 || value.autonomyReason !== void 0 || value.category !== void 0 || value.directorThreadId !== void 0 || value.dueDate !== void 0 || value.followUpAt !== void 0 || value.impact !== void 0 || value.notes !== void 0 || value.planId !== void 0 || value.specWikiPageId !== void 0 || value.status !== void 0 || value.subcategory !== void 0 || value.tags !== void 0 || value.type !== void 0 || value.verificationDueAt !== void 0, { message: "TaskUpdate requires at least one field" }).superRefine((value, context) => {
+}).refine((value) => value.assignee !== void 0 || value.autoDeploy !== void 0 || value.autonomyLevel !== void 0 || value.autonomyReason !== void 0 || value.category !== void 0 || value.directorThreadId !== void 0 || value.dueDate !== void 0 || value.followUpAt !== void 0 || value.impact !== void 0 || value.notes !== void 0 || value.planId !== void 0 || value.specApproved !== void 0 || value.specWikiPageId !== void 0 || value.status !== void 0 || value.subcategory !== void 0 || value.tags !== void 0 || value.type !== void 0 || value.verificationDueAt !== void 0, { message: "TaskUpdate requires at least one field" }).superRefine((value, context) => {
   if (value.autonomyLevel !== void 0 && value.autonomyReason === void 0) {
     context.addIssue({
       code: external_exports.ZodIssueCode.custom,
@@ -36415,12 +36713,14 @@ var mrrlinPlanCreateSchema = external_exports.object({
   goal: external_exports.string().min(1),
   id: mrrlinPlanIdSchema,
   name: external_exports.string().min(1),
+  specWikiPageId: external_exports.string().nullable().optional(),
   status: mrrlinPlanStatusSchema.default("active")
 });
 var mrrlinPlanUpdateSchema = external_exports.object({
   dueDate: external_exports.string().date().nullable().optional(),
   goal: external_exports.string().min(1).optional(),
   name: external_exports.string().min(1).optional(),
+  specWikiPageId: external_exports.string().nullable().optional(),
   status: mrrlinPlanStatusSchema.optional()
 }).refine((value) => Object.keys(value).length > 0, { message: "PlanUpdate requires at least one field" });
 var mrrlinTaxonomyCreateSchema = mrrlinTaxonomyEntrySchema;
@@ -36643,6 +36943,10 @@ var markSpecReadyResponseSchema = external_exports.object({
 var wikiPageSpecReadyCasResponseSchema = external_exports.object({
   data: external_exports.object({ promoted: external_exports.literal(true) })
 });
+var mrrlinRunPrerequisiteSchema = external_exports.object({
+  mcp: external_exports.string().min(1),
+  reason: external_exports.string().min(1)
+});
 var mrrlinExecutionRunSchema = external_exports.object({
   actor: external_exports.string().min(1),
   baseSha: external_exports.string().min(1).nullable(),
@@ -36651,6 +36955,7 @@ var mrrlinExecutionRunSchema = external_exports.object({
   claimedAt: external_exports.string().datetime().nullable(),
   codeExecution: external_exports.boolean(),
   createdAt: external_exports.string().datetime(),
+  devEnvUrl: external_exports.string().min(1).nullable(),
   devRunUrl: external_exports.string().min(1).nullable(),
   devWorkflowId: external_exports.number().int().positive().nullable(),
   directorSessionId: external_exports.string().min(1).nullable(),
@@ -36659,6 +36964,8 @@ var mrrlinExecutionRunSchema = external_exports.object({
   id: mrrlinExecutionRunIdSchema,
   lastActor: external_exports.string().min(1).nullable(),
   leaseId: external_exports.string().min(1).nullable(),
+  prerequisites: external_exports.array(mrrlinRunPrerequisiteSchema),
+  prodEnvUrl: external_exports.string().min(1).nullable(),
   prodRunUrl: external_exports.string().min(1).nullable(),
   prodWorkflowId: external_exports.number().int().positive().nullable(),
   projectSlug: mrrlinProjectSlugSchema,
@@ -36677,6 +36984,7 @@ var mrrlinExecutionRunCreateSchema = external_exports.object({
   codeExecution: external_exports.boolean().optional().default(false),
   devWorkflowId: external_exports.number().int().positive().optional(),
   id: mrrlinExecutionRunIdSchema,
+  prerequisites: external_exports.array(mrrlinRunPrerequisiteSchema).default([]),
   prodWorkflowId: external_exports.number().int().positive().optional(),
   provider: external_exports.string().min(1),
   status: mrrlinExecutionRunStatusSchema.default("pending"),
@@ -36687,11 +36995,13 @@ var mrrlinExecutionRunUpdateSchema = external_exports.object({
   baseSha: external_exports.string().min(1).nullable().optional(),
   branch: external_exports.string().min(1).nullable().optional(),
   checkpointCursor: external_exports.string().min(1).nullable().optional(),
+  devEnvUrl: external_exports.string().min(1).nullable().optional(),
   devRunUrl: external_exports.string().min(1).nullable().optional(),
   devWorkflowId: external_exports.number().int().positive().nullable().optional(),
   finishedAt: external_exports.string().datetime().nullable().optional(),
   headSha: external_exports.string().min(1).nullable().optional(),
   leaseId: external_exports.string().min(1).nullable().optional(),
+  prodEnvUrl: external_exports.string().min(1).nullable().optional(),
   prodRunUrl: external_exports.string().min(1).nullable().optional(),
   prodWorkflowId: external_exports.number().int().positive().nullable().optional(),
   pullRequestUrl: external_exports.string().min(1).nullable().optional(),
@@ -36739,6 +37049,7 @@ var mrrlinResolveHandoffSchema = external_exports.object({
   }
 });
 var resolveHandoffResponseSchema = external_exports.object({ data: mrrlinExecutionRunSchema });
+var createExecutionRunHandoffSchema = external_exports.object({ reason: external_exports.string().min(1) });
 var mrrlinExecutionRunTouchSchema = external_exports.object({
   leaseId: external_exports.string().min(1)
 });
@@ -36804,7 +37115,9 @@ var exchangeAgentTokenRequestSchema = external_exports.object({
 var exchangeAgentTokenResponseSchema = external_exports.object({
   token: external_exports.string().min(1),
   expiresAt: external_exports.string().datetime(),
-  projectSlug: external_exports.string().min(1),
+  // ADR 0016 §T7 amendment: operator-scope exchanges return no projectSlug (the token is
+  // operator-wide); project-scope exchanges still return the pinned slug.
+  projectSlug: external_exports.string().min(1).optional(),
   login: external_exports.string().min(1)
 });
 var MRRLIN_ARTIFACT_FILE_MAX_BYTES = 5 * 1024 * 1024;
@@ -36822,6 +37135,7 @@ var mrrlinArtifactFileMimeTypes = [
 ];
 var mrrlinArtifactFileClassSchema = external_exports.enum(["temp", "durable"]);
 var mrrlinArtifactFileStatusSchema = external_exports.enum(["pending", "uploaded", "expired"]);
+var mrrlinArtifactFileVisibilitySchema = external_exports.enum(["private", "public"]);
 var mrrlinArtifactFileSchema = external_exports.object({
   class: mrrlinArtifactFileClassSchema,
   contentType: external_exports.enum(mrrlinArtifactFileMimeTypes),
@@ -36836,7 +37150,9 @@ var mrrlinArtifactFileSchema = external_exports.object({
   // min(0): reads tolerate 0-byte rows; creation requires min(1) (see create schema).
   sizeBytes: external_exports.number().int().min(0).max(MRRLIN_ARTIFACT_FILE_MAX_BYTES),
   status: mrrlinArtifactFileStatusSchema,
-  taskId: mrrlinTaskIdSchema.nullable()
+  taskId: mrrlinTaskIdSchema.nullable(),
+  // Defaulted (fail-safe → private) so legacy rows/fixtures predating the column read as private.
+  visibility: mrrlinArtifactFileVisibilitySchema.default("private")
 });
 var mrrlinArtifactFileCreateSchema = external_exports.object({
   class: mrrlinArtifactFileClassSchema,
@@ -36844,7 +37160,9 @@ var mrrlinArtifactFileCreateSchema = external_exports.object({
   filename: external_exports.string().min(1).max(255),
   runId: mrrlinExecutionRunIdSchema.optional(),
   sizeBytes: external_exports.number().int().min(1).max(MRRLIN_ARTIFACT_FILE_MAX_BYTES),
-  taskId: mrrlinTaskIdSchema.optional()
+  taskId: mrrlinTaskIdSchema.optional(),
+  // Optional + fail-safe: callers must opt in to 'public'; everything else stays private.
+  visibility: mrrlinArtifactFileVisibilitySchema.optional().default("private")
 });
 var mrrlinArtifactFileUploadTargetSchema = external_exports.discriminatedUnion("kind", [
   external_exports.object({ kind: external_exports.literal("presigned-post"), url: external_exports.string().min(1), fields: external_exports.record(external_exports.string(), external_exports.string()) }),
@@ -36967,6 +37285,8 @@ var mrrlinInboxItemSchema = external_exports.object({
   directorSessionId: external_exports.string().min(1).nullable(),
   id: mrrlinInboxItemIdSchema,
   kind: mrrlinInboxItemKindSchema,
+  origin: external_exports.string().nullable().optional(),
+  planId: mrrlinPlanIdSchema.nullable().default(null),
   projectSlug: mrrlinProjectSlugSchema,
   readAt: external_exports.string().datetime().nullable(),
   status: mrrlinInboxItemStatusSchema,
@@ -36978,6 +37298,8 @@ var mrrlinInboxItemCreateSchema = external_exports.object({
   directorSessionId: external_exports.string().min(1).optional(),
   id: mrrlinInboxItemIdSchema,
   kind: mrrlinInboxItemKindSchema,
+  origin: external_exports.string().min(1).optional(),
+  planId: mrrlinPlanIdSchema.nullable().optional(),
   taskId: mrrlinTaskIdSchema.nullable().optional()
 });
 var mrrlinInboxItemDecideSchema = external_exports.object({
@@ -37108,18 +37430,18 @@ function createMrrlinClient(config2) {
   const customFetch = config2.fetch ?? globalThis.fetch;
   const baseUrl = config2.baseUrl.replace(/\/$/, "");
   const token = config2.token;
-  async function request(path15, init) {
+  async function request(path16, 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}${path15}`, { ...init, headers });
+    const response = await customFetch(`${baseUrl}${path16}`, { ...init, headers });
     if (!response.ok) {
       const body = await response.text();
       let code = `HTTP_${response.status}`;
       let violations = null;
-      let message = `Mrrlin API ${method} ${path15} failed: ${response.status}`;
+      let message = `Mrrlin API ${method} ${path16} failed: ${response.status}`;
       try {
         const parsed = JSON.parse(body);
         const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
@@ -37139,7 +37461,7 @@ function createMrrlinClient(config2) {
       throw new MrrlinApiError({
         code,
         method,
-        path: path15,
+        path: path16,
         responseBody: body,
         status: response.status,
         violations,
@@ -37386,7 +37708,7 @@ function createMrrlinClient(config2) {
       return taskEventListResponseSchema.parse(body).data;
     },
     async listTasks(projectSlug, filters = {}) {
-      const path15 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
+      const path16 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
         assignee: filters.assignee,
         autonomyLevel: filters.autonomyLevel,
         blockedBy: filters.blockedBy,
@@ -37398,7 +37720,7 @@ function createMrrlinClient(config2) {
         subcategory: filters.subcategory,
         type: filters.type
       });
-      const body = await request(path15);
+      const body = await request(path16);
       return taskListResponseSchema.parse(body).data;
     },
     async listTaxonomy(projectSlug) {
@@ -37406,22 +37728,22 @@ function createMrrlinClient(config2) {
       return taxonomyListResponseSchema.parse(body).data;
     },
     async listWikiPages(projectSlug, filters = {}) {
-      const path15 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
+      const path16 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
         folder: filters.folder,
         q: filters.q,
         taskId: filters.taskId
       });
-      const body = await request(path15);
+      const body = await request(path16);
       return wikiPageListResponseSchema.parse(body).data;
     },
     async searchWikiPages(projectSlug, query) {
-      const path15 = appendQuery(`${projectPath(projectSlug)}/wiki/search`, {
+      const path16 = 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(path15);
+      const body = await request(path16);
       return wikiPageSearchResponseSchema.parse(body).data;
     },
     async updatePlan(projectSlug, planId, patch) {
@@ -37687,6 +38009,14 @@ function createMrrlinClient(config2) {
       });
       return executionRunResponseSchema.parse(body).data;
     },
+    async createExecutionRunHandoff(projectSlug, runId, input) {
+      const body = await request(`${projectPath(projectSlug)}/execution-runs/${encodeURIComponent(runId)}/handoff`, {
+        body: JSON.stringify(input),
+        headers: { "content-type": "application/json" },
+        method: "POST"
+      });
+      return executionRunResponseSchema.parse(body).data;
+    },
     async listExecutionArtifacts(projectSlug, runId) {
       const body = await request(`${projectPath(projectSlug)}/execution-runs/${encodeURIComponent(runId)}/artifacts`);
       return executionArtifactListResponseSchema.parse(body).data;
@@ -37962,13 +38292,13 @@ function startSelfUpdate(deps) {
     });
     return `[bridge:update] An update for @mrrlin-dev/mcp is available: ${pkgVersion} \u2192 ${latestVersion}.
 
-This turn, at a natural pause, ASK the operator a yes/no question \u2014 e.g. "\u0411\u0430\u0447\u0443 \u0449\u043E bridge \u043D\u0430 ${pkgVersion}, \u043D\u0430 npm \u0443\u0436\u0435 ${latestVersion} \u2014 \u043E\u043D\u043E\u0432\u0438\u0442\u0438 \u0437\u0430\u0440\u0430\u0437? (\u0437\u0430\u043F\u0443\u0449\u0443 \`pnpm install -g @mrrlin-dev/mcp@latest\`)". Do NOT install without explicit confirmation.
+This turn, at a natural pause, ASK the operator a yes/no question \u2014 e.g. "\u0411\u0430\u0447\u0443 \u0449\u043E bridge \u043D\u0430 ${pkgVersion}, \u043D\u0430 npm \u0443\u0436\u0435 ${latestVersion} \u2014 \u043E\u043D\u043E\u0432\u0438\u0442\u0438 \u0437\u0430\u0440\u0430\u0437? (\u0437\u0430\u043F\u0443\u0449\u0443 \`npm install -g @mrrlin-dev/mcp@latest\`)". Do NOT install without explicit confirmation.
 
-If the operator confirms (yes / \u0442\u0430\u043A / \u0430\u0433\u0430 / etc.): immediately run \`pnpm install -g @mrrlin-dev/mcp@latest\` via your shell tool and report the outcome in chat. After a successful install, the bridge auto-restarts via its self-update loop within a couple of minutes \u2014 you do NOT need to call pm2.
+If the operator confirms (yes / \u0442\u0430\u043A / \u0430\u0433\u0430 / etc.): immediately run \`npm install -g @mrrlin-dev/mcp@latest\` via your shell tool and report the outcome in chat. After a successful install, the bridge auto-restarts via its self-update loop within a couple of minutes \u2014 you do NOT need to call pm2.
 
 If the operator declines / says "later": acknowledge briefly and do not bring it up again this turn. The bridge has a cooldown and will re-offer in 48h.
 
-If the install fails (permission denied, registry pinned, sudo required, network blocked): paste the error verbatim and show the operator the manual command \`pnpm install -g @mrrlin-dev/mcp@latest\` plus a one-line hint about likely cause.
+If the install fails (permission denied, registry pinned, sudo required, network blocked): paste the error verbatim and show the operator the manual command \`npm install -g @mrrlin-dev/mcp@latest\` plus a one-line hint about likely cause.
 
 Do NOT derail the current task \u2014 if the operator has an in-flight question, answer that first; the update offer is a brief aside, not the main subject.`;
   }
@@ -38130,7 +38460,7 @@ Do NOT derail the current task \u2014 if the operator has an in-flight question,
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.2";
+var PKG_VERSION = "0.3.5";
 
 // src/api-base-url.ts
 var DEFAULT_API_BASE_URL = "http://127.0.0.1:8787";
@@ -38297,6 +38627,11 @@ async function runDeployGateTick(deps, projectSlug, run2, task) {
     await deps.handoff(projectSlug, task, run2, "no_environment_url");
     return { kind: "handoff", reason: "no_environment_url" };
   }
+  await deps.client.updateExecutionRun(
+    projectSlug,
+    run2.id,
+    env === "dev" ? { devEnvUrl: deployment.environmentUrl } : { prodEnvUrl: deployment.environmentUrl }
+  );
   const section = await deps.loadVerificationSection(projectSlug, task);
   if (!section || section.trim().length === 0) {
     await deps.handoff(projectSlug, task, run2, "verification_steps_missing_at_verify");
@@ -38359,18 +38694,18 @@ async function awaitTurnWithDeadline(opts) {
 }
 
 // src/worktree.ts
-var import_node_child_process2 = require("node:child_process");
+var import_node_child_process3 = require("node:child_process");
 var import_node_fs3 = require("node:fs");
-var import_node_os2 = require("node:os");
-var import_node_path3 = require("node:path");
+var import_node_os3 = require("node:os");
+var import_node_path4 = require("node:path");
 
 // src/checkout-lock.ts
 var import_node_fs2 = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 async function withCheckoutLock(locksDir, slug, fn) {
   (0, import_node_fs2.mkdirSync)(locksDir, { recursive: true });
-  const target = (0, import_node_path2.join)(locksDir, `${slug}.lock`);
+  const target = (0, import_node_path3.join)(locksDir, `${slug}.lock`);
   if (!(0, import_node_fs2.existsSync)(target)) (0, import_node_fs2.writeFileSync)(target, "");
   const release = await import_proper_lockfile.default.lock(target, {
     retries: { retries: 600, factor: 1, minTimeout: 100, maxTimeout: 100 },
@@ -38387,16 +38722,16 @@ async function withCheckoutLock(locksDir, slug, fn) {
 function worktreeBranch(runId) {
   return `mrrlin/run-${runId}`;
 }
-var defaultGitExec = (args, env) => (0, import_node_child_process2.execFileSync)("git", args, { encoding: "utf8", timeout: 3e4, env });
+var defaultGitExec = (args, env) => (0, import_node_child_process3.execFileSync)("git", args, { encoding: "utf8", timeout: 3e4, env });
 function git(checkout, args) {
-  return (0, import_node_child_process2.execFileSync)("git", ["-C", checkout, ...args], {
+  return (0, import_node_child_process3.execFileSync)("git", ["-C", checkout, ...args], {
     encoding: "utf8",
     timeout: 3e4,
     env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
   });
 }
 async function createRunWorktree(opts) {
-  const worktreePath = (0, import_node_path3.join)(opts.worktreeRoot, opts.slug, opts.runId);
+  const worktreePath = (0, import_node_path4.join)(opts.worktreeRoot, opts.slug, opts.runId);
   await withCheckoutLock(opts.locksDir, opts.slug, async () => {
     (0, import_node_fs3.mkdirSync)(opts.worktreeRoot, { recursive: true });
     try {
@@ -38459,8 +38794,8 @@ 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_fs3.mkdtempSync)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "mrrlin-push-"));
-  const askpass = (0, import_node_path3.join)(dir, "askpass");
+  const dir = (0, import_node_fs3.mkdtempSync)((0, import_node_path4.join)((0, import_node_os3.tmpdir)(), "mrrlin-push-"));
+  const askpass = (0, import_node_path4.join)(dir, "askpass");
   try {
     (0, import_node_fs3.writeFileSync)(
       askpass,
@@ -38946,16 +39281,12 @@ async function resetWedgedThread(deps, projectSlug, taskId, interruptFailed) {
   });
 }
 async function failRun(deps, projectSlug, task, runId, leaseId, reason) {
+  if (!await runHasLease(deps, projectSlug, runId, leaseId)) return;
   try {
-    if (!await runHasLease(deps, projectSlug, runId, leaseId)) return;
-    await deps.client.updateExecutionRun(projectSlug, runId, {
-      status: "failed",
-      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      leaseId
-    });
+    await deps.client.createExecutionRunHandoff(projectSlug, runId, { reason });
   } catch {
+    await notifyOperatorHandoff(deps, projectSlug, task, runId, reason);
   }
-  await notifyOperatorHandoff(deps, projectSlug, task, runId, reason);
 }
 async function notifyOperatorHandoff(deps, projectSlug, task, runId, reason) {
   try {
@@ -39261,14 +39592,14 @@ function codexIdleMs() {
 
 // src/operator-token.ts
 var import_node_fs4 = require("node:fs");
-var import_node_os3 = __toESM(require("node:os"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 function operatorDir() {
-  const base = process.env.CODEX_HOME ? import_node_path4.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path4.default.join(import_node_os3.default.homedir(), ".mrrlin");
+  const base = process.env.CODEX_HOME ? import_node_path5.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path5.default.join(import_node_os4.default.homedir(), ".mrrlin");
   return base;
 }
 function operatorTokenPath() {
-  return import_node_path4.default.join(operatorDir(), "operator-token");
+  return import_node_path5.default.join(operatorDir(), "operator-token");
 }
 function readOperatorToken() {
   try {
@@ -39285,7 +39616,7 @@ function persistOperatorToken(token) {
 `, { encoding: "utf8", mode: 384 });
 }
 function agentCredentialPath() {
-  return import_node_path4.default.join(operatorDir(), "agent-credential");
+  return import_node_path5.default.join(operatorDir(), "agent-credential");
 }
 function persistAgentSecret(secret) {
   const dir = operatorDir();
@@ -39306,9 +39637,9 @@ function readAgentSecret() {
 
 // src/thread-index.ts
 var import_node_fs5 = require("node:fs");
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
 function threadIndexPath(stateDir) {
-  return import_node_path5.default.join(stateDir, "threads.json");
+  return import_node_path6.default.join(stateDir, "threads.json");
 }
 function loadThreadIndex(stateDir, ttlMs, now) {
   const result = /* @__PURE__ */ new Map();
@@ -39393,8 +39724,8 @@ function chatTurnMaxMs() {
 // src/worker-token.ts
 var import_node_crypto4 = require("node:crypto");
 var import_node_fs6 = require("node:fs");
-var import_node_os4 = __toESM(require("node:os"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
 var DEFAULT_WORKER_PORT = 8792;
 function workerPort() {
   const raw = process.env.MRRLIN_WORKER_PORT;
@@ -39403,11 +39734,11 @@ function workerPort() {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_WORKER_PORT;
 }
 function workerDir() {
-  const base = process.env.CODEX_HOME ? import_node_path6.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path6.default.join(import_node_os4.default.homedir(), ".mrrlin");
-  return import_node_path6.default.join(base, "worker");
+  const base = process.env.CODEX_HOME ? import_node_path7.default.join(process.env.CODEX_HOME, "mrrlin") : import_node_path7.default.join(import_node_os5.default.homedir(), ".mrrlin");
+  return import_node_path7.default.join(base, "worker");
 }
 function workerTokenPath() {
-  return import_node_path6.default.join(workerDir(), "token");
+  return import_node_path7.default.join(workerDir(), "token");
 }
 function readWorkerToken() {
   try {
@@ -39431,8 +39762,8 @@ function readOrCreateWorkerToken() {
 // src/remote-phone-relay.ts
 var import_node_events2 = require("node:events");
 var import_node_fs7 = require("node:fs");
-var import_node_os5 = require("node:os");
-var import_node_path7 = require("node:path");
+var import_node_os6 = require("node:os");
+var import_node_path8 = 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);
@@ -42207,7 +42538,10 @@ function parseFrame(bytes3) {
       };
     }
     case "inbox_read":
-      return { type: "inbox_read" };
+      return {
+        type: "inbox_read",
+        ...isString(f.projectSlug) ? { projectSlug: f.projectSlug } : {}
+      };
     case "inbox_decide":
       if (!isString(f.itemId) || !isString(f.idempotencyKey))
         throw new Error("frame inbox_decide: itemId + idempotencyKey required");
@@ -42220,7 +42554,8 @@ function parseFrame(bytes3) {
         itemId: f.itemId,
         decision: f.decision,
         idempotencyKey: f.idempotencyKey,
-        ...f.reason === void 0 ? {} : { reason: f.reason }
+        ...f.reason === void 0 ? {} : { reason: f.reason },
+        ...isString(f.projectSlug) ? { projectSlug: f.projectSlug } : {}
       };
     case "ack":
       if (!isString(f.refId))
@@ -42966,12 +43301,12 @@ var DirectorRelay = class {
           this.sendFrame(channelId, { type: "ack", refId: frame.idempotencyKey });
           return;
         }
-        await this.deps.onInboxDecide?.(frame.itemId, frame.decision, frame.idempotencyKey, frame.reason);
+        await this.deps.onInboxDecide?.(frame.itemId, frame.decision, frame.idempotencyKey, frame.reason, frame.projectSlug);
         this.seenDecideKeys.add(frame.idempotencyKey);
         this.sendFrame(channelId, { type: "ack", refId: frame.idempotencyKey });
         return;
       case "inbox_read": {
-        const items = await this.deps.onInboxRead?.();
+        const items = await this.deps.onInboxRead?.(frame.projectSlug);
         if (items !== void 0) this.sendDirectorEvent(channelId, { type: "inbox_items", items });
         this.sendFrame(channelId, { type: "ack", refId: "inbox_read" });
         return;
@@ -42999,9 +43334,9 @@ var DirectorRelay = class {
 
 // src/remote-phone-relay.ts
 function loadOrCreateAgentDeviceKey() {
-  const path15 = (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin", "agent-device-key");
+  const path16 = (0, import_node_path8.join)((0, import_node_os6.homedir)(), ".mrrlin", "agent-device-key");
   try {
-    const raw = JSON.parse((0, import_node_fs7.readFileSync)(path15, "utf8"));
+    const raw = JSON.parse((0, import_node_fs7.readFileSync)(path16, "utf8"));
     if (typeof raw.priv === "string" && typeof raw.pub === "string") {
       return { privateKey: fromBase64Url(raw.priv), publicKey: fromBase64Url(raw.pub) };
     }
@@ -43009,9 +43344,9 @@ function loadOrCreateAgentDeviceKey() {
   }
   const kp = generateIdentityKeyPair();
   try {
-    (0, import_node_fs7.mkdirSync)((0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)((0, import_node_os6.homedir)(), ".mrrlin"), { recursive: true });
     (0, import_node_fs7.writeFileSync)(
-      path15,
+      path16,
       JSON.stringify({ priv: toBase64Url(kp.privateKey), pub: toBase64Url(kp.publicKey) }),
       { mode: 384 }
     );
@@ -43019,7 +43354,7 @@ function loadOrCreateAgentDeviceKey() {
   }
   return kp;
 }
-var AGENT_PAIRING_PATH = (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin", "agent-pairing.json");
+var AGENT_PAIRING_PATH = (0, import_node_path8.join)((0, import_node_os6.homedir)(), ".mrrlin", "agent-pairing.json");
 function loadAgentPairing() {
   try {
     const raw = JSON.parse((0, import_node_fs7.readFileSync)(AGENT_PAIRING_PATH, "utf8"));
@@ -43037,7 +43372,7 @@ function loadAgentPairing() {
 }
 function saveAgentPairing(record2) {
   try {
-    (0, import_node_fs7.mkdirSync)((0, import_node_path7.join)((0, import_node_os5.homedir)(), ".mrrlin"), { recursive: true });
+    (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)((0, import_node_os6.homedir)(), ".mrrlin"), { recursive: true });
     (0, import_node_fs7.writeFileSync)(AGENT_PAIRING_PATH, JSON.stringify(record2), { mode: 384 });
   } catch {
   }
@@ -43116,30 +43451,38 @@ function decisionToVerdict(decision) {
       throw new Error(`remote-relay: unknown inbox decision "${decision}"`);
   }
 }
-function startRemotePhoneRelay(deps) {
-  const log = deps.log ?? ((m) => process.stderr.write(`[mrrlin-mcp remote-relay] ${m}
-`));
-  const provider = createAgentTokenProvider({ secret: deps.agentSecret, baseUrl: deps.apiBaseUrl });
-  const authed = async () => {
+function _makeRelayInboxCallbacks(provider, apiBaseUrl) {
+  const authed = async (frameSlug) => {
     const session = await provider.getSession();
+    const slug = frameSlug ?? session.projectSlug;
+    if (!slug) {
+      throw new Error("[mrrlin-mcp remote-relay] missing project context for inbox action");
+    }
     return {
-      client: createMrrlinClient({ baseUrl: deps.apiBaseUrl, token: session.token }),
-      slug: session.projectSlug,
+      client: createMrrlinClient({ baseUrl: apiBaseUrl, token: session.token }),
+      slug,
       login: session.login
     };
   };
-  const onInboxRead = async () => {
-    const { client, slug } = await authed();
+  const onInboxRead = async (projectSlug) => {
+    const { client, slug } = await authed(projectSlug);
     return boundInboxItems(await client.listInboxItems(slug, { status: "pending" }));
   };
-  const onInboxDecide = async (itemId, decision, _key, reason) => {
-    const { client, slug, login } = await authed();
+  const onInboxDecide = async (itemId, decision, _key, reason, projectSlug) => {
+    const { client, slug, login } = await authed(projectSlug);
     await client.decideInboxItem(slug, itemId, {
       verdict: decisionToVerdict(decision),
       decidedBy: login,
       ...reason ? { reason } : {}
     });
   };
+  return { onInboxRead, onInboxDecide };
+}
+function startRemotePhoneRelay(deps) {
+  const log = deps.log ?? ((m) => process.stderr.write(`[mrrlin-mcp remote-relay] ${m}
+`));
+  const provider = createAgentTokenProvider({ secret: deps.agentSecret, baseUrl: deps.apiBaseUrl });
+  const { onInboxRead, onInboxDecide } = _makeRelayInboxCallbacks(provider, deps.apiBaseUrl);
   const relayClient = new RelayClient({
     relayUrl: deps.relayUrl,
     now: () => Date.now(),
@@ -43208,11 +43551,11 @@ async function renderPairingQrSvg(payload) {
 
 // src/checkout-registry.ts
 var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 var CheckoutRegistry = class {
   file;
   constructor(stateDir) {
-    this.file = (0, import_node_path8.join)(stateDir, "checkouts.json");
+    this.file = (0, import_node_path9.join)(stateDir, "checkouts.json");
     (0, import_node_fs8.mkdirSync)(stateDir, { recursive: true });
   }
   read() {
@@ -43226,17 +43569,17 @@ var CheckoutRegistry = class {
   get(slug) {
     return this.read()[slug] ?? null;
   }
-  confirm(slug, path15, now) {
+  confirm(slug, path16, now) {
     const all = this.read();
-    all[slug] = { path: path15, confirmedAt: now };
+    all[slug] = { path: path16, confirmedAt: now };
     (0, import_node_fs8.writeFileSync)(this.file, JSON.stringify(all, null, 2));
   }
 };
 
 // src/executor-server.ts
 var import_node_fs9 = require("node:fs");
-var import_node_os6 = require("node:os");
-var import_node_path9 = require("node:path");
+var import_node_os7 = require("node:os");
+var import_node_path10 = require("node:path");
 var DENY_READ_GLOBS = [
   "**/.ssh/**",
   "**/.aws/**",
@@ -43267,17 +43610,17 @@ function buildExecutorConfig(opts) {
     trustWorktreeConfig: false
   };
 }
-function operatorSecretPaths(realHome = (0, import_node_os6.homedir)()) {
+function operatorSecretPaths(realHome = (0, import_node_os7.homedir)()) {
   return [
-    (0, import_node_path9.join)(realHome, ".ssh"),
-    (0, import_node_path9.join)(realHome, ".aws"),
-    (0, import_node_path9.join)(realHome, ".config", "gh"),
-    (0, import_node_path9.join)(realHome, ".npmrc"),
-    (0, import_node_path9.join)(realHome, ".netrc"),
-    (0, import_node_path9.join)(realHome, ".gnupg"),
-    (0, import_node_path9.join)(realHome, ".kube"),
-    (0, import_node_path9.join)(realHome, ".docker", "config.json"),
-    (0, import_node_path9.join)(realHome, ".config", "gcloud")
+    (0, import_node_path10.join)(realHome, ".ssh"),
+    (0, import_node_path10.join)(realHome, ".aws"),
+    (0, import_node_path10.join)(realHome, ".config", "gh"),
+    (0, import_node_path10.join)(realHome, ".npmrc"),
+    (0, import_node_path10.join)(realHome, ".netrc"),
+    (0, import_node_path10.join)(realHome, ".gnupg"),
+    (0, import_node_path10.join)(realHome, ".kube"),
+    (0, import_node_path10.join)(realHome, ".docker", "config.json"),
+    (0, import_node_path10.join)(realHome, ".config", "gcloud")
   ];
 }
 var SECRET_DIRECTORY_BASENAMES = /* @__PURE__ */ new Set([".ssh", ".aws", "gh", ".gnupg", ".kube", "gcloud"]);
@@ -43286,7 +43629,7 @@ function isSecretDirectoryPath(p) {
   return SECRET_DIRECTORY_BASENAMES.has(base);
 }
 function writeExecutorCodexHome(scratchDir, opts) {
-  const codexHome = (0, import_node_path9.join)(scratchDir, ".codex");
+  const codexHome = (0, import_node_path10.join)(scratchDir, ".codex");
   (0, import_node_fs9.mkdirSync)(codexHome, { recursive: true });
   const hasEgress = opts.egressDomains.length > 0;
   const networkSection = hasEgress ? [
@@ -43322,14 +43665,14 @@ function writeExecutorCodexHome(scratchDir, opts) {
     networkSection,
     ""
   ].join("\n");
-  (0, import_node_fs9.writeFileSync)((0, import_node_path9.join)(codexHome, "config.toml"), toml3, "utf8");
+  (0, import_node_fs9.writeFileSync)((0, import_node_path10.join)(codexHome, "config.toml"), toml3, "utf8");
   return codexHome;
 }
 async function startExecutorServer(opts) {
   const egressDomains = opts.egressDomains ?? DEFAULT_EGRESS_DOMAINS;
-  const realHome = (0, import_node_os6.homedir)();
+  const realHome = (0, import_node_os7.homedir)();
   const denySecretPaths = operatorSecretPaths(realHome);
-  const scratchDir = (0, import_node_fs9.mkdtempSync)((0, import_node_path9.join)((0, import_node_os6.tmpdir)(), "mrrlin-executor-"));
+  const scratchDir = (0, import_node_fs9.mkdtempSync)((0, import_node_path10.join)((0, import_node_os7.tmpdir)(), "mrrlin-executor-"));
   const scratchHome = scratchDir;
   let scratchCleaned = false;
   const cleanScratch = () => {
@@ -43528,7 +43871,7 @@ function extractVerificationSection(markdown) {
 
 // src/bridge-log.ts
 var import_node_fs10 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_path11 = require("node:path");
 
 // src/redact.ts
 var REDACTED = "[REDACTED]";
@@ -43613,14 +43956,14 @@ function resolvePromptsEnabled(env) {
 }
 function createBridgeLogger(stateDir, env = process.env) {
   if (!resolveBridgeLogEnabled(env)) return NOOP_LOGGER;
-  const logsDir = (0, import_node_path10.join)(stateDir, "logs");
+  const logsDir = (0, import_node_path11.join)(stateDir, "logs");
   try {
     (0, import_node_fs10.mkdirSync)(logsDir, { recursive: true });
   } catch {
     return NOOP_LOGGER;
   }
   const includePrompts = resolvePromptsEnabled(env);
-  const fileFor = () => (0, import_node_path10.join)(logsDir, `bridge-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
+  const fileFor = () => (0, import_node_path11.join)(logsDir, `bridge-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
   const write = (dir, rec) => {
     try {
       const line = JSON.stringify({
@@ -43646,9 +43989,9 @@ function createBridgeLogger(stateDir, env = process.env) {
 
 // src/issue-report.ts
 var import_node_fs11 = require("node:fs");
-var import_node_os7 = require("node:os");
-var import_node_path11 = __toESM(require("node:path"), 1);
-var import_node_child_process3 = require("node:child_process");
+var import_node_os8 = require("node:os");
+var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_child_process4 = require("node:child_process");
 var TELEGRAM_BOT_TOKEN = "8506614214:AAGyhO1phWb7ah2aN6_gAX2Co7OXNN3zb0A";
 var TELEGRAM_CHAT_ID = "-5373779177";
 function summarizeTranscript(entries = []) {
@@ -43683,10 +44026,10 @@ function describePayload(payload) {
 function resolveLogDir() {
   const codexHome = process.env.CODEX_HOME?.trim();
   if (codexHome) {
-    const candidate = import_node_path11.default.join(codexHome, "mrrlin", "director-bridge", "logs");
+    const candidate = import_node_path12.default.join(codexHome, "mrrlin", "director-bridge", "logs");
     if (existsDir(candidate)) return candidate;
   }
-  const fallback = import_node_path11.default.join((0, import_node_os7.homedir)(), ".mrrlin", "director-bridge", "logs");
+  const fallback = import_node_path12.default.join((0, import_node_os8.homedir)(), ".mrrlin", "director-bridge", "logs");
   return fallback;
 }
 function existsDir(candidate) {
@@ -43698,7 +44041,7 @@ function existsDir(candidate) {
 }
 function listRecentLogFiles(logDir) {
   if (!existsDir(logDir)) return [];
-  return (0, import_node_fs11.readdirSync)(logDir).filter((name) => /^bridge-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name)).sort((a, b) => b.localeCompare(a)).slice(0, 3).map((name) => import_node_path11.default.join(logDir, name));
+  return (0, import_node_fs11.readdirSync)(logDir).filter((name) => /^bridge-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name)).sort((a, b) => b.localeCompare(a)).slice(0, 3).map((name) => import_node_path12.default.join(logDir, name));
 }
 function parseLogFile(file2) {
   const lines2 = (0, import_node_fs11.readFileSync)(file2, "utf8").split(/\r?\n/).filter(Boolean);
@@ -43844,10 +44187,10 @@ function buildIssueDraft(request, logWindow) {
     `- Route: ${request.urlPath?.trim() || "(unknown)"}`,
     `- Director session: ${request.directorSessionId?.trim() || "(none)"}`,
     `- @mrrlin-dev/mcp: ${PKG_VERSION}`,
-    `- OS: ${(0, import_node_os7.platform)()}`,
+    `- OS: ${(0, import_node_os8.platform)()}`,
     `- Node: ${process.version}`
   ].join("\n");
-  const logLabel = logWindow.file ? import_node_path11.default.basename(logWindow.file) : "(none)";
+  const logLabel = logWindow.file ? import_node_path12.default.basename(logWindow.file) : "(none)";
   const body = [
     "## Summary",
     `${titlePrefix(request.source)} issue report generated from local Mrrlin evidence.`,
@@ -43883,7 +44226,7 @@ function buildTelegramAnnouncement(request, draft, issueUrl) {
 ${issueUrl}`;
 }
 function ensureGhReady() {
-  const auth = (0, import_node_child_process3.spawnSync)("gh", ["auth", "status", "-h", "github.com"], { encoding: "utf8" });
+  const auth = (0, import_node_child_process4.spawnSync)("gh", ["auth", "status", "-h", "github.com"], { encoding: "utf8" });
   if (auth.status !== 0) {
     const detail = (auth.stderr || auth.stdout || "gh auth status failed").trim();
     throw new Error(`GitHub CLI is not ready: ${detail}`);
@@ -43891,13 +44234,13 @@ function ensureGhReady() {
 }
 function createGithubIssue(draft) {
   ensureGhReady();
-  const tmpDir = (0, import_node_fs11.mkdtempSync)(import_node_path11.default.join((0, import_node_os7.tmpdir)(), "mrrlin-issue-"));
-  const bodyFile = import_node_path11.default.join(tmpDir, "issue-body.md");
+  const tmpDir = (0, import_node_fs11.mkdtempSync)(import_node_path12.default.join((0, import_node_os8.tmpdir)(), "mrrlin-issue-"));
+  const bodyFile = import_node_path12.default.join(tmpDir, "issue-body.md");
   try {
     (0, import_node_fs11.writeFileSync)(bodyFile, draft.body, "utf8");
     const args = ["issue", "create", "--repo", "fnnzzz/mrrlin", "--title", draft.title, "--body-file", bodyFile];
     for (const label of draft.labels) args.push("--label", label);
-    const result = (0, import_node_child_process3.spawnSync)("gh", args, { encoding: "utf8" });
+    const result = (0, import_node_child_process4.spawnSync)("gh", args, { encoding: "utf8" });
     if (result.status !== 0) {
       const detail = (result.stderr || result.stdout || "gh issue create failed").trim();
       throw new Error(detail);
@@ -43913,8 +44256,8 @@ function createGithubIssue(draft) {
   }
 }
 function sendTelegramAnnouncement(text) {
-  const tmpDir = (0, import_node_fs11.mkdtempSync)(import_node_path11.default.join((0, import_node_os7.tmpdir)(), "mrrlin-issue-telegram-"));
-  const bodyFile = import_node_path11.default.join(tmpDir, "telegram-body.json");
+  const tmpDir = (0, import_node_fs11.mkdtempSync)(import_node_path12.default.join((0, import_node_os8.tmpdir)(), "mrrlin-issue-telegram-"));
+  const bodyFile = import_node_path12.default.join(tmpDir, "telegram-body.json");
   try {
     (0, import_node_fs11.writeFileSync)(
       bodyFile,
@@ -43925,7 +44268,7 @@ function sendTelegramAnnouncement(text) {
       }),
       "utf8"
     );
-    const result = (0, import_node_child_process3.spawnSync)(
+    const result = (0, import_node_child_process4.spawnSync)(
       "curl",
       [
         "-sS",
@@ -44032,7 +44375,7 @@ function normalizeIssueScreenshots(value) {
   return screenshots;
 }
 function neutralCheckoutCwd(stateDir) {
-  const dir = import_node_path12.default.join(stateDir, "no-checkout");
+  const dir = import_node_path13.default.join(stateDir, "no-checkout");
   try {
     import_node_fs12.default.mkdirSync(dir, { recursive: true });
   } catch {
@@ -44043,12 +44386,19 @@ function buildThreadStartParams(msg, config2, desiredModel) {
   const baseInstructions = [
     "You are the Mrrlin Director assistant.",
     "You can call MCP tools to read and write project state.",
-    "Prefer calling tools over guessing. Be concise. Ask clarification questions only when needed.",
+    "Prefer calling tools over guessing. Be concise.",
+    "Autonomy level is NOT a reason to skip clarification. `auto` means only that no human gate is",
+    "required before the result LANDS (merge/deploy); it does not authorize building on unvalidated",
+    "assumptions. Judge clarification on requirement clarity, independently of autonomy_level.",
     "Never announce or pre-narrate that you are about to use tools, and never name the toolset in",
     `prose. Do NOT write openers like "I'll use the Mrrlin tools to\u2026", "\u0412\u0438\u043A\u043E\u0440\u0438\u0441\u0442\u0430\u044E Mrrlin tools\u2026",`,
     'or "let me call the \u2026 tool" in ANY language. The operator already sees tool calls in the',
     "transcript. Just call the tools and reply with the outcome \u2014 start your reply with the result.",
     "When creating or updating tasks, always provide `autonomyLevel` and `autonomyReason`.",
+    "When you create a task out of an operator request, set `operatorSeedRequest` to the operator's",
+    "VERBATIM words (their request as they wrote it \u2014 NOT your paraphrase or synthesized notes). It is",
+    "the spec gate's independent record of intent; omit it only when there is genuinely no operator",
+    "request behind the task (pure system bookkeeping) \u2014 note that omitting it makes the gate fail-closed.",
     "",
     "Spec authoring contract \u2014 when creating or updating a `Specs/{id}` wiki page:",
     "- In `## Specification`, write each requirement as `### Requirement: <name>` followed by one",
@@ -44058,6 +44408,7 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "- 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.",
+    '- 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.',
     "",
     'Research playbook \u2014 when the user asks about a topic, an area, or "what do we have on X":',
     "- Tasks are the source of truth. Start with `list_tasks` using `q=<keyword>`; the filter is a",
@@ -44119,12 +44470,20 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "  call `list_inbox_items` (kind=question), fold any relevant `acknowledged` TASKLESS answer",
     "  into the new task's Specs/{id} Clarifications, and `reject` (with a reason) any taskless",
     "  question the new task makes moot \u2014 so taskless answers never linger unconsumed.",
-    "- When resuming a task, call `list_inbox_items` (kind=question) and incorporate any",
-    "  `acknowledged` answer not yet reflected in the spec's Clarifications section.",
+    "- Gate-origin questions (origin='gate', filed by the spec consensus gate) are auto-folded",
+    "  into the spec and re-gated by the system when the operator answers them in the inbox.",
+    "  Do NOT fold or `decide_inbox_item` them yourself \u2014 your fold-contract above applies only",
+    "  to YOUR OWN discretionary questions.",
+    "- When resuming a task, call `list_inbox_items` (kind=question) and fold any `acknowledged`",
+    "  answer from YOUR questions (origin is null/absent) not yet reflected into the spec's",
+    "  Clarifications section \u2014 THEN re-run `run_spec_consensus` on the updated spec. Skip",
+    "  gate-origin items (origin='gate') as those are handled automatically.",
     "- If a question becomes moot (task cancelled, superseded, or no longer relevant), close it",
     '  with `decide_inbox_item` `verdict="rejected"` + a `reason`; never leave it pending.',
-    "- Questions are a chat-only mechanism. Do not create question items from non-interactive",
-    "  runs; use the handoff contract above when there is no live operator.",
+    "- YOUR discretionary questions are a chat-only mechanism: do not create question items yourself",
+    "  from non-interactive runs; use the handoff contract above when there is no live operator.",
+    "  The spec consensus GATE, however, may file its own clarification questions on non-interactive",
+    "  runs (that is gate-driven, not your discretion) \u2014 resume them via the rule above when answered.",
     "",
     "Onboarding contract \u2014 seed project context when there is none:",
     `- A project is un-onboarded when it has no \`${PROJECT_CONSTITUTION_PAGE.path}\` wiki page.`,
@@ -44226,7 +44585,7 @@ function resolveDefaultBranch(checkoutPath) {
   if (!checkoutPath) return "main";
   const runGit = (args) => {
     try {
-      return (0, import_node_child_process4.execFileSync)("git", ["-C", checkoutPath, ...args], {
+      return (0, import_node_child_process5.execFileSync)("git", ["-C", checkoutPath, ...args], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
         timeout: 15e3,
@@ -44295,8 +44654,8 @@ async function runOrphanWorktreeSweep(client, opts) {
   }
 }
 function readStateDir() {
-  if (process.env.CODEX_HOME) return import_node_path12.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
-  return import_node_path12.default.join(import_node_os8.default.homedir(), ".mrrlin", "director-bridge");
+  if (process.env.CODEX_HOME) return import_node_path13.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
+  return import_node_path13.default.join(import_node_os9.default.homedir(), ".mrrlin", "director-bridge");
 }
 function readAllowedOrigins() {
   const raw = (process.env.MRRLIN_DIRECTOR_BRIDGE_ALLOWED_ORIGINS ?? "").trim();
@@ -44384,7 +44743,7 @@ function sessionIdOf(msg) {
   return typeof id === "string" ? id : null;
 }
 function attachBridgeWss(server, opts) {
-  const { token, allowedOrigins, onReady, logger, onPaired, selfUpdate } = opts;
+  const { token, allowedOrigins, onReady, logger, onPaired, bridgeInstanceId, selfUpdate } = opts;
   const wss = new import_websocket_server.default({ server, path: "/ws" });
   wss.on("connection", (socket, request) => {
     const origin = request.headers.origin;
@@ -44426,6 +44785,7 @@ function attachBridgeWss(server, opts) {
     send({
       type: "ready",
       bridgeVersion: 1,
+      ...bridgeInstanceId ? { bridgeInstanceId } : {},
       ...selfUpdate ? {
         version: selfUpdate.version,
         binSha: selfUpdate.binSha,
@@ -44439,13 +44799,118 @@ function attachBridgeWss(server, opts) {
 }
 var TurnInterruptedError = class extends Error {
 };
+function attachSeqMetadata(msg, seq, turnId) {
+  if (msg.type === "event" || msg.type === "rateLimits" || msg.type === "error") {
+    return { ...msg, seq, turnId };
+  }
+  return msg;
+}
 function createBridgeMessageHandler(deps) {
+  const tombstones = deps.tombstones ?? /* @__PURE__ */ new Map();
   return (socket, _request, send, logCtx) => {
     const boundSessions = /* @__PURE__ */ new Set();
     socket.on("close", () => {
       for (const id of boundSessions) deps.unbindSessionSink?.(id, send);
       boundSessions.clear();
     });
+    function logResumeRejected(sessionId, reason) {
+      logCtx?.logger.logOut({
+        spanId: logCtx.span.id,
+        sessionId,
+        type: "<resume-rejected>",
+        payload: { sessionId, reason }
+      });
+    }
+    function handleResumeRequest(req, sendMsg) {
+      if (req.lastSeenBridgeInstanceId !== deps.bridgeInstanceId) {
+        sendMsg({ type: "resume", status: "no-buffer", reason: "bridge-restarted" });
+        logResumeRejected(req.directorSessionId, "bridge-restarted");
+        return;
+      }
+      const t = deps.threads.get(req.directorSessionId);
+      const tombstone = lookupTombstone(tombstones, req.directorSessionId);
+      if (!t && !tombstone) {
+        sendMsg({ type: "resume", status: "no-buffer", reason: "wrong-session" });
+        logResumeRejected(req.directorSessionId, "wrong-session");
+        return;
+      }
+      if (!t && tombstone) {
+        const reason = tombstone.turnId === req.turnId ? "expired" : "wrong-turn";
+        sendMsg({ type: "resume", status: "no-buffer", reason });
+        logResumeRejected(req.directorSessionId, reason);
+        return;
+      }
+      const buf = t?.replay ?? null;
+      if (!buf) {
+        sendMsg({ type: "resume", status: "no-buffer", reason: "wrong-session" });
+        logResumeRejected(req.directorSessionId, "wrong-session");
+        return;
+      }
+      if (buf.turnId !== req.turnId) {
+        sendMsg({ type: "resume", status: "no-buffer", reason: "wrong-turn" });
+        logResumeRejected(req.directorSessionId, "wrong-turn");
+        return;
+      }
+      const epochMatch = req.epoch === buf.bindEpoch || req.epoch === buf.bindEpoch - 1;
+      if (!epochMatch) {
+        sendMsg({ type: "resume", status: "no-buffer", reason: "superseded" });
+        logResumeRejected(req.directorSessionId, "superseded");
+        return;
+      }
+      const tail2 = eventsAfter(buf, req.lastSeq);
+      if (tail2 === null) {
+        sendMsg({ type: "resume", status: "no-buffer", reason: "evicted" });
+        logResumeRejected(req.directorSessionId, "evicted");
+        return;
+      }
+      const result = transition(buf.state, { kind: "resume", epochMatch: true });
+      if (result.next === "invalid") {
+        sendMsg({ type: "resume", status: "no-buffer", reason: "superseded" });
+        return;
+      }
+      buf.state = result.next;
+      incrementBindEpoch(buf);
+      buf.replaying = true;
+      deps.bindSessionSink?.(req.directorSessionId, send);
+      boundSessions.add(req.directorSessionId);
+      if (buf.triggerGrace) socket.once("close", buf.triggerGrace);
+      const willStreamLive = result.next === "live";
+      sendMsg({
+        type: "resume",
+        status: "replaying",
+        turnId: buf.turnId,
+        firstSeq: tail2[0]?.seq ?? req.lastSeq + 1,
+        lastSeq: buf.lastSeq,
+        spanId: buf.spanId,
+        bindEpoch: buf.bindEpoch,
+        eventCount: tail2.length,
+        willStreamLive
+      });
+      for (const { msg: bufferedMsg } of tail2) sendMsg(bufferedMsg);
+      for (const m of buf.outboundQueue) sendMsg(m);
+      buf.outboundQueue.length = 0;
+      buf.replaying = false;
+      logCtx?.logger.logOut({
+        spanId: logCtx.span.id,
+        sessionId: req.directorSessionId,
+        type: "<resume-replay>",
+        payload: {
+          sessionId: req.directorSessionId,
+          turnId: buf.turnId,
+          willStreamLive,
+          firstSeq: tail2[0]?.seq ?? req.lastSeq + 1,
+          lastSeq: buf.lastSeq,
+          eventCount: tail2.length
+        }
+      });
+      if (result.next === "interrupted") {
+        const closed = transition("interrupted", { kind: "result_delivered_to_client" });
+        if (closed.next !== "invalid") {
+          buf.state = closed.next;
+          buf.finishedAt = Date.now();
+        }
+      }
+    }
     socket.on("message", async (data) => {
       const spanId = import_node_crypto5.default.randomUUID();
       if (logCtx) {
@@ -44532,7 +44997,11 @@ function createBridgeMessageHandler(deps) {
         } catch (error51) {
           bootstrapError = error51 instanceof Error ? error51.message : String(error51);
         }
-        sendForSpan({ type: "bootstrap", models, rateLimits, ...bootstrapError ? { error: bootstrapError } : {} });
+        sendForSpan({ type: "bootstrap", models, rateLimits, ...deps.bridgeInstanceId ? { bridgeInstanceId: deps.bridgeInstanceId } : {}, ...bootstrapError ? { error: bootstrapError } : {} });
+        return;
+      }
+      if (msg.type === "resume") {
+        handleResumeRequest(msg, sendForSpan);
         return;
       }
       if (msg.type === "report_issue") {
@@ -44590,6 +45059,15 @@ function createBridgeMessageHandler(deps) {
           sendForSpan({ type: "error", directorSessionId: directorSessionId2, error: "No active Director session to interrupt." });
           return;
         }
+        const interruptBuf = existing.replay;
+        if (interruptBuf && interruptBuf.state === "grace") {
+          const stopResult = transition("grace", { kind: "stop" });
+          if (stopResult.next !== "invalid") {
+            interruptBuf.state = stopResult.next;
+            cancelGrace(interruptBuf);
+            recordInterrupted(interruptBuf);
+          }
+        }
         const codexClient2 = await deps.acquireCodex();
         try {
           await codexClient2.turn.interrupt({ threadId: existing.threadId });
@@ -44660,7 +45138,8 @@ function createBridgeMessageHandler(deps) {
             lastUsedAt: Date.now(),
             inFlight: false,
             model: desiredModel,
-            reasoningEffort: desiredEffort
+            reasoningEffort: desiredEffort,
+            replay: null
           };
           await acquireThread(codexClient, {
             threadId: null,
@@ -44710,11 +45189,52 @@ function createBridgeMessageHandler(deps) {
         return;
       }
       thread.inFlight = true;
+      thread.replay = createReplayBuffer({
+        turnId: (0, import_node_crypto5.randomUUID)(),
+        spanId,
+        ...deps.turnGraceMs !== void 0 ? { graceMs: deps.turnGraceMs } : {}
+      });
       thread.lastUsedAt = Date.now();
       const threadId = thread.threadId;
+      sendForSpan({
+        type: "turn-started",
+        directorSessionId,
+        turnId: thread.replay.turnId
+      });
       const mapper = thread.mapper;
       mapper.reset();
       const contextPrefix = renderContextPrefix({ ...msg.context, directorSessionId });
+      const sendInTurn = (msg2) => {
+        const buf = thread.replay;
+        if (!buf) {
+          sendForSpan(msg2);
+          return;
+        }
+        if (isTerminalEvent(msg2) && buf.terminalDelivered) {
+          logCtx?.logger.logOut({
+            spanId,
+            sessionId: directorSessionId,
+            type: "<terminal-event-dropped>",
+            payload: { sessionId: directorSessionId, terminalAlreadyDelivered: true }
+          });
+          return;
+        }
+        const recorded = recordOutgoing(buf, msg2);
+        if (isTerminalEvent(msg2)) buf.terminalDelivered = true;
+        const tagged = attachSeqMetadata(recorded.msg, recorded.seq, buf.turnId);
+        if (buf.replaying) {
+          buf.outboundQueue.push(tagged);
+          return;
+        }
+        const liveSink = deps.getSessionSink?.(directorSessionId);
+        if (liveSink) {
+          liveSink(tagged);
+          return;
+        }
+        if (socket.readyState === socket.OPEN) {
+          sendForSpan(tagged);
+        }
+      };
       try {
         await deps.runExclusive(async () => {
           let resolveTurn = null;
@@ -44734,13 +45254,13 @@ function createBridgeMessageHandler(deps) {
               return;
             }
             outputEvents += 1;
-            sendForSpan({ type: "event", directorSessionId, event });
+            sendInTurn({ type: "event", directorSessionId, event });
           };
           const unsub = codexClient.onNotification((method, params) => {
             pokeActivity();
             if (method === "account/rateLimits/updated") {
               const snapshot = params?.rateLimits ?? null;
-              if (snapshot) sendForSpan({ type: "rateLimits", directorSessionId, rateLimits: snapshot });
+              if (snapshot) sendInTurn({ type: "rateLimits", directorSessionId, rateLimits: snapshot });
             }
             const events = mapper.mapNotification({ method, params }, threadId);
             for (const event of events) {
@@ -44778,15 +45298,41 @@ function createBridgeMessageHandler(deps) {
             }
           });
           const onSocketClose = () => {
-            rejectWatchdog?.(new TurnInterruptedError());
-            void withTimeout(codexClient.turn.interrupt({ threadId }), DEFAULT_TURN_INTERRUPT_TIMEOUT_MS, "interrupt timed out").catch(
-              () => {
+            const buf = thread.replay;
+            if (!buf || buf.state !== "live") return;
+            const r = transition("live", { kind: "socket_close" });
+            if (r.next === "invalid") return;
+            buf.state = r.next;
+            logCtx?.logger.logOut({
+              spanId,
+              sessionId: directorSessionId,
+              type: "<resume-grace-started>",
+              payload: { sessionId: directorSessionId, turnId: buf.turnId, graceMs: buf.graceMs }
+            });
+            enterGrace(buf, () => {
+              const expired = transition("grace", { kind: "grace_expire" });
+              if (expired.next === "invalid") return;
+              buf.state = expired.next;
+              recordInterrupted(buf);
+              logCtx?.logger.logOut({
+                spanId,
+                sessionId: directorSessionId,
+                type: "<grace-expired>",
+                payload: { sessionId: directorSessionId, turnId: buf.turnId, lastSeq: buf.lastSeq }
+              });
+              rejectWatchdog?.(new TurnInterruptedError());
+              void withTimeout(
+                codexClient.turn.interrupt({ threadId }),
+                DEFAULT_TURN_INTERRUPT_TIMEOUT_MS,
+                "interrupt timed out"
+              ).catch(() => {
                 deps.threads.delete(directorSessionId);
                 deps.persistThreads();
-              }
-            );
+              });
+            });
           };
           socket.once("close", onSocketClose);
+          if (thread.replay) thread.replay.triggerGrace = onSocketClose;
           pokeActivity = () => watchdog.poke();
           const runSequence = (async () => {
             const turnInput = [];
@@ -44821,16 +45367,19 @@ ${effectiveText}` : effectiveText;
               forward(event);
             }
             if (outputEvents === 0) {
-              sendForSpan({
+              sendInTurn({
                 type: "error",
                 directorSessionId,
                 error: "Director turn completed without any output \u2014 Codex likely hit its usage/credits limit. Check your Codex account/plan."
               });
             }
             for (const event of deferredResults) {
-              sendForSpan({ type: "event", directorSessionId, event });
+              sendInTurn({ type: "event", directorSessionId, event });
             }
           } finally {
+            if (thread.replay && thread.replay.state === "live") {
+              markCompleted(thread.replay, Date.now());
+            }
             socket.off("close", onSocketClose);
             watchdog.cancel();
             unsub();
@@ -44839,7 +45388,7 @@ ${effectiveText}` : effectiveText;
         });
       } catch (error51) {
         if (!(error51 instanceof TurnInterruptedError)) {
-          sendForSpan({ type: "error", directorSessionId, error: error51 instanceof Error ? error51.message : String(error51) });
+          sendInTurn({ type: "error", directorSessionId, error: error51 instanceof Error ? error51.message : String(error51) });
           const msg2 = error51 instanceof Error ? error51.message : String(error51);
           if (/unauthor|not logged in|login|401|auth/i.test(msg2)) {
             deps.setCodexAuth?.("expired");
@@ -44886,7 +45435,7 @@ function parseConfig() {
 }
 function scanForOtherBridges() {
   try {
-    const result = (0, import_node_child_process4.spawnSync)("pgrep", ["-f", "mrrlin-mcp director-bridge"], {
+    const result = (0, import_node_child_process5.spawnSync)("pgrep", ["-f", "mrrlin-mcp director-bridge"], {
       encoding: "utf8"
     });
     if (result.status !== 0) return [];
@@ -45018,8 +45567,8 @@ async function startDirectorBridge() {
     codexCwd: config2.codexCwd,
     codexExecutable: config2.codexExecutable,
     checkoutRegistry,
-    worktreeRoot: import_node_path12.default.join(config2.stateDir, "worktrees"),
-    locksDir: import_node_path12.default.join(config2.stateDir, "locks"),
+    worktreeRoot: import_node_path13.default.join(config2.stateDir, "worktrees"),
+    locksDir: import_node_path13.default.join(config2.stateDir, "locks"),
     // Wire the profile-enforced executor server for code-execution runs. Each run gets its own
     // sandboxed Codex instance (scrubbed env, scratch CODEX_HOME, deny-read, egress allowlist).
     // The returned handle's dispose() shuts down the spawned app-server CHILD (manager.shutdown(),
@@ -45052,7 +45601,7 @@ async function startDirectorBridge() {
       },
       runVerificationTurn: createRunVerificationTurn({
         startSandbox: async (egressDomains) => {
-          const cwd = import_node_fs12.default.mkdtempSync(import_node_path12.default.join(import_node_os8.default.tmpdir(), "mrrlin-verify-"));
+          const cwd = import_node_fs12.default.mkdtempSync(import_node_path13.default.join(import_node_os9.default.tmpdir(), "mrrlin-verify-"));
           let handle;
           try {
             handle = await startExecutorServer({ worktree: cwd, egressDomains });
@@ -45081,6 +45630,8 @@ async function startDirectorBridge() {
     }
   };
   const sessionSinks = createSessionSinkRegistry();
+  const tombstones = /* @__PURE__ */ new Map();
+  const bridgeInstanceId = (0, import_node_crypto5.randomUUID)();
   const asyncConsumerDeps = {
     client,
     runExclusive: wrappedTurnLock.runExclusive,
@@ -45140,7 +45691,8 @@ async function startDirectorBridge() {
       lastUsedAt: entry.lastUsedAt,
       inFlight: false,
       model: entry.model,
-      reasoningEffort: normalizeReasoningEffort(entry.reasoningEffort)
+      reasoningEffort: normalizeReasoningEffort(entry.reasoningEffort),
+      replay: null
     });
   }
   const persistThreads = () => {
@@ -45200,6 +45752,7 @@ async function startDirectorBridge() {
     unbindSessionSink: (directorSessionId, send) => {
       sessionSinks.unbind(directorSessionId, send);
     },
+    getSessionSink: (directorSessionId) => sessionSinks.get(directorSessionId),
     maybeUpdateOffer: () => selfUpdateHandle.maybeUpdateOffer()
   };
   const bridgeLogger = createBridgeLogger(config2.stateDir, process.env);
@@ -45211,9 +45764,10 @@ async function startDirectorBridge() {
   attachBridgeWss(server, {
     token: config2.token,
     allowedOrigins: config2.allowedOrigins,
-    onReady: createBridgeMessageHandler({ ...sharedHandlerDeps, threads, persistThreads }),
+    onReady: createBridgeMessageHandler({ ...sharedHandlerDeps, threads, persistThreads, bridgeInstanceId, tombstones }),
     logger: bridgeLogger,
     onPaired: () => health.setPaired(true),
+    bridgeInstanceId,
     selfUpdate: {
       version: PKG_VERSION,
       binSha: bridgeBinShaShort,
@@ -45313,10 +45867,36 @@ async function startDirectorBridge() {
       enqueueRun(
         () => runOrphanWorktreeSweep(client, {
           checkoutRegistry,
-          worktreeRoot: import_node_path12.default.join(config2.stateDir, "worktrees"),
-          locksDir: import_node_path12.default.join(config2.stateDir, "locks")
+          worktreeRoot: import_node_path13.default.join(config2.stateDir, "worktrees"),
+          locksDir: import_node_path13.default.join(config2.stateDir, "locks")
         })
       );
+      enqueueRun(async () => {
+        const now = Date.now();
+        for (const [sid, t] of threads) {
+          if (t.replay && shouldGc(t.replay, now)) {
+            const turnId = t.replay.turnId;
+            const lastSeq = t.replay.lastSeq;
+            writeTombstone(tombstones, sid, t.replay, now);
+            bridgeLogger.logOut({
+              spanId: "gc",
+              sessionId: sid,
+              type: "<tombstone-written>",
+              payload: { sessionId: sid, turnId, lastSeq }
+            });
+            t.replay = null;
+          }
+        }
+        const removed = sweepExpiredTombstones(tombstones, now);
+        if (removed > 0) {
+          bridgeLogger.logOut({
+            spanId: "gc",
+            sessionId: null,
+            type: "<tombstone-expired>",
+            payload: { removed }
+          });
+        }
+      });
       scheduleClaimLoop();
     }, claimIntervalMs());
     claimTimer.unref?.();
@@ -45500,7 +46080,7 @@ function readDispatchBody(req) {
 function readOrCreateBridgeToken(stateDir) {
   const explicit = (process.env.MRRLIN_DIRECTOR_BRIDGE_TOKEN ?? "").trim();
   if (explicit) return explicit;
-  const tokenPath = import_node_path12.default.join(stateDir, "token.txt");
+  const tokenPath = import_node_path13.default.join(stateDir, "token.txt");
   try {
     const existing = import_node_fs12.default.readFileSync(tokenPath, "utf8").trim();
     if (existing) return existing;
@@ -48892,16 +49472,16 @@ var StdioServerTransport = class {
 // src/tools.ts
 var import_promises3 = require("node:fs/promises");
 var import_node_fs14 = require("node:fs");
-var import_node_path15 = __toESM(require("node:path"), 1);
-var import_node_os9 = __toESM(require("node:os"), 1);
-var import_node_child_process7 = require("node:child_process");
+var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_os10 = __toESM(require("node:os"), 1);
+var import_node_child_process8 = require("node:child_process");
 
 // ../../packages/wiki/dist/index.js
 var import_promises2 = __toESM(require("node:fs/promises"), 1);
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path14 = __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_path13.default.sep).join("/");
+  return input.split(import_node_path14.default.sep).join("/");
 }
 function slugifyWikiSegment(input) {
   return input.trim().toLowerCase().replace(/`/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -48915,12 +49495,12 @@ async function pathExists2(input) {
   }
 }
 async function findWorkspaceRoot(start = process.cwd()) {
-  let current = import_node_path13.default.resolve(start);
+  let current = import_node_path14.default.resolve(start);
   while (true) {
-    if (await pathExists2(import_node_path13.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path13.default.join(current, "docs"))) {
+    if (await pathExists2(import_node_path14.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path14.default.join(current, "docs"))) {
       return current;
     }
-    const parent = import_node_path13.default.dirname(current);
+    const parent = import_node_path14.default.dirname(current);
     if (parent === current) {
       throw new Error(`Unable to find Mrrlin workspace root from ${start}`);
     }
@@ -48929,28 +49509,28 @@ async function findWorkspaceRoot(start = process.cwd()) {
 }
 async function resolveDocsRoot(input) {
   if (input) {
-    return import_node_path13.default.resolve(input);
+    return import_node_path14.default.resolve(input);
   }
   if (process.env.MRRLIN_DOCS_ROOT) {
-    return import_node_path13.default.resolve(process.env.MRRLIN_DOCS_ROOT);
+    return import_node_path14.default.resolve(process.env.MRRLIN_DOCS_ROOT);
   }
-  return import_node_path13.default.join(await findWorkspaceRoot(), "docs");
+  return import_node_path14.default.join(await findWorkspaceRoot(), "docs");
 }
 async function resolveIndexPath(input) {
   if (input) {
-    return import_node_path13.default.resolve(input);
+    return import_node_path14.default.resolve(input);
   }
   if (process.env.MRRLIN_WIKI_INDEX_PATH) {
-    return import_node_path13.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
+    return import_node_path14.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
   }
   const workspaceRoot = await findWorkspaceRoot();
-  return import_node_path13.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
+  return import_node_path14.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_path13.default.join(dir, entry.name);
+    const absolute = import_node_path14.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkMarkdownFiles(root, absolute));
       continue;
@@ -48969,7 +49549,7 @@ function parseTitle(markdown, sourcePath) {
   return title;
 }
 function documentFromFile(docsRoot, absolutePath, markdown) {
-  const relativePath = toPosixPath(import_node_path13.default.relative(docsRoot, absolutePath));
+  const relativePath = toPosixPath(import_node_path14.default.relative(docsRoot, absolutePath));
   const [section, fileName] = relativePath.split("/");
   if (!section || !fileName || !INCLUDED_DOC_FOLDERS.has(section)) {
     return null;
@@ -49267,6 +49847,19 @@ ${dismissedFwd.slice(-20).join("\n")}` : "";
 var SPEC_HEADS = ["plan-reviewer", "architect", "security-analyst", "scope-analyst"];
 async function runSpecGate(_target, deps, opts) {
   if (!await deps.consensusEnabled()) return { outcome: "SKIPPED" };
+  const intent = await deps.readIntent();
+  if (intent.taskId !== null && (intent.seed === null || intent.seed.trim() === "")) {
+    return {
+      outcome: "CONSENSUS_BLOCKED",
+      clarifications: [
+        {
+          question: "What are the requirements for this task? There is no operator request on record, so the spec cannot be validated against your intent \u2014 please state what this task must do.",
+          whyBlocking: "operator_seed_request is empty",
+          category: "scope"
+        }
+      ]
+    };
+  }
   const extraHeads = opts?.extraHeads ?? [];
   const heads = [...SPEC_HEADS, ...extraHeads.filter((h) => !SPEC_HEADS.includes(h))];
   const spec = await deps.readSpec();
@@ -49308,6 +49901,15 @@ async function runSpecGate(_target, deps, opts) {
     await deps.promoteSpecReady(currentHash);
     return { outcome: "CONVERGED" };
   }
+  if (result.outcome === "CONSENSUS_BLOCKED") {
+    const accepted = result.history.at(-1)?.accepted ?? [];
+    const clarifications = accepted.filter((issue2) => issue2.category === "ambiguity" || issue2.category === "scope").map((issue2) => ({
+      question: issue2.text,
+      whyBlocking: `reviewer raised a ${issue2.category} issue`,
+      category: issue2.category
+    }));
+    return clarifications.length > 0 ? { outcome: "CONSENSUS_BLOCKED", clarifications } : { outcome: "CONSENSUS_BLOCKED" };
+  }
   return { outcome: result.outcome };
 }
 
@@ -49384,7 +49986,7 @@ async function runCodeGate(_target, deps) {
 }
 
 // src/consensus/codex-exec.ts
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 function extractFinalMessage(stdout) {
   let last = null;
   for (const rawLine of stdout.split(/\r?\n/)) {
@@ -49429,7 +50031,7 @@ function firstString(...values) {
   return null;
 }
 function runCodexExec(input, deps) {
-  const spawn2 = deps?.spawn ?? import_node_child_process5.spawn;
+  const spawn2 = deps?.spawn ?? import_node_child_process6.spawn;
   const executable = input.codexExecutable ?? "codex";
   const sandbox = input.sandbox ?? "read-only";
   const fullPrompt = input.developerInstructions.trim() ? `${input.developerInstructions.trim()}
@@ -49502,11 +50104,11 @@ function errMessage(err) {
 
 // src/consensus/wiring.ts
 var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_node_path14 = __toESM(require("node:path"), 1);
-var import_node_url = require("node:url");
+var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_url2 = require("node:url");
 
 // src/consensus/code-gate-git.ts
-var import_node_child_process6 = require("node:child_process");
+var import_node_child_process7 = require("node:child_process");
 var DIFF_MAX_BYTES = 2e5;
 var FASTGATE_OUTPUT_MAX_BYTES = 16e3;
 var GIT_TIMEOUT_MS = 6e4;
@@ -49522,7 +50124,7 @@ var defaultRunCmd = (cmd, args, opts) => new Promise((resolve) => {
   };
   let child;
   try {
-    child = (0, import_node_child_process6.spawn)(cmd, args, {
+    child = (0, import_node_child_process7.spawn)(cmd, args, {
       cwd: opts.cwd,
       env: process.env,
       shell: false,
@@ -49734,18 +50336,18 @@ ${res.stdout}${res.stderr}`);
 }
 
 // src/consensus/wiring.ts
-var import_meta = {};
+var import_meta2 = {};
 function getPersonasDir() {
   if (typeof __dirname !== "undefined") {
-    return import_node_path14.default.join(__dirname, "consensus", "personas");
+    return import_node_path15.default.join(__dirname, "consensus", "personas");
   }
-  return import_node_path14.default.join(import_node_path14.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url)), "personas");
+  return import_node_path15.default.join(import_node_path15.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_fs13.default.readFileSync(import_node_path14.default.join(getPersonasDir(), `${name}.md`), "utf8");
+  const content = import_node_fs13.default.readFileSync(import_node_path15.default.join(getPersonasDir(), `${name}.md`), "utf8");
   personaCache.set(name, content);
   return content;
 }
@@ -49754,6 +50356,19 @@ function buildSpecGateDeps(args) {
   const rounds = Number(process.env["MRRLIN_CONSENSUS_ROUNDS"] ?? 3);
   const maxHeadCalls = rounds * (4 + extraHeadCount + 1);
   const timeoutMs = Number(process.env["MRRLIN_CONSENSUS_HEAD_TIMEOUT_MS"] ?? 15e4);
+  let intentPromise = null;
+  function loadIntent() {
+    if (!intentPromise) {
+      intentPromise = (async () => {
+        const page = await client.getWikiPage(projectSlug, specPageId);
+        const taskId = page?.taskId ?? null;
+        if (taskId === null) return { taskId: null, seed: null };
+        const task = await client.getTask(projectSlug, taskId);
+        return { taskId, seed: task?.operatorSeedRequest ?? null };
+      })();
+    }
+    return intentPromise;
+  }
   return {
     rounds,
     maxHeadCalls,
@@ -49769,15 +50384,23 @@ function buildSpecGateDeps(args) {
         contentHash: page.contentHash
       };
     },
+    readIntent() {
+      return loadIntent();
+    },
     async runHead(personaName, artifact, dismissed) {
       const persona = loadPersona(personaName);
+      const { seed } = await loadIntent();
+      const intentBlock = seed ? `--- OPERATOR INTENT (the operator's own words \u2014 judge the spec against THIS) ---
+${seed}
+
+` : "";
       return runCodexExec(
         {
-          prompt: `Review this spec.
+          prompt: `Review this spec against the operator's intent.
 
 ${dismissed}
 
---- SPEC ---
+${intentBlock}--- SPEC ---
 ${artifact}`,
           developerInstructions: persona,
           cwd,
@@ -49953,6 +50576,7 @@ ${artifact}`,
 }
 
 // src/async-tools/consensus.ts
+var import_node_crypto6 = require("node:crypto");
 async function cachedResult(client, input) {
   const page = await client.getWikiPage(input.projectSlug, input.pageId);
   if (!page) return null;
@@ -49979,16 +50603,58 @@ async function run(ctx, input) {
     deps,
     input.extraHeads && input.extraHeads.length > 0 ? { extraHeads: input.extraHeads } : void 0
   );
+  if (result.outcome === "CONSENSUS_BLOCKED") {
+    const clarifications = result.clarifications ?? [];
+    if (clarifications.length > 0) {
+      const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+      const taskId = page?.taskId ?? null;
+      let planId = null;
+      if (!taskId) {
+        const plans = await ctx.client.listPlans(input.projectSlug);
+        planId = plans.find((p) => p.specWikiPageId === input.pageId)?.id ?? null;
+      }
+      if (taskId) {
+        for (const clarification of clarifications) {
+          const scopeId = taskId;
+          const id = `II-${scopeId}-gate-${(0, import_node_crypto6.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
+          try {
+            await ctx.client.createInboxItem(input.projectSlug, {
+              id,
+              kind: "question",
+              taskId: scopeId,
+              body: clarification.question,
+              origin: "gate"
+            });
+          } catch {
+          }
+        }
+      } else if (planId) {
+        for (const clarification of clarifications) {
+          const scopeId = planId;
+          const id = `II-${scopeId}-gate-${(0, import_node_crypto6.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
+          try {
+            await ctx.client.createInboxItem(input.projectSlug, {
+              id,
+              kind: "question",
+              planId: scopeId,
+              body: clarification.question,
+              origin: "gate"
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    return {
+      kind: "failed",
+      failureReason: "consensus_blocked",
+      error: clarifications.length > 0 ? `Consensus blocked on ${clarifications.length} clarification(s); filed as operator question(s).` : "Consensus blocked: reviewers did not converge within budget."
+    };
+  }
   switch (result.outcome) {
     case "CONVERGED":
     case "SKIPPED":
       return { kind: "done", resultJson: JSON.stringify(result), finalReviewedHash: null };
-    case "CONSENSUS_BLOCKED":
-      return {
-        kind: "failed",
-        failureReason: "consensus_blocked",
-        error: "Consensus blocked: reviewers did not converge within budget."
-      };
     case "CONSENSUS_UNAVAILABLE":
       return { kind: "retry", failureReason: "provider_unavailable", error: "Consensus unavailable (provider/quota)." };
     case "SPEC_CHANGED_DURING_REVIEW":
@@ -50003,6 +50669,17 @@ async function run(ctx, input) {
 }
 function onComplete(outcome, input) {
   if (outcome.kind === "done") {
+    let specOutcome = "CONVERGED";
+    try {
+      specOutcome = JSON.parse(outcome.resultJson).outcome ?? "CONVERGED";
+    } catch {
+    }
+    if (specOutcome === "SKIPPED") {
+      return {
+        kind: "info",
+        body: `Consensus is disabled for this project; Specs/${input.pageId} was not gated and spec_ready is unchanged.`
+      };
+    }
     return {
       kind: "info",
       body: `Consensus CONVERGED for Specs/${input.pageId}; spec_ready set. Ready to create an execution run.`
@@ -50023,7 +50700,7 @@ var consensusDescriptor = {
 };
 
 // src/async-tools/enqueue.ts
-var import_node_crypto6 = __toESM(require("node:crypto"), 1);
+var import_node_crypto7 = __toESM(require("node:crypto"), 1);
 async function enqueueAsyncTool(client, descriptor2, input) {
   if (descriptor2.cachedResult) {
     const cached2 = await descriptor2.cachedResult(client, input);
@@ -50036,7 +50713,7 @@ async function enqueueAsyncTool(client, descriptor2, input) {
   if (active) {
     return { status: "already_running", jobId: active.id, message: "Already running; will notify in inbox." };
   }
-  const jobId = `AJ-${import_node_crypto6.default.randomUUID()}`;
+  const jobId = `AJ-${import_node_crypto7.default.randomUUID()}`;
   try {
     await client.createAsyncJob(input.projectSlug, {
       id: jobId,
@@ -50895,7 +51572,7 @@ var mcpToolDescriptions = {
   [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.',
   [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.createExecutionRun]: "Create a durable Director execution run for a task. Persists status, branch/SHA, workflow ids, and checkpoint cursor outside the chat transcript.",
+  [mcpToolNames.createExecutionRun]: 'Create a durable Director execution run for a task. Persists status, branch/SHA, workflow ids, and checkpoint cursor outside the chat transcript. For tasks that require a browser (login flows, UI verification, scraping), set prerequisites:[{mcp:"mrrlin-browser",reason:"<why a browser is needed>"}] so any resulting handoff offers a one-click "Launch browser & resume".',
   [mcpToolNames.getExecutionRun]: "Fetch a single execution run by id.",
   [mcpToolNames.listExecutionArtifacts]: "List artifacts captured during an execution run, in chronological order.",
   [mcpToolNames.listExecutionRuns]: "List execution runs for a project. Optional filters: taskId, status.",
@@ -51339,7 +52016,10 @@ function createMrrlinTools(options) {
         if (ready !== true) return await c.markSpecReady({ projectSlug, pageId, ready });
         const settings = await c.getOperatorSettings();
         if (!settings.consensusEnabled) {
-          return await c.markSpecReady({ projectSlug, pageId, ready });
+          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.`
+          );
         }
         const page = await c.getWikiPage(projectSlug, pageId);
         if (!page || page.folder !== "Specs") {
@@ -51508,7 +52188,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_path15.default.extname(filePath).toLowerCase();
+        const extension2 = import_node_path16.default.extname(filePath).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -51536,7 +52216,7 @@ function createMrrlinTools(options) {
             "Artifact exceeds 5MB; split or summarize instead."
           );
         }
-        const filename = import_node_path15.default.basename(filePath);
+        const filename = import_node_path16.default.basename(filePath);
         const created = await c.createArtifactFile(projectSlug, {
           class: artifactClass,
           contentType,
@@ -51619,7 +52299,7 @@ function createMrrlinTools(options) {
       "Unable to register local checkout.",
       async (_c, { projectSlug, path: checkoutPath, repo }) => {
         const trimmedPath = checkoutPath.trim();
-        if (!import_node_path15.default.isAbsolute(trimmedPath)) {
+        if (!import_node_path16.default.isAbsolute(trimmedPath)) {
           throw new McpToolCodedError(
             "LOCAL_CHECKOUT_PATH_NOT_ABSOLUTE",
             `Path must be absolute, got: ${trimmedPath}`
@@ -51636,7 +52316,7 @@ function createMrrlinTools(options) {
         }
         let remoteUrl;
         try {
-          remoteUrl = (0, import_node_child_process7.execFileSync)("git", ["-C", resolvedPath, "remote", "get-url", "origin"], {
+          remoteUrl = (0, import_node_child_process8.execFileSync)("git", ["-C", resolvedPath, "remote", "get-url", "origin"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
             timeout: 15e3,
@@ -51654,7 +52334,7 @@ function createMrrlinTools(options) {
             `Origin remote ${remoteUrl} does not match repo ${repo}.`
           );
         }
-        const stateDir = process.env.CODEX_HOME ? import_node_path15.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path15.default.join(import_node_os9.default.homedir(), ".mrrlin", "director-bridge");
+        const stateDir = process.env.CODEX_HOME ? import_node_path16.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path16.default.join(import_node_os10.default.homedir(), ".mrrlin", "director-bridge");
         const registry3 = new CheckoutRegistry(stateDir);
         const confirmedAt = (/* @__PURE__ */ new Date()).toISOString();
         registry3.confirm(projectSlug, resolvedPath, confirmedAt);
@@ -51861,13 +52541,13 @@ function runSetCredential(args) {
 }
 
 // src/install-service.ts
-var import_node_os10 = __toESM(require("node:os"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_os11 = __toESM(require("node:os"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 
 // src/service-paths.ts
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 function isWorktreePath(p) {
-  const norm = import_node_path16.default.normalize(p).split(import_node_path16.default.sep).join("/");
+  const norm = import_node_path17.default.normalize(p).split(import_node_path17.default.sep).join("/");
   return norm.includes("/.claude/worktrees/");
 }
 function resolveServiceCwd(opts) {
@@ -51921,7 +52601,7 @@ function installService(deps) {
     deps.log(resolved.reason);
     return { ok: false };
   }
-  const home = deps.env.HOME ?? import_node_os10.default.homedir();
+  const home = deps.env.HOME ?? import_node_os11.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.");
@@ -51932,7 +52612,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_path17.default.dirname(b)))).join(":");
+  const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path18.default.dirname(b)))).join(":");
   const text = renderEcosystemConfig({
     cwd: resolved.cwd,
     home,
@@ -51941,7 +52621,7 @@ function installService(deps) {
     staging: deps.env.MRRLIN_STAGING === "1",
     apiBaseUrl: deps.env.MRRLIN_API_BASE_URL?.trim() || void 0
   });
-  const ecoPath = import_node_path17.default.join(home, ".mrrlin", "ecosystem.config.cjs");
+  const ecoPath = import_node_path18.default.join(home, ".mrrlin", "ecosystem.config.cjs");
   deps.writeFile(ecoPath, text);
   const start = deps.runPm2(["startOrReload", ecoPath]);
   if (start.code !== 0) {
@@ -51972,13 +52652,13 @@ function uninstallService(deps) {
 
 // src/uninstall-codex.ts
 var import_promises4 = __toESM(require("node:fs/promises"), 1);
-var import_node_os11 = __toESM(require("node:os"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_os12 = __toESM(require("node:os"), 1);
+var import_node_path19 = __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_path18.default.join(options.homeDir ?? import_node_os11.default.homedir(), ".codex");
+  return import_node_path19.default.join(options.homeDir ?? import_node_os12.default.homedir(), ".codex");
 }
 async function pathExists3(target) {
   try {
@@ -51988,10 +52668,10 @@ async function pathExists3(target) {
     return false;
   }
 }
-var MRRLIN_BLOCK_RE2 = /(^|\n)\[mcp_servers\.mrrlin(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
+var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.mrrlin(?:-browser)?(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
 async function uninstallCodex(options = {}) {
   const codexHome = resolveCodexHome2(options);
-  const configPath = import_node_path18.default.join(codexHome, "config.toml");
+  const configPath = import_node_path19.default.join(codexHome, "config.toml");
   const removePrompts = async () => uninstallPrompts(codexHome, options.promptNames ?? []);
   if (!await pathExists3(configPath)) {
     return { action: "missing", configPath, prompts: await removePrompts() };
@@ -52010,19 +52690,19 @@ async function uninstallCodex(options = {}) {
     };
     throw Object.assign(new Error(err.detail), err);
   }
-  if (parsed?.mcp_servers?.["mrrlin"] === void 0) {
+  if (parsed?.mcp_servers?.["mrrlin"] === void 0 && parsed?.mcp_servers?.["mrrlin-browser"] === void 0) {
     return { action: "noop", configPath: realPath, prompts: await removePrompts() };
   }
-  const stripped = existing.replace(MRRLIN_BLOCK_RE2, (match) => match.startsWith("\n") ? "\n" : "").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
+  const stripped = existing.replace(MRRLIN_BLOCK_RE, (match) => match.startsWith("\n") ? "\n" : "").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
   await import_promises4.default.writeFile(realPath, stripped, { mode: 384 });
   return { action: "removed", configPath: realPath, prompts: await removePrompts() };
 }
 async function uninstallPrompts(codexHome, names) {
   if (names.length === 0) return [];
-  const promptsDir2 = import_node_path18.default.join(codexHome, "prompts");
+  const promptsDir2 = import_node_path19.default.join(codexHome, "prompts");
   const out = [];
   for (const name of names) {
-    const promptPath = import_node_path18.default.join(promptsDir2, `${name}.md`);
+    const promptPath = import_node_path19.default.join(promptsDir2, `${name}.md`);
     try {
       await import_promises4.default.unlink(promptPath);
       out.push({ name, action: "removed", promptPath });
@@ -52040,26 +52720,26 @@ async function uninstallPrompts(codexHome, names) {
 
 // src/report-issue-prompt.ts
 var import_node_fs15 = __toESM(require("node:fs"), 1);
-var import_node_path19 = __toESM(require("node:path"), 1);
-var import_node_url2 = require("node:url");
-var import_meta2 = {};
+var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_url3 = require("node:url");
+var import_meta3 = {};
 function promptsDir() {
-  if (typeof __dirname !== "undefined") return import_node_path19.default.join(__dirname, "prompts");
-  return import_node_path19.default.join(import_node_path19.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url)), "prompts");
+  if (typeof __dirname !== "undefined") return import_node_path20.default.join(__dirname, "prompts");
+  return import_node_path20.default.join(import_node_path20.default.dirname((0, import_node_url3.fileURLToPath)(import_meta3.url)), "prompts");
 }
 function readReportIssuePrompt() {
-  return import_node_fs15.default.readFileSync(import_node_path19.default.join(promptsDir(), "report-issue.md"), "utf8");
+  return import_node_fs15.default.readFileSync(import_node_path20.default.join(promptsDir(), "report-issue.md"), "utf8");
 }
 
 // src/bin.ts
 function pm2Runner(args) {
-  const r = (0, import_node_child_process8.spawnSync)("pm2", args, { encoding: "utf8" });
+  const r = (0, import_node_child_process9.spawnSync)("pm2", args, { encoding: "utf8" });
   process.stderr.write(r.stdout ?? "");
   process.stderr.write(r.stderr ?? "");
   return { code: r.status ?? 1, stdout: r.stdout ?? "" };
 }
 function whichBin(bin) {
-  const r = (0, import_node_child_process8.spawnSync)("which", [bin], { encoding: "utf8" });
+  const r = (0, import_node_child_process9.spawnSync)("which", [bin], { encoding: "utf8" });
   const out = (r.stdout ?? "").trim();
   return r.status === 0 && out ? out.split("\n")[0] ?? null : null;
 }
@@ -52072,6 +52752,18 @@ Usage:
                                 MRRLIN_API_ALLOW_REMOTE=1, or use MRRLIN_STAGING=1
                                 to target the known staging API alias.
 
+  mrrlin-mcp install-browser    Idempotently install the dedicated, pinned
+                                Chromium into ~/.mrrlin/browser/browsers (its own
+                                copy, isolated from the operator's Chrome and
+                                codex-chrome). Run by install-codex; safe to
+                                re-run. Exits non-zero on download failure.
+
+  mrrlin-mcp browser-serve      Launch the vendored @playwright/mcp against the
+                                dedicated persistent profile
+                                (~/.mrrlin/browser/profile, headed). This is the
+                                command install-codex wires for the
+                                [mcp_servers.mrrlin-browser] block.
+
   mrrlin-mcp install-codex      Idempotently register Mrrlin in
   [--force]                     ~/.codex/config.toml (or CODEX_HOME). Adds an
   [--force-prompts]             [mcp_servers.mrrlin] block AND drops the bundled
@@ -52205,10 +52897,33 @@ async function main() {
       await startStdioServer();
       return;
     }
+    case "install-browser": {
+      const res = await installBrowser();
+      process.stderr.write(`[mrrlin-mcp install-browser] ${res.action} ${res.browsersPath}
+`);
+      return;
+    }
+    case "browser-serve": {
+      const { command: command2, args, env } = browserServeArgs();
+      const r = (0, import_node_child_process9.spawnSync)(command2, args, { stdio: "inherit", env: { ...process.env, ...env } });
+      process.exitCode = r.status ?? 1;
+      return;
+    }
     case "install-codex": {
       const force = rest.includes("--force");
       const forcePrompts = rest.includes("--force-prompts");
       const binPath = resolveSelfBinPath();
+      try {
+        const b = await installBrowser();
+        process.stderr.write(`[mrrlin-mcp install-codex] install-browser ${b.action} ${b.browsersPath}
+`);
+      } catch (error51) {
+        process.stderr.write(
+          `[mrrlin-mcp install-codex] install-browser FAILED \u2014 config.toml left untouched: ${error51 instanceof Error ? error51.message : String(error51)}
+`
+        );
+        process.exit(2);
+      }
       const result = await installCodex({
         binPath,
         force,
@@ -52258,7 +52973,7 @@ async function main() {
         env: process.env,
         cwd: process.cwd(),
         writeFile: (p, c) => {
-          (0, import_node_fs16.mkdirSync)(import_node_path21.default.dirname(p), { recursive: true, mode: 448 });
+          (0, import_node_fs16.mkdirSync)(import_node_path22.default.dirname(p), { recursive: true, mode: 448 });
           (0, import_node_fs16.writeFileSync)(p, c, { mode: 384 });
         },
         runPm2: pm2Runner,
@@ -52283,14 +52998,14 @@ async function main() {
         purgeSecret: purge,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path21.default.join(process.env.HOME ?? (0, import_node_os12.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path22.default.join(process.env.HOME ?? (0, import_node_os13.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_os12.homedir)();
+      const home = process.env.HOME ?? (0, import_node_os13.homedir)();
       const log = (m) => process.stderr.write(`[mrrlin-mcp uninstall] ${m}
 `);
       uninstallService({
@@ -52304,7 +53019,7 @@ async function main() {
         purgeSecret: true,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path21.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path22.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
         log
       });
       let codexOk = true;
@@ -52324,7 +53039,7 @@ async function main() {
         log(`codex config NOT modified: ${error51 instanceof Error ? error51.message : String(error51)}`);
       }
       try {
-        (0, import_node_fs16.rmSync)(import_node_path21.default.join(home, ".mrrlin"), { recursive: true, force: true });
+        (0, import_node_fs16.rmSync)(import_node_path22.default.join(home, ".mrrlin"), { recursive: true, force: true });
       } catch {
       }
       log("removed ~/.mrrlin");
@@ -52365,7 +53080,7 @@ ${HELP_TEXT}`);
   }
 }
 function resolveSelfBinPath() {
-  return import_node_path20.default.resolve(process.argv[1] ?? process.execPath);
+  return import_node_path21.default.resolve(process.argv[1] ?? process.execPath);
 }
 main().catch((error51) => {
   process.stderr.write(`mrrlin-mcp fatal error: ${error51 instanceof Error ? error51.message : String(error51)}