@mrrlin-dev/mcp 0.3.51 → 0.3.54

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: randomBytes4, createHash: createHash4 } = require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash5 } = 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 = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("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: createHash4 } = require("crypto");
+    var { createHash: createHash5 } = 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 = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("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(fs8) {
+    function patch(fs9) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs8);
-      }
-      if (!fs8.lutimes) {
-        patchLutimes(fs8);
-      }
-      fs8.chown = chownFix(fs8.chown);
-      fs8.fchown = chownFix(fs8.fchown);
-      fs8.lchown = chownFix(fs8.lchown);
-      fs8.chmod = chmodFix(fs8.chmod);
-      fs8.fchmod = chmodFix(fs8.fchmod);
-      fs8.lchmod = chmodFix(fs8.lchmod);
-      fs8.chownSync = chownFixSync(fs8.chownSync);
-      fs8.fchownSync = chownFixSync(fs8.fchownSync);
-      fs8.lchownSync = chownFixSync(fs8.lchownSync);
-      fs8.chmodSync = chmodFixSync(fs8.chmodSync);
-      fs8.fchmodSync = chmodFixSync(fs8.fchmodSync);
-      fs8.lchmodSync = chmodFixSync(fs8.lchmodSync);
-      fs8.stat = statFix(fs8.stat);
-      fs8.fstat = statFix(fs8.fstat);
-      fs8.lstat = statFix(fs8.lstat);
-      fs8.statSync = statFixSync(fs8.statSync);
-      fs8.fstatSync = statFixSync(fs8.fstatSync);
-      fs8.lstatSync = statFixSync(fs8.lstatSync);
-      if (fs8.chmod && !fs8.lchmod) {
-        fs8.lchmod = function(path18, mode, cb) {
+        patchLchmod(fs9);
+      }
+      if (!fs9.lutimes) {
+        patchLutimes(fs9);
+      }
+      fs9.chown = chownFix(fs9.chown);
+      fs9.fchown = chownFix(fs9.fchown);
+      fs9.lchown = chownFix(fs9.lchown);
+      fs9.chmod = chmodFix(fs9.chmod);
+      fs9.fchmod = chmodFix(fs9.fchmod);
+      fs9.lchmod = chmodFix(fs9.lchmod);
+      fs9.chownSync = chownFixSync(fs9.chownSync);
+      fs9.fchownSync = chownFixSync(fs9.fchownSync);
+      fs9.lchownSync = chownFixSync(fs9.lchownSync);
+      fs9.chmodSync = chmodFixSync(fs9.chmodSync);
+      fs9.fchmodSync = chmodFixSync(fs9.fchmodSync);
+      fs9.lchmodSync = chmodFixSync(fs9.lchmodSync);
+      fs9.stat = statFix(fs9.stat);
+      fs9.fstat = statFix(fs9.fstat);
+      fs9.lstat = statFix(fs9.lstat);
+      fs9.statSync = statFixSync(fs9.statSync);
+      fs9.fstatSync = statFixSync(fs9.fstatSync);
+      fs9.lstatSync = statFixSync(fs9.lstatSync);
+      if (fs9.chmod && !fs9.lchmod) {
+        fs9.lchmod = function(path19, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs8.lchmodSync = function() {
+        fs9.lchmodSync = function() {
         };
       }
-      if (fs8.chown && !fs8.lchown) {
-        fs8.lchown = function(path18, uid, gid, cb) {
+      if (fs9.chown && !fs9.lchown) {
+        fs9.lchown = function(path19, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs8.lchownSync = function() {
+        fs9.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs8.rename = typeof fs8.rename !== "function" ? fs8.rename : function(fs$rename) {
+        fs9.rename = typeof fs9.rename !== "function" ? fs9.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() {
-                  fs8.stat(to, function(stater, st) {
+                  fs9.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;
-        }(fs8.rename);
+        }(fs9.rename);
       }
-      fs8.read = typeof fs8.read !== "function" ? fs8.read : function(fs$read) {
+      fs9.read = typeof fs9.read !== "function" ? fs9.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(fs8, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs9, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs8.read);
-      fs8.readSync = typeof fs8.readSync !== "function" ? fs8.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs9.read);
+      fs9.readSync = typeof fs9.readSync !== "function" ? fs9.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs8, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs9, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -7801,11 +7801,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs8.readSync);
-      function patchLchmod(fs9) {
-        fs9.lchmod = function(path18, mode, callback) {
-          fs9.open(
-            path18,
+      }(fs9.readSync);
+      function patchLchmod(fs10) {
+        fs10.lchmod = function(path19, mode, callback) {
+          fs10.open(
+            path19,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -7813,80 +7813,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs9.fchmod(fd, mode, function(err2) {
-                fs9.close(fd, function(err22) {
+              fs10.fchmod(fd, mode, function(err2) {
+                fs10.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs9.lchmodSync = function(path18, mode) {
-          var fd = fs9.openSync(path18, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs10.lchmodSync = function(path19, mode) {
+          var fd = fs10.openSync(path19, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs9.fchmodSync(fd, mode);
+            ret = fs10.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs9.closeSync(fd);
+                fs10.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs9.closeSync(fd);
+              fs10.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs9) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs9.futimes) {
-          fs9.lutimes = function(path18, at, mt, cb) {
-            fs9.open(path18, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs10) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs10.futimes) {
+          fs10.lutimes = function(path19, at, mt, cb) {
+            fs10.open(path19, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs9.futimes(fd, at, mt, function(er2) {
-                fs9.close(fd, function(er22) {
+              fs10.futimes(fd, at, mt, function(er2) {
+                fs10.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs9.lutimesSync = function(path18, at, mt) {
-            var fd = fs9.openSync(path18, constants.O_SYMLINK);
+          fs10.lutimesSync = function(path19, at, mt) {
+            var fd = fs10.openSync(path19, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs9.futimesSync(fd, at, mt);
+              ret = fs10.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs9.closeSync(fd);
+                  fs10.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs9.closeSync(fd);
+                fs10.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs9.futimes) {
-          fs9.lutimes = function(_a3, _b, _c, cb) {
+        } else if (fs10.futimes) {
+          fs10.lutimes = function(_a3, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs9.lutimesSync = function() {
+          fs10.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs8, target, mode, function(er) {
+          return orig.call(fs9, 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(fs8, target, mode);
+            return orig.call(fs9, 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(fs8, target, uid, gid, function(er) {
+          return orig.call(fs9, 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(fs8, target, uid, gid);
+            return orig.call(fs9, 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(fs8, target, options, callback) : orig.call(fs8, target, callback);
+          return options ? orig.call(fs9, target, options, callback) : orig.call(fs9, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs8, target, options) : orig.call(fs8, target);
+          var stats = options ? orig.call(fs9, target, options) : orig.call(fs9, 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(fs8) {
+    function legacy(fs9) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path18, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path18, options);
+      function ReadStream(path19, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path19, options);
         Stream.call(this);
         var self = this;
-        this.path = path18;
+        this.path = path19;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -8013,7 +8013,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs8.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs9.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(path18, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path18, options);
+      function WriteStream(path19, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path19, options);
         Stream.call(this);
-        this.path = path18;
+        this.path = path19;
         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 = fs8.open;
+          this._open = fs9.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 fs8 = require("fs");
+    var fs9 = 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 (!fs8[gracefulQueue]) {
+    if (!fs9[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs8, queue);
-      fs8.close = function(fs$close) {
+      publishQueue(fs9, queue);
+      fs9.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs8, fd, function(err) {
+          return fs$close.call(fs9, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -8136,48 +8136,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs8.close);
-      fs8.closeSync = function(fs$closeSync) {
+      }(fs9.close);
+      fs9.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs8, arguments);
+          fs$closeSync.apply(fs9, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs8.closeSync);
+      }(fs9.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs8[gracefulQueue]);
-          require("assert").equal(fs8[gracefulQueue].length, 0);
+          debug(fs9[gracefulQueue]);
+          require("assert").equal(fs9[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs8[gracefulQueue]);
-    }
-    module2.exports = patch(clone2(fs8));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs8.__patched) {
-      module2.exports = patch(fs8);
-      fs8.__patched = true;
-    }
-    function patch(fs9) {
-      polyfills(fs9);
-      fs9.gracefulify = patch;
-      fs9.createReadStream = createReadStream;
-      fs9.createWriteStream = createWriteStream;
-      var fs$readFile = fs9.readFile;
-      fs9.readFile = readFile2;
-      function readFile2(path18, options, cb) {
+      publishQueue(global, fs9[gracefulQueue]);
+    }
+    module2.exports = patch(clone2(fs9));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs9.__patched) {
+      module2.exports = patch(fs9);
+      fs9.__patched = true;
+    }
+    function patch(fs10) {
+      polyfills(fs10);
+      fs10.gracefulify = patch;
+      fs10.createReadStream = createReadStream;
+      fs10.createWriteStream = createWriteStream;
+      var fs$readFile = fs10.readFile;
+      fs10.readFile = readFile2;
+      function readFile2(path19, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path18, options, cb);
-        function go$readFile(path19, options2, cb2, startTime) {
-          return fs$readFile(path19, options2, function(err) {
+        return go$readFile(path19, options, cb);
+        function go$readFile(path20, options2, cb2, startTime) {
+          return fs$readFile(path20, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path19, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path20, 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 = fs9.writeFile;
-      fs9.writeFile = writeFile;
-      function writeFile(path18, data, options, cb) {
+      var fs$writeFile = fs10.writeFile;
+      fs10.writeFile = writeFile;
+      function writeFile(path19, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path18, data, options, cb);
-        function go$writeFile(path19, data2, options2, cb2, startTime) {
-          return fs$writeFile(path19, data2, options2, function(err) {
+        return go$writeFile(path19, data, options, cb);
+        function go$writeFile(path20, data2, options2, cb2, startTime) {
+          return fs$writeFile(path20, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path19, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path20, 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 = fs9.appendFile;
+      var fs$appendFile = fs10.appendFile;
       if (fs$appendFile)
-        fs9.appendFile = appendFile;
-      function appendFile(path18, data, options, cb) {
+        fs10.appendFile = appendFile;
+      function appendFile(path19, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path18, data, options, cb);
-        function go$appendFile(path19, data2, options2, cb2, startTime) {
-          return fs$appendFile(path19, data2, options2, function(err) {
+        return go$appendFile(path19, data, options, cb);
+        function go$appendFile(path20, data2, options2, cb2, startTime) {
+          return fs$appendFile(path20, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path19, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path20, 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 = fs9.copyFile;
+      var fs$copyFile = fs10.copyFile;
       if (fs$copyFile)
-        fs9.copyFile = copyFile;
+        fs10.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 = fs9.readdir;
-      fs9.readdir = readdir2;
+      var fs$readdir = fs10.readdir;
+      fs10.readdir = readdir2;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir2(path18, options, cb) {
+      function readdir2(path19, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path19, options2, cb2, startTime) {
-          return fs$readdir(path19, fs$readdirCallback(
-            path19,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path20, options2, cb2, startTime) {
+          return fs$readdir(path20, fs$readdirCallback(
+            path20,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path19, options2, cb2, startTime) {
-          return fs$readdir(path19, options2, fs$readdirCallback(
-            path19,
+        } : function go$readdir2(path20, options2, cb2, startTime) {
+          return fs$readdir(path20, options2, fs$readdirCallback(
+            path20,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path18, options, cb);
-        function fs$readdirCallback(path19, options2, cb2, startTime) {
+        return go$readdir(path19, options, cb);
+        function fs$readdirCallback(path20, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path19, options2, cb2],
+                [path20, 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(fs9);
+        var legStreams = legacy(fs10);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs9.ReadStream;
+      var fs$ReadStream = fs10.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs9.WriteStream;
+      var fs$WriteStream = fs10.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs9, "ReadStream", {
+      Object.defineProperty(fs10, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -8306,7 +8306,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs9, "WriteStream", {
+      Object.defineProperty(fs10, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -8317,7 +8317,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs9, "FileReadStream", {
+      Object.defineProperty(fs10, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -8328,7 +8328,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs9, "FileWriteStream", {
+      Object.defineProperty(fs10, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -8338,7 +8338,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path18, options) {
+      function ReadStream(path19, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -8358,7 +8358,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path18, options) {
+      function WriteStream(path19, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -8376,22 +8376,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path18, options) {
-        return new fs9.ReadStream(path18, options);
+      function createReadStream(path19, options) {
+        return new fs10.ReadStream(path19, options);
       }
-      function createWriteStream(path18, options) {
-        return new fs9.WriteStream(path18, options);
+      function createWriteStream(path19, options) {
+        return new fs10.WriteStream(path19, options);
       }
-      var fs$open = fs9.open;
-      fs9.open = open;
-      function open(path18, flags, mode, cb) {
+      var fs$open = fs10.open;
+      fs10.open = open;
+      function open(path19, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path18, flags, mode, cb);
-        function go$open(path19, flags2, mode2, cb2, startTime) {
-          return fs$open(path19, flags2, mode2, function(err, fd) {
+        return go$open(path19, flags, mode, cb);
+        function go$open(path20, flags2, mode2, cb2, startTime) {
+          return fs$open(path20, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path19, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path20, 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 fs9;
+      return fs10;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs8[gracefulQueue].push(elem);
+      fs9[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs8[gracefulQueue].length; ++i) {
-        if (fs8[gracefulQueue][i].length > 2) {
-          fs8[gracefulQueue][i][3] = now;
-          fs8[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs9[gracefulQueue].length; ++i) {
+        if (fs9[gracefulQueue][i].length > 2) {
+          fs9[gracefulQueue][i][3] = now;
+          fs9[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -8420,9 +8420,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs8[gracefulQueue].length === 0)
+      if (fs9[gracefulQueue].length === 0)
         return;
-      var elem = fs8[gracefulQueue].shift();
+      var elem = fs9[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 {
-          fs8[gracefulQueue].push(elem);
+          fs9[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, fs8, callback) {
-      const cachedPrecision = fs8[cacheSymbol];
+    function probe(file2, fs9, callback) {
+      const cachedPrecision = fs9[cacheSymbol];
       if (cachedPrecision) {
-        return fs8.stat(file2, (err, stat2) => {
+        return fs9.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);
-      fs8.utimes(file2, mtime, mtime, (err) => {
+      fs9.utimes(file2, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs8.stat(file2, (err2, stat2) => {
+        fs9.stat(file2, (err2, stat2) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat2.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs8, cacheSymbol, { value: precision });
+          Object.defineProperty(fs9, 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 path18 = require("path");
-    var fs8 = require_graceful_fs();
+    var path19 = require("path");
+    var fs9 = 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, path18.resolve(file2));
+        return callback(null, path19.resolve(file2));
       }
       options.fs.realpath(file2, callback);
     }
@@ -9052,7 +9052,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs8,
+        fs: fs9,
         onCompromised: (err) => {
           throw err;
         },
@@ -9096,7 +9096,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file2, options, callback) {
       options = {
-        fs: fs8,
+        fs: fs9,
         realpath: true,
         ...options
       };
@@ -9118,7 +9118,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs8,
+        fs: fs9,
         ...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 fs8 = require_graceful_fs();
-    function createSyncFs(fs9) {
+    var fs9 = require_graceful_fs();
+    function createSyncFs(fs10) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs9 };
+      const newFs = { ...fs10 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs9[`${method}Sync`](...args);
+            ret = fs10[`${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 || fs8);
+      options.fs = createSyncFs(options.fs || fs9);
       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 path18 = dijkstra.find_path(graph.map, "start", "end");
+      const path19 = dijkstra.find_path(graph.map, "start", "end");
       const optimizedSegs = [];
-      for (let i = 1; i < path18.length - 1; i++) {
-        optimizedSegs.push(graph.table[path18[i]].node);
+      for (let i = 1; i < path19.length - 1; i++) {
+        optimizedSegs.push(graph.table[path19[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 fs8 = require("fs");
+    var fs9 = 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(path18, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path19, 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 = fs8.createWriteStream(path18);
+      const stream = fs9.createWriteStream(path19);
       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(path18, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path19, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs8 = require("fs");
+      const fs9 = require("fs");
       const utf8 = exports2.render(qrData, options);
-      fs8.writeFile(path18, utf8, cb);
+      fs9.writeFile(path19, utf8, cb);
     };
   }
 });
@@ -13476,7 +13476,7 @@ var require_svg_tag = __commonJS({
       return str;
     }
     function qrToPath(data, size, margin) {
-      let path18 = "";
+      let path19 = "";
       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])) {
-            path18 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+            path19 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
             moveBy = 0;
             newRow = false;
           }
           if (!(col + 1 < size && data[i + 1])) {
-            path18 += svgCmd("h", lineLength);
+            path19 += svgCmd("h", lineLength);
             lineLength = 0;
           }
         } else {
           moveBy++;
         }
       }
-      return path18;
+      return path19;
     }
     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 path18 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+      const path19 = "<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 + path18 + "</svg>\n";
+      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path19 + "</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(path18, qrData, options, cb) {
+    exports2.renderToFile = function renderToFile(path19, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs8 = require("fs");
+      const fs9 = 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;
-      fs8.writeFile(path18, xmlStr, cb);
+      fs9.writeFile(path19, xmlStr, cb);
     };
   }
 });
@@ -13690,8 +13690,8 @@ var require_server = __commonJS({
         cb
       };
     }
-    function getTypeFromFilename(path18) {
-      return path18.slice((path18.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
+    function getTypeFromFilename(path19) {
+      return path19.slice((path19.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(path18, text, opts, cb) {
-      if (typeof path18 !== "string" || !(typeof text === "string" || typeof text === "object")) {
+    exports2.toFile = function toFile(path19, text, opts, cb) {
+      if (typeof path19 !== "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(path18);
+      const type = params.opts.type || getTypeFromFilename(path19);
       const renderer = getRendererFromType(type);
-      const renderToFile = renderer.renderToFile.bind(null, path18);
+      const renderToFile = renderer.renderToFile.bind(null, path19);
       return render(renderToFile, text, params);
     };
     exports2.toFileStream = function toFileStream(stream, text, opts) {
@@ -16983,8 +16983,8 @@ var require_utils3 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path18) {
-      let input = path18;
+    function removeDotSegments(path19) {
+      let input = path19;
       const output3 = [];
       let nextSlash = -1;
       let len = 0;
@@ -17236,8 +17236,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path18, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path18 && path18 !== "/" ? path18 : void 0;
+        const [path19, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path19 && path19 !== "/" ? path19 : 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, fs8, exportName) {
+    function addFormats(ajv, list, fs9, 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, fs8[f]);
+        ajv.addFormat(f, fs9[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -20644,11 +20644,11 @@ var require_dist = __commonJS({
 });
 
 // src/bin.ts
-var import_node_path22 = __toESM(require("node:path"), 1);
-var import_node_child_process13 = require("node:child_process");
-var import_node_fs15 = require("node:fs");
-var import_node_os12 = require("node:os");
 var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_child_process13 = require("node:child_process");
+var import_node_fs16 = require("node:fs");
+var import_node_os13 = require("node:os");
+var import_node_path24 = __toESM(require("node:path"), 1);
 
 // src/install-codex.ts
 var import_promises = __toESM(require("node:fs/promises"), 1);
@@ -21153,12 +21153,12 @@ ${block}`;
 }
 
 // src/director-bridge.ts
-var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_fs14 = __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_path17 = __toESM(require("node:path"), 1);
+var import_node_os9 = __toESM(require("node:os"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var import_node_child_process10 = require("node:child_process");
-var import_node_crypto7 = __toESM(require("node:crypto"), 1);
+var import_node_crypto8 = __toESM(require("node:crypto"), 1);
 
 // src/turn-replay-buffer.ts
 var DEFAULT_MAX_EVENTS = 2e3;
@@ -22713,10 +22713,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -23125,11 +23125,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -23276,16 +23276,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path18 = []) => {
+  const processError = (error52, path19 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -23312,17 +23312,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path18 = []) => {
+  const processError = (error52, path19 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -23354,8 +23354,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -36047,13 +36047,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -36499,6 +36499,7 @@ var openApiOperationIds = {
   deleteTaskDependency: "deleteTaskDependency",
   getExecutionRun: "getExecutionRun",
   getProjectSchedulerPolicy: "getProjectSchedulerPolicy",
+  getProjectDeployWorkflow: "getProjectDeployWorkflow",
   getSchedulerPendingTasks: "getSchedulerPendingTasks",
   wakeDirector: "wakeDirector",
   getGithubInstallationRepositories: "getGithubInstallationRepositories",
@@ -36530,6 +36531,7 @@ var openApiOperationIds = {
   searchKnowledge: "searchKnowledge",
   updateExecutionRun: "updateExecutionRun",
   upsertProjectSchedulerPolicy: "upsertProjectSchedulerPolicy",
+  upsertProjectDeployWorkflow: "upsertProjectDeployWorkflow",
   updatePlan: "updatePlan",
   updateTask: "updateTask",
   updateWikiPage: "updateWikiPage",
@@ -36807,7 +36809,8 @@ var mrrlinExecutionRunStatusSchema = external_exports.enum([
   "done",
   "failed",
   "handoff_requested",
-  "handoff_queued"
+  "handoff_queued",
+  "cancelled"
 ]);
 var mrrlinExecutionArtifactKindSchema = external_exports.enum([
   "plan",
@@ -37045,7 +37048,11 @@ var mrrlinProjectSnapshotSchema = external_exports.object({
   wikiPages: external_exports.array(mrrlinWikiPageSchema).default([])
 });
 var mrrlinTaskCreateSchema = external_exports.object({
-  autoDeploy: mrrlinAutoDeploySchema.default("off"),
+  // Auto-deploy design Part B: input-optional (NOT .default("off")) so createTask can tell
+  // "caller omitted this" apart from "caller explicitly chose off" -- omitted falls through to
+  // the project's default_auto_deploy; the tasks column itself still defaults to 'off' at the
+  // SQL level for any direct-insert path that bypasses createTask entirely.
+  autoDeploy: mrrlinAutoDeploySchema.optional(),
   // Input-optional so existing createTask call sites need no churn; createTask fills 'code' for the
   // INSERT (the pg column is NOT NULL, so a concrete value is required, not undefined→NULL).
   domain: mrrlinTaskDomainSchema.optional(),
@@ -37639,6 +37646,10 @@ var mrrlinProjectSchedulerPolicySchema = external_exports.object({
   createdAt: external_exports.string().datetime(),
   // Slice 3 Part E: combined per-UTC-day cap on scheduler-enqueued draft/consensus jobs.
   dailyAutonomousJobBudget: external_exports.number().int().nonnegative(),
+  // Auto-deploy design Part B: copied into tasks.autoDeploy at task-creation time when the
+  // caller doesn't specify one. 'prod' is a legal value here (the DB CHECK allows it) but the
+  // Settings UI never offers it as a project default -- only reachable per task.
+  defaultAutoDeploy: mrrlinAutoDeploySchema,
   eligibleAutonomyLevels: external_exports.array(mrrlinAutonomyLevelSchema).min(1),
   // Slice 3 Part E: cap on concurrently active scheduler-created (ER-SCHED-*) runs.
   maxConcurrentAutonomousRuns: external_exports.number().int().nonnegative(),
@@ -37654,6 +37665,7 @@ var mrrlinProjectSchedulerPolicyUpsertSchema = external_exports.object({
   autoSpecApproval: mrrlinAutoSpecApprovalSchema.optional(),
   cadenceSeconds: external_exports.number().int().positive().nullable().optional(),
   dailyAutonomousJobBudget: external_exports.number().int().nonnegative().optional(),
+  defaultAutoDeploy: mrrlinAutoDeploySchema.optional(),
   eligibleAutonomyLevels: external_exports.array(mrrlinAutonomyLevelSchema).min(1).optional(),
   maxConcurrentAutonomousRuns: external_exports.number().int().nonnegative().optional(),
   prodGraceSeconds: external_exports.number().int().nonnegative().optional(),
@@ -37665,6 +37677,38 @@ var mrrlinProjectSchedulerPolicyUpsertSchema = external_exports.object({
 var projectSchedulerPolicyResponseSchema = external_exports.object({
   data: mrrlinProjectSchedulerPolicySchema
 });
+var mrrlinDeployWorkflowEnvSchema = external_exports.enum(["dev", "prod"]);
+var mrrlinDeployWorkflowSourceSchema = external_exports.enum(["agent", "operator"]);
+var mrrlinDeployWorkflowStateSchema = external_exports.enum(["resolved", "ambiguous"]);
+var mrrlinProjectDeployWorkflowSchema = external_exports.object({
+  projectSlug: mrrlinProjectSlugSchema,
+  env: mrrlinDeployWorkflowEnvSchema,
+  workflowId: external_exports.number().int().positive().nullable(),
+  workflowPath: external_exports.string().nullable(),
+  reason: external_exports.string().nullable(),
+  source: mrrlinDeployWorkflowSourceSchema.nullable(),
+  state: mrrlinDeployWorkflowStateSchema,
+  activeSetFingerprint: external_exports.string().nullable(),
+  reverifyRequested: external_exports.boolean(),
+  resolvedAt: external_exports.string().datetime().nullable(),
+  createdAt: external_exports.string().datetime(),
+  updatedAt: external_exports.string().datetime()
+});
+var mrrlinProjectDeployWorkflowUpsertSchema = external_exports.object({
+  workflowId: external_exports.number().int().positive().nullable(),
+  workflowPath: external_exports.string().nullable().optional(),
+  reason: external_exports.string().nullable().optional(),
+  state: mrrlinDeployWorkflowStateSchema.optional(),
+  activeSetFingerprint: external_exports.string().nullable().optional(),
+  reverifyRequested: external_exports.boolean().optional()
+}).refine((value) => (value.state ?? "resolved") !== "resolved" || value.workflowId !== null, {
+  message: "A resolved deploy-workflow row requires a non-null workflowId."
+}).refine((value) => (value.state ?? "resolved") !== "ambiguous" || value.workflowId === null, {
+  message: "An ambiguous deploy-workflow row must not carry a workflowId."
+});
+var projectDeployWorkflowResponseSchema = external_exports.object({
+  data: mrrlinProjectDeployWorkflowSchema
+});
 var mrrlinSchedulerPendingReasonSchema = external_exports.enum([
   "follow_up_due",
   "verification_due",
@@ -38055,18 +38099,18 @@ function createMrrlinClient(config2) {
   const customFetch = config2.fetch ?? globalThis.fetch;
   const baseUrl = config2.baseUrl.replace(/\/$/, "");
   const token = config2.token;
-  async function request(path18, init) {
+  async function request(path19, 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}${path18}`, { ...init, headers });
+    const response = await customFetch(`${baseUrl}${path19}`, { ...init, headers });
     if (!response.ok) {
       const body = await response.text();
       let code = `HTTP_${response.status}`;
       let violations = null;
-      let message = `Mrrlin API ${method} ${path18} failed: ${response.status}`;
+      let message = `Mrrlin API ${method} ${path19} failed: ${response.status}`;
       try {
         const parsed = JSON.parse(body);
         const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
@@ -38086,7 +38130,7 @@ function createMrrlinClient(config2) {
       throw new MrrlinApiError({
         code,
         method,
-        path: path18,
+        path: path19,
         responseBody: body,
         status: response.status,
         violations,
@@ -38341,7 +38385,7 @@ function createMrrlinClient(config2) {
       return taskEventListResponseSchema.parse(body).data;
     },
     async listTasks(projectSlug, filters = {}) {
-      const path18 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
+      const path19 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
         assignee: filters.assignee,
         autonomyLevel: filters.autonomyLevel,
         blockedBy: filters.blockedBy,
@@ -38353,7 +38397,7 @@ function createMrrlinClient(config2) {
         subcategory: filters.subcategory,
         type: filters.type
       });
-      const body = await request(path18);
+      const body = await request(path19);
       return taskListResponseSchema.parse(body).data;
     },
     async listTaxonomy(projectSlug) {
@@ -38361,22 +38405,22 @@ function createMrrlinClient(config2) {
       return taxonomyListResponseSchema.parse(body).data;
     },
     async listWikiPages(projectSlug, filters = {}) {
-      const path18 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
+      const path19 = appendQuery(`${projectPath(projectSlug)}/wiki`, {
         folder: filters.folder,
         q: filters.q,
         taskId: filters.taskId
       });
-      const body = await request(path18);
+      const body = await request(path19);
       return wikiPageListResponseSchema.parse(body).data;
     },
     async searchWikiPages(projectSlug, query) {
-      const path18 = appendQuery(`${projectPath(projectSlug)}/wiki/search`, {
+      const path19 = 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(path18);
+      const body = await request(path19);
       return wikiPageSearchResponseSchema.parse(body).data;
     },
     async updatePlan(projectSlug, planId, patch) {
@@ -38721,6 +38765,25 @@ function createMrrlinClient(config2) {
       });
       return projectSchedulerPolicyResponseSchema.parse(body).data;
     },
+    async getProjectDeployWorkflow(projectSlug, env) {
+      try {
+        const body = await request(`${projectPath(projectSlug)}/deploy-workflows/${env}`);
+        return projectDeployWorkflowResponseSchema.parse(body).data;
+      } catch (error51) {
+        if (error51 instanceof MrrlinApiError && error51.status === 404 && error51.code === "DEPLOY_WORKFLOW_UNSET") {
+          return null;
+        }
+        throw error51;
+      }
+    },
+    async upsertProjectDeployWorkflow(projectSlug, env, input) {
+      const body = await request(`${projectPath(projectSlug)}/deploy-workflows/${env}`, {
+        body: JSON.stringify(input),
+        headers: { "content-type": "application/json" },
+        method: "PUT"
+      });
+      return projectDeployWorkflowResponseSchema.parse(body).data;
+    },
     async getSchedulerPendingTasks(projectSlug) {
       const body = await request(`${projectPath(projectSlug)}/scheduler/pending`);
       return schedulerPendingTasksResponseSchema.parse(body).data;
@@ -39259,7 +39322,7 @@ function startCodexProbe(deps = {}) {
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.51";
+var PKG_VERSION = "0.3.54";
 
 // src/api-base-url-migrate.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
@@ -39789,9 +39852,6 @@ function startSchedulerTickLoop(deps) {
   };
 }
 
-// src/agent-pool-loop.ts
-var import_node_child_process5 = require("node:child_process");
-
 // src/agent-pool-snapshot.ts
 function normalizeLastUsedAt(value) {
   if (value === void 0 || value === null) return null;
@@ -39904,6 +39964,9 @@ async function collectAgentPoolSnapshot(deps) {
   );
 }
 
+// src/external-agents-spawn.ts
+var import_node_child_process5 = require("node:child_process");
+
 // src/external-agents-bin.ts
 function resolveExternalAgentsCliInvocation(override) {
   if (override && override.trim()) return { command: override, prefixArgs: [] };
@@ -39917,50 +39980,113 @@ function resolveExternalAgentsCliInvocation(override) {
   }
 }
 
-// src/agent-pool-loop.ts
-var DEFAULT_INTERVAL_MS2 = 6e4;
-function agentPoolLoopDisabled(env = process.env) {
-  return env["MRRLIN_BRIDGE_AGENT_POOL_DISABLE"] === "1";
-}
-function defaultRunCli(args) {
-  const cli = process.env["EXTERNAL_AGENTS_CLI"];
-  const { command, prefixArgs } = cli ? { command: "node", prefixArgs: [cli] } : resolveExternalAgentsCliInvocation();
+// src/external-agents-spawn.ts
+function runExternalAgentsCli(args, opts) {
+  let command;
+  let prefixArgs;
+  let source;
+  let triedPath;
+  if (opts.envCliPath && opts.envCliPath.trim()) {
+    command = "node";
+    prefixArgs = [opts.envCliPath];
+    source = "env";
+    triedPath = opts.envCliPath;
+  } else {
+    ({ command, prefixArgs } = resolveExternalAgentsCliInvocation());
+    source = command === "node" && prefixArgs.length === 1 ? "bundled" : "path";
+    triedPath = source === "bundled" ? prefixArgs[0] ?? "" : "external-agents (PATH)";
+  }
+  const useStdin = opts.stdinValue !== void 0;
+  const stdioConfig = useStdin ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"];
   return new Promise((resolve) => {
     let stdout = "";
+    let stderr = "";
     let settled = false;
+    let timedOut = false;
     const done = (code) => {
       if (!settled) {
         settled = true;
-        resolve({ stdout, code });
+        resolve({ stdout, stderr, code, timedOut, source, triedPath });
       }
     };
+    let spawned;
     try {
-      const child = (0, import_node_child_process5.spawn)(command, [...prefixArgs, ...args], { stdio: ["ignore", "pipe", "ignore"] });
-      const timer = setTimeout(() => {
+      spawned = (0, import_node_child_process5.spawn)(command, [...prefixArgs, ...args], { stdio: stdioConfig });
+    } catch {
+      done(1);
+      return;
+    }
+    const child = spawned;
+    let sigkillTimer = null;
+    let budgetTimer = null;
+    if (useStdin && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(opts.stdinValue);
+      child.stdin.end();
+    }
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+      if (stdout.length > 2e5) stdout = stdout.slice(-2e5);
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+      if (stderr.length > 2e5) stderr = stderr.slice(-2e5);
+    });
+    budgetTimer = setTimeout(() => {
+      budgetTimer = null;
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      sigkillTimer = setTimeout(() => {
+        sigkillTimer = null;
         try {
           child.kill("SIGKILL");
         } catch {
         }
-        done(1);
-      }, 5e3);
-      timer.unref?.();
-      child.stdout.on("data", (d) => {
-        stdout += d.toString();
-        if (stdout.length > 2e5) stdout = stdout.slice(-2e5);
-      });
-      child.on("error", () => {
-        clearTimeout(timer);
-        done(1);
-      });
-      child.on("close", (code) => {
-        clearTimeout(timer);
-        done(code ?? 1);
-      });
-    } catch {
+      }, 2e3);
+      sigkillTimer.unref?.();
       done(1);
-    }
+    }, opts.budgetMs);
+    budgetTimer.unref?.();
+    child.on("error", () => {
+      if (budgetTimer) {
+        clearTimeout(budgetTimer);
+        budgetTimer = null;
+      }
+      if (sigkillTimer) {
+        clearTimeout(sigkillTimer);
+        sigkillTimer = null;
+      }
+      done(1);
+    });
+    child.on("close", (code) => {
+      if (budgetTimer) {
+        clearTimeout(budgetTimer);
+        budgetTimer = null;
+      }
+      if (sigkillTimer) {
+        clearTimeout(sigkillTimer);
+        sigkillTimer = null;
+      }
+      done(code ?? 1);
+    });
   });
 }
+
+// src/agent-pool-loop.ts
+var DEFAULT_INTERVAL_MS2 = 6e4;
+function agentPoolLoopDisabled(env = process.env) {
+  return env["MRRLIN_BRIDGE_AGENT_POOL_DISABLE"] === "1";
+}
+function defaultRunCli(args) {
+  return runExternalAgentsCli(args, {
+    budgetMs: 5e3,
+    envCliPath: process.env["EXTERNAL_AGENTS_CLI"]
+  }).then(({ stdout, code }) => ({ stdout, code }));
+}
 async function runAgentPoolCycle(deps) {
   try {
     const snapshot = await collectAgentPoolSnapshot({
@@ -39998,7 +40124,7 @@ function startAgentPoolLoop(deps) {
 
 // src/execution-consumer.ts
 var import_node_child_process9 = require("node:child_process");
-var import_node_crypto4 = __toESM(require("node:crypto"), 1);
+var import_node_crypto5 = __toESM(require("node:crypto"), 1);
 var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
 
@@ -40873,8 +40999,117 @@ You revise a deliverable to address the accepted issues so it satisfies the acce
   };
 }
 
-// src/async-tools/draft-spec.ts
+// src/consensus/deliverable-gate-outcome.ts
+function mapDeliverableGateResult(result) {
+  switch (result.outcome) {
+    case "DELIVERABLE_CHANGED_DURING_REVIEW":
+      return {
+        action: "retry",
+        reason: "the deliverable's wiki page changed underneath an in-progress review (DELIVERABLE_CHANGED_DURING_REVIEW)"
+      };
+    case "CONSENSUS_UNAVAILABLE":
+      return {
+        action: "retry",
+        reason: "reviewers were unavailable (provider/quota) during the deliverable review (CONSENSUS_UNAVAILABLE)"
+      };
+    case "CONSENSUS_BLOCKED": {
+      const clarifications = result.clarifications ?? [];
+      if (clarifications.length > 0) {
+        return {
+          action: "questions",
+          clarifications,
+          reason: "reviewers did not converge; unresolved scope/ambiguity/correctness issues were filed as operator questions (CONSENSUS_BLOCKED)"
+        };
+      }
+      return {
+        action: "handoff",
+        reason: "reviewers did not converge and raised no clarification-eligible issues (CONSENSUS_BLOCKED)"
+      };
+    }
+    case "MISSING_ACCEPTANCE_CRITERIA":
+      return {
+        action: "handoff",
+        reason: "the linked spec has no parseable `## Acceptance criteria` checklist (MISSING_ACCEPTANCE_CRITERIA)"
+      };
+    // CONVERGED/SKIPPED (success paths) should never reach this function — both consumers
+    // special-case them first. Degrade to a safe handoff rather than throwing so a future
+    // caller mistake is visible to the operator instead of crashing the run.
+    default:
+      return {
+        action: "handoff",
+        reason: `unexpected outcome routed to mapDeliverableGateResult: ${result.outcome}`
+      };
+  }
+}
+
+// src/consensus/deliverable-gate-questions.ts
 var import_node_crypto3 = require("node:crypto");
+function buildDeliverableQuestionOptions(category) {
+  if (category === "correctness") {
+    return [
+      {
+        label: "Deliverable is correct",
+        description: "The flagged claim is accurate as written; no change needed.",
+        answer: "Confirm the deliverable's content is correct as written; the reviewer's concern does not require a change."
+      },
+      {
+        label: "Deliverable needs correction",
+        description: "The flagged claim is wrong or unsupported; the deliverable needs revision.",
+        answer: "The deliverable is incorrect here and must be revised to fix the flagged claim before it can be accepted."
+      }
+    ];
+  }
+  if (category === "scope") {
+    return [
+      {
+        label: "Coverage is sufficient",
+        description: "The deliverable's current coverage of the acceptance criteria is sufficient as written.",
+        answer: "Accept the deliverable's current scope/coverage as sufficient against the acceptance criteria."
+      },
+      {
+        label: "Coverage is missing",
+        description: "The deliverable is missing required coverage and needs revision to address it.",
+        answer: "The deliverable is missing required coverage and must be revised to address the flagged gap."
+      }
+    ];
+  }
+  return [
+    {
+      label: "Interpretation is fine",
+      description: "The deliverable's current interpretation of the ambiguous point is acceptable as written.",
+      answer: "Accept the deliverable's current interpretation of the ambiguous point as written."
+    },
+    {
+      label: "Needs clarification",
+      description: "The ambiguous point needs to be resolved and the deliverable revised accordingly.",
+      answer: "The deliverable must be revised to resolve the flagged ambiguity explicitly."
+    }
+  ];
+}
+async function fileDeliverableGateQuestions(client, projectSlug, taskId, clarifications) {
+  let filed = 0;
+  for (const clarification of clarifications) {
+    const id = `II-${taskId}-deliverable-gate-${(0, import_node_crypto3.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
+    try {
+      await client.createInboxItem(projectSlug, {
+        id,
+        kind: "question",
+        taskId,
+        body: clarification.question,
+        origin: "gate",
+        questionOptions: buildDeliverableQuestionOptions(clarification.category)
+      });
+      filed += 1;
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      if (/inbox_items_pkey/.test(message)) filed += 1;
+    }
+  }
+  return filed;
+}
+
+// src/async-tools/draft-spec.ts
+var import_node_crypto4 = require("node:crypto");
 var DRAFT_SPEC_TOOL_NAME = "draft_task_spec";
 var SPECS_FOLDER = "Specs";
 var DRAFT_SPEC_TLDR_MAX_CHARS = 300;
@@ -41151,7 +41386,7 @@ function onComplete(outcome, input) {
     };
   }
   const summary = outcome.error;
-  const hash3 = (0, import_node_crypto3.createHash)("sha256").update(summary).digest("hex").slice(0, 10);
+  const hash3 = (0, import_node_crypto4.createHash)("sha256").update(summary).digest("hex").slice(0, 10);
   return {
     kind: "info",
     id: `II-sched-draft-failed-${input.taskId}-${hash3}`,
@@ -41276,6 +41511,17 @@ function gateEnvSequence(autoDeploy) {
   if (autoDeploy === "prod") return ["dev", "prod"];
   return [];
 }
+function effectiveGateEnvSequence(autoDeploy, artifacts) {
+  const policy = gateEnvSequence(autoDeploy);
+  const envs = ["dev", "prod"];
+  const union2 = new Set(policy);
+  for (const env of envs) {
+    if (latestByEnv(artifacts, "deploy_attempt", env, { realAttemptsOnly: true })) {
+      union2.add(env);
+    }
+  }
+  return envs.filter((env) => union2.has(env));
+}
 function deployApprovalItemId(runId, env) {
   return `II-deploy-approve-${env}-${runId}`;
 }
@@ -41343,7 +41589,7 @@ async function resolveProdGrace(deps, projectSlug, run3, task, artifacts) {
     const graceUntil = new Date(nowMs + seconds * 1e3);
     const cancelId = graceCancelItemId(run3.id);
     await deps.client.appendExecutionArtifact(projectSlug, run3.id, {
-      id: `deploy-grace-${run3.id}`,
+      id: `EA-deploy-grace-${run3.id}`,
       kind: "deploy_attempt",
       payload: {
         env: "prod",
@@ -41403,7 +41649,7 @@ async function tryProdAutoRevert(deps, projectSlug, run3, task) {
     const lastGood = await findLastGoodProdAttempt(deps.client, projectSlug, task, run3.id);
     if (!lastGood) return null;
     await deps.client.appendExecutionArtifact(projectSlug, run3.id, {
-      id: `deploy-revert-${run3.id}`,
+      id: `EA-deploy-revert-${run3.id}`,
       kind: "deploy_attempt",
       payload: {
         env: "prod",
@@ -41424,10 +41670,39 @@ async function tryProdAutoRevert(deps, projectSlug, run3, task) {
     return null;
   }
 }
+function computeActiveSetFingerprint(workflows) {
+  return workflows.map((workflow) => `${workflow.id}:${workflow.path}`).sort().join(",");
+}
+async function resolveWorkflowId(deps, projectSlug, run3, env) {
+  const pinned = env === "dev" ? run3.devWorkflowId : run3.prodWorkflowId;
+  if (pinned) return { workflowId: pinned, source: null, resolvedFromStore: false };
+  const row = await deps.client.getProjectDeployWorkflow(projectSlug, env);
+  if (!row || row.state !== "resolved" || row.workflowId === null) {
+    return { workflowId: null, source: null, resolvedFromStore: false };
+  }
+  if (row.source !== "operator") {
+    const liveWorkflows = await deps.client.listGithubWorkflows(projectSlug);
+    const activeWorkflows = liveWorkflows.filter((workflow) => workflow.state === "active");
+    const isLive = activeWorkflows.some((workflow) => String(workflow.id) === String(row.workflowId));
+    if (!isLive) return { workflowId: null, source: null, resolvedFromStore: false };
+    const liveFingerprint = computeActiveSetFingerprint(activeWorkflows);
+    if (!row.reverifyRequested && row.activeSetFingerprint !== null && liveFingerprint !== row.activeSetFingerprint) {
+      await deps.client.upsertProjectDeployWorkflow(projectSlug, env, {
+        workflowId: row.workflowId,
+        workflowPath: row.workflowPath,
+        reason: row.reason,
+        state: row.state,
+        activeSetFingerprint: row.activeSetFingerprint,
+        reverifyRequested: true
+      });
+    }
+  }
+  return { workflowId: row.workflowId, source: row.source, resolvedFromStore: true };
+}
 async function runDeployGateTick(deps, projectSlug, run3, task) {
-  const sequence = gateEnvSequence(task.autoDeploy);
-  if (sequence.length === 0) return { kind: "noop", reason: "auto_deploy=off" };
   const artifacts = await deps.client.listExecutionArtifacts(projectSlug, run3.id);
+  const sequence = effectiveGateEnvSequence(task.autoDeploy, artifacts);
+  if (sequence.length === 0) return { kind: "noop", reason: "auto_deploy=off" };
   let activeEnv = null;
   for (const env2 of sequence) {
     const verification = latestByEnv(artifacts, "verification", env2);
@@ -41444,7 +41719,8 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
     return { kind: "done" };
   }
   const env = activeEnv;
-  const workflowId = env === "dev" ? run3.devWorkflowId : run3.prodWorkflowId;
+  const resolution = await resolveWorkflowId(deps, projectSlug, run3, env);
+  const workflowId = resolution.workflowId;
   const attempt = latestByEnv(artifacts, "deploy_attempt", env, { realAttemptsOnly: true });
   if (!attempt) {
     if (await autonomyPaused(deps.client)) {
@@ -41480,7 +41756,7 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
     }
     const dispatchedAt = deps.now().toISOString();
     await deps.client.appendExecutionArtifact(projectSlug, run3.id, {
-      id: `deploy-${env}-${attemptIndex(artifacts, env) + 1}`,
+      id: `EA-deploy-${env}-${attemptIndex(artifacts, env) + 1}`,
       kind: "deploy_attempt",
       payload: { env, workflowId, branch: run3.branch ?? "", dispatchedAt }
     });
@@ -41490,9 +41766,23 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
     try {
       await deps.client.dispatchTaskDeploy(projectSlug, task.id, { env, ref: run3.branch, workflowId: String(workflowId) });
     } catch (error51) {
+      if (resolution.source === "operator") {
+        await deps.handoff(
+          projectSlug,
+          task,
+          run3,
+          `deploy_workflow_operator_choice_stale:${env}:${String(error51).slice(0, 120)}`
+        );
+        return { kind: "handoff", reason: `deploy_workflow_operator_choice_stale:${env}` };
+      }
       await deps.handoff(projectSlug, task, run3, `workflow_dispatch_failed:${env}:${String(error51).slice(0, 120)}`);
       return { kind: "handoff", reason: `workflow_dispatch_failed:${env}` };
     }
+    if (resolution.resolvedFromStore) {
+      await deps.client.updateExecutionRun(projectSlug, run3.id, {
+        [env === "dev" ? "devWorkflowId" : "prodWorkflowId"]: workflowId
+      });
+    }
     return { kind: "dispatched", env };
   }
   const runStatus = await deps.client.getGithubWorkflowRunLatest(projectSlug, {
@@ -41543,7 +41833,7 @@ async function runDeployGateTick(deps, projectSlug, run3, task) {
     run: run3
   });
   await deps.client.appendExecutionArtifact(projectSlug, run3.id, {
-    id: `verification-${env}-${attemptIndex(artifacts, env, "verification") + 1}`,
+    id: `EA-verification-${env}-${attemptIndex(artifacts, env, "verification") + 1}`,
     kind: "verification",
     payload: { env, verdict: verdict.verdict, summary: verdict.summary, turnRef: verdict.turnRef }
   });
@@ -41726,6 +42016,20 @@ async function pushRunBranch(opts, execGit = defaultGitExec) {
   const run3 = () => doPushRunBranch(opts, execGit);
   return opts.alreadyLocked ? run3() : withCheckoutLock(opts.locksDir, opts.slug, run3);
 }
+async function hasCommitsToPush(opts, execGit = defaultGitExec) {
+  const baseEnv = {
+    PATH: process.env.PATH ?? "",
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_CONFIG_GLOBAL: "/dev/null",
+    GIT_CONFIG_SYSTEM: "/dev/null",
+    GIT_CONFIG_NOSYSTEM: "1"
+  };
+  const count2 = execGit(
+    ["-C", opts.worktreePath, "rev-list", "--count", `origin/${opts.defaultBranch}..HEAD`],
+    baseEnv
+  ).trim();
+  return Number(count2) > 0;
+}
 async function doPushRunBranch(opts, execGit) {
   const branch = worktreeBranch(opts.runId);
   const baseEnv = {
@@ -41856,6 +42160,13 @@ var EXECUTION_TURN_BUDGET_PREFIX = "Execution turn exceeded the run wall-clock b
 var EXECUTION_TURN_TIMEOUT_RETRY_CODE = "execution_turn_timeout_retry";
 var EXECUTION_TURN_TIMEOUT_RETRY_SUMMARY = "Execution turn timed out; requeued for one automatic retry.";
 var EXECUTION_TURN_TIMEOUT_RETRY_CURSOR = "execution_turn_timeout_retry:1";
+var DELIVERABLE_GATE_RETRY_CODE = "deliverable_gate_retry";
+var DELIVERABLE_GATE_RETRY_CURSOR_PREFIX = "deliverable_gate_retry:";
+var DELIVERABLE_GATE_RETRY_MAX_ATTEMPTS = 3;
+var DELIVERABLE_GATE_RETRYABLE_REASON_PREFIXES = [
+  "deliverable_gate_deliverable_changed_during_review",
+  "deliverable_gate_consensus_unavailable"
+];
 var AWAITING_MERGE_STATUS_RETRY_DELAYS_MS = [50, 100];
 function readPositiveIntEnv(name, fallback) {
   const raw = (process.env[name] ?? "").trim();
@@ -41887,6 +42198,17 @@ function executionTurnBudgetMessage(budgetMs) {
 function isExecutionTurnTimeoutReason(reason) {
   return reason.startsWith(EXECUTION_TURN_TIMEOUT_PREFIX) || reason.startsWith(EXECUTION_TURN_STALL_PREFIX);
 }
+function isDeliverableGateRetryableReason(reason) {
+  return DELIVERABLE_GATE_RETRYABLE_REASON_PREFIXES.some((prefix) => reason.startsWith(prefix));
+}
+function deliverableGateRetryAttempt(checkpointCursor) {
+  if (!checkpointCursor || !checkpointCursor.startsWith(DELIVERABLE_GATE_RETRY_CURSOR_PREFIX)) return 0;
+  const parsed = Number.parseInt(checkpointCursor.slice(DELIVERABLE_GATE_RETRY_CURSOR_PREFIX.length), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
+}
+function deliverableGateRetryCursor(attempt) {
+  return `${DELIVERABLE_GATE_RETRY_CURSOR_PREFIX}${attempt}`;
+}
 function contextMaxArtifacts() {
   return readPositiveIntEnv("MRRLIN_DIRECTOR_BRIDGE_CONTEXT_MAX_ARTIFACTS", DEFAULT_CONTEXT_MAX_ARTIFACTS);
 }
@@ -41915,8 +42237,10 @@ function buildCompletionTurnPrompt(taskId, currentStatus) {
     "   to the open run if you haven't already.",
     "",
     "If the work is NOT complete \u2014 be honest, do not close incomplete work:",
-    "1. Call update_task with the appropriate status (needs_human, awaiting_verification, etc.)",
-    "   and explain what remains in the notes.",
+    "1. Call update_task with the status that matches why it is not complete, and explain what remains",
+    "   in the notes:",
+    "   - if the code work itself is done and only a PR or merge remains, use status=awaiting_verification;",
+    "   - if you are blocked and need an operator decision before the work can continue, use status=needs_human.",
     "2. Append a handoff_judgement artifact explaining what the operator needs to do.",
     "",
     "You must pick one of these paths \u2014 do not leave the task in_progress."
@@ -41940,6 +42264,9 @@ var BASE_INSTRUCTIONS_PREFIX = [
   "- For a CODE task the run opens a draft PR for you after your turn; opening that PR is NOT",
   "  completion. Do NOT set closed_done for code work \u2014 leave the task open; the run parks at",
   "  `pull_request` (waiting for merge) and the operator merges. Closure happens after merge.",
+  "- Pick the right open status when you stop a CODE task: if the code work itself is done and only a",
+  "  PR or merge remains, leave the task at `awaiting_verification`; if you are blocked and a human",
+  "  must decide before the work can continue, leave it at `needs_human`.",
   "",
   "File artifacts:",
   "- When your output is a file (markdown report, HTML, screenshot), upload it with",
@@ -42014,7 +42341,35 @@ var EXECUTOR_BASE_INSTRUCTIONS = [
   "You MUST verify every delegated result against the actual files and tests before it lands \u2014",
   "pool models are lower-reliability and a wrong delegated edit is YOUR responsibility; never",
   "commit unverified delegated output. If dispatch fails or the pool is unavailable, do the",
-  "work yourself \u2014 never block the run on the pool."
+  "work yourself \u2014 never block the run on the pool.",
+  "",
+  // Auto-deploy design Part C (2026-08-04), C4: the workflow-resolution procedure. Only relevant
+  // when the deploy gate has parked this run on a missing/stale workflow id for one environment —
+  // most turns will never need this. This choice becomes durable project state (record_deploy_workflow
+  // writes project_deploy_workflow), not a per-run decision, so resolve it AT MOST ONCE per
+  // project+environment, only when actually needed (lazy, per env — do not speculatively resolve
+  // prod when only dev was asked for).
+  "If your context shows the deploy gate parked on a missing or stale workflow id for an",
+  "environment, resolve it once with this fail-closed procedure \u2014 do this AT MOST ONCE per",
+  "project+environment; it becomes durable project state, not a per-run choice:",
+  '1. Call `list_github_workflows` and keep only candidates with state: "active". A workflow\'s',
+  "   name is NOT evidence it deploys anything \u2014 e.g. this repo also has `publish` (ships an npm",
+  "   package) and `bootstrap-changelog`; picking by name resemblance can dispatch the wrong thing.",
+  "2. For each active candidate, read its file at `<worktree>/<path>` \u2014 the list API's `path` is",
+  "   already repo-root-relative (e.g. `.github/workflows/deploy.yml`), so do NOT prefix it again",
+  "   with `.github/workflows/`. Require an explicit `workflow_dispatch` trigger \u2014 a workflow you",
+  "   cannot confirm is dispatchable this way is not a candidate.",
+  "3. Require positive evidence from the workflow's own steps that it deploys THIS project \u2014 not",
+  "   just a plausible-sounding name.",
+  "4. Exactly one confirmed candidate \u2192 call `record_deploy_workflow` with that workflowId (state",
+  '   defaults to "resolved") and a one-sentence reason. The server captures its own snapshot of',
+  "   the live active-workflow set at write time \u2014 you do not need to compute or pass one; hand-",
+  "   assembling it yourself would risk a format mismatch against what the deploy gate recomputes",
+  "   later, silently disabling the drift check. Append a `checkpoint` artifact with the same pick",
+  "   + reason so the decision stays auditable.",
+  "5. Zero confirmed candidates, or more than one \u2192 call `record_deploy_workflow` with",
+  '   workflowId: null and state: "ambiguous", and file a clarifying question through the normal',
+  "   inbox question path. Do NOT guess between multiple plausible candidates."
 ].join("\n");
 function artifactKindForEvent(event) {
   switch (event.type) {
@@ -42030,6 +42385,7 @@ function artifactKindForEvent(event) {
   }
 }
 var COMPLETED_TASK_STATUSES = /* @__PURE__ */ new Set(["closed_done"]);
+var CODE_PR_READY_TASK_STATUSES = /* @__PURE__ */ new Set(["closed_done", "awaiting_verification"]);
 var COMPLETION_EVIDENCE_KINDS = /* @__PURE__ */ new Set([
   "checkpoint",
   "test_result",
@@ -42047,11 +42403,11 @@ function isBridgeGeneratedArtifact(artifact) {
   return typeof payload === "object" && payload !== null && "event" in payload;
 }
 function newArtifactId() {
-  return `EA-${import_node_crypto4.default.randomUUID()}`;
+  return `EA-${import_node_crypto5.default.randomUUID()}`;
 }
 var BLAST_RADIUS_FLOOR_PATTERNS = [/^supabase\/migrations\//, /^packages\/db\/src\/schema\.ts$/];
-function isBlastRadiusFloorPath(path18) {
-  return BLAST_RADIUS_FLOOR_PATTERNS.some((re) => re.test(path18));
+function isBlastRadiusFloorPath(path19) {
+  return BLAST_RADIUS_FLOOR_PATTERNS.some((re) => re.test(path19));
 }
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process9.execFile);
 async function defaultListRunDiffPaths(opts) {
@@ -42131,9 +42487,25 @@ async function gatherContext(client, projectSlug, task, openRunId) {
     autonomyEvents
   };
 }
-async function assertRunCompletionReady(deps, projectSlug, taskId, runId) {
+async function deployWorkflowReverifyNotice(client, projectSlug) {
+  const envs = ["dev", "prod"];
+  const flagged = [];
+  for (const env of envs) {
+    try {
+      const row = await client.getProjectDeployWorkflow(projectSlug, env);
+      if (row?.reverifyRequested) flagged.push(env);
+    } catch {
+    }
+  }
+  if (flagged.length === 0) return "";
+  return `
+
+## Deploy workflow re-verification needed
+The GitHub Actions workflow set changed since the deploy workflow was last confirmed for: ${flagged.join(", ")}. Re-run the workflow-resolution procedure (list_github_workflows -> confirm -> record_deploy_workflow) for ${flagged.length === 1 ? "this environment" : "these environments"} if you have a worktree this turn \u2014 this is a hint, not a blocker, so it is fine to skip if unrelated work is more urgent this turn.`;
+}
+async function assertRunCompletionReady(deps, projectSlug, taskId, runId, allowedStatuses) {
   const task = await deps.client.getTask(projectSlug, taskId);
-  if (!COMPLETED_TASK_STATUSES.has(task.status)) {
+  if (!allowedStatuses.has(task.status)) {
     return {
       ok: false,
       reason: `Codex turn completed but task ${task.id} remained in status ${task.status}.`,
@@ -42264,7 +42636,7 @@ async function driveRun(deps, projectSlug, runId) {
   if (!claimed) return;
   if (!claimed.leaseId) {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto4.default.randomUUID()}`,
+      id: `II-${import_node_crypto5.default.randomUUID()}`,
       kind: "handoff",
       taskId: claimed.taskId,
       body: `Execution run ${runId} was claimed but returned no leaseId. This indicates DB/API corruption and requires operator attention.`
@@ -42313,7 +42685,7 @@ async function driveRun(deps, projectSlug, runId) {
   }
   const compactEnabled = (process.env.MRRLIN_MCP_COMPACT_DISABLE ?? "").trim() !== "1";
   const context = await gatherContext(deps.client, projectSlug, task, runId);
-  const bundle = renderContextBundle(
+  let bundle = renderContextBundle(
     compactEnabled ? {
       ...context,
       compact: {
@@ -42322,10 +42694,12 @@ async function driveRun(deps, projectSlug, runId) {
       }
     } : context
   );
+  bundle += await deployWorkflowReverifyNotice(deps.client, projectSlug);
   const checkout = deps.checkoutRegistry?.get(projectSlug) ?? null;
   let sandbox = "read-only";
   let turnCwd = deps.codexCwd ?? null;
   let worktreePath = null;
+  let resolvedDefaultBranch = null;
   let useExecutor = false;
   let codex;
   let disposeCodex = () => {
@@ -42343,13 +42717,14 @@ async function driveRun(deps, projectSlug, runId) {
     try {
       const createWt = deps.createRunWorktree ?? createRunWorktree;
       const getDefaultBranch = deps.getDefaultBranch ?? (async () => "main");
+      resolvedDefaultBranch = await getDefaultBranch(projectSlug);
       worktreePath = await createWt({
         checkout: checkout.path,
         worktreeRoot: deps.worktreeRoot ?? "/tmp/mrrlin-worktrees",
         locksDir: deps.locksDir ?? "/tmp/mrrlin-locks",
         slug: projectSlug,
         runId,
-        defaultBranch: await getDefaultBranch(projectSlug)
+        defaultBranch: resolvedDefaultBranch
       });
       if (!await runHasLease(deps, projectSlug, runId, leaseId)) return;
       await deps.client.updateExecutionRun(projectSlug, runId, {
@@ -42433,7 +42808,8 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
       await failRun(deps, projectSlug, task, runId, leaseId, outcome.error);
       return;
     }
-    let readiness = await assertRunCompletionReady(deps, projectSlug, task.id, runId);
+    const prReadyStatuses = useExecutor ? CODE_PR_READY_TASK_STATUSES : COMPLETED_TASK_STATUSES;
+    let readiness = await assertRunCompletionReady(deps, projectSlug, task.id, runId, prReadyStatuses);
     if (!readiness.ok) {
       const completionBudget = Math.min(completionTurnBudgetMs(), remainingTurnBudgetMs());
       if (isCompletionTurnDisabled() || completionBudget < completionTurnMinBudgetMs()) {
@@ -42466,7 +42842,7 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
         await failRun(deps, projectSlug, readiness.task, runId, leaseId, completionOutcome.error);
         return;
       }
-      readiness = await assertRunCompletionReady(deps, projectSlug, task.id, runId);
+      readiness = await assertRunCompletionReady(deps, projectSlug, task.id, runId, prReadyStatuses);
       if (!readiness.ok) {
         await failRun(deps, projectSlug, readiness.task, runId, leaseId, readiness.reason);
         return;
@@ -42478,6 +42854,19 @@ Continue executing task ${task.id}. Make the next concrete increment of progress
         return;
       }
       if (!await runHasLease(deps, projectSlug, runId, leaseId)) return;
+      const hasCommitsFn = deps.hasCommitsToPush ?? hasCommitsToPush;
+      const defaultBranchForPush = resolvedDefaultBranch ?? "main";
+      if (!await hasCommitsFn({ worktreePath, defaultBranch: defaultBranchForPush })) {
+        await failRun(
+          deps,
+          projectSlug,
+          readiness.task,
+          runId,
+          leaseId,
+          `no_commits_to_push: run ${runId} has no commits on ${worktreeBranch(runId)} ahead of origin/${defaultBranchForPush} \u2014 nothing to push.`
+        );
+        return;
+      }
       let review = null;
       if (deps.selfReviewTurn) {
         review = await deps.selfReviewTurn(codex, worktreePath, readiness.task);
@@ -42788,9 +43177,9 @@ async function driveNonCodeRun(deps, projectSlug, runId, leaseId, task, domain2)
     );
     return;
   }
-  let gateOutcome;
+  let gateResult;
   try {
-    gateOutcome = (await deps.runDeliverableGate({ projectSlug, taskId: task.id, runId, deliverablePageId: pageId })).outcome;
+    gateResult = await deps.runDeliverableGate({ projectSlug, taskId: task.id, runId, deliverablePageId: pageId });
   } catch (error51) {
     await failRun(
       deps,
@@ -42802,14 +43191,19 @@ async function driveNonCodeRun(deps, projectSlug, runId, leaseId, task, domain2)
     );
     return;
   }
-  if (gateOutcome !== "CONVERGED") {
+  if (gateResult.outcome !== "CONVERGED") {
+    const mapped = mapDeliverableGateResult(gateResult);
+    if (mapped.action === "questions") {
+      await fileDeliverableGateQuestions(deps.client, projectSlug, task.id, mapped.clarifications).catch(() => {
+      });
+    }
     await failRun(
       deps,
       projectSlug,
       task,
       runId,
       leaseId,
-      `deliverable_gate_${gateOutcome.toLowerCase()}: the produced deliverable did not pass the acceptance-criteria review (${gateOutcome}).`
+      `deliverable_gate_${gateResult.outcome.toLowerCase()}: ${mapped.reason}`
     );
     return;
   }
@@ -42858,6 +43252,33 @@ async function failRun(deps, projectSlug, task, runId, leaseId, reason) {
     } catch {
     }
   }
+  if (isDeliverableGateRetryableReason(reason)) {
+    const attempt = deliverableGateRetryAttempt(currentRun.checkpointCursor) + 1;
+    if (attempt <= DELIVERABLE_GATE_RETRY_MAX_ATTEMPTS) {
+      try {
+        await deps.client.updateExecutionRun(projectSlug, runId, {
+          status: "pending",
+          leaseId: null,
+          checkpointCursor: deliverableGateRetryCursor(attempt)
+        });
+        await deps.client.appendExecutionArtifact(projectSlug, runId, {
+          id: newArtifactId(),
+          kind: "error",
+          payload: {
+            code: DELIVERABLE_GATE_RETRY_CODE,
+            source: "execution-consumer",
+            attempt,
+            maxAttempts: DELIVERABLE_GATE_RETRY_MAX_ATTEMPTS,
+            reason,
+            summary: `Deliverable review hit a transient outcome; requeued for automatic retry ${attempt}/${DELIVERABLE_GATE_RETRY_MAX_ATTEMPTS}.`
+          }
+        }).catch(() => {
+        });
+        return;
+      } catch {
+      }
+    }
+  }
   try {
     await deps.client.createExecutionRunHandoff(projectSlug, runId, { reason });
   } catch {
@@ -42897,7 +43318,7 @@ async function reconcileTaskAwaitingMerge(deps, projectSlug, task, runId, reason
   }
   try {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto4.default.randomUUID()}`,
+      id: `II-${import_node_crypto5.default.randomUUID()}`,
       kind: "handoff",
       taskId: task.id,
       body: `Task ${task.id} (${task.title}) still needs operator follow-up: ${reason}. Mrrlin could not move the task back to Handoff needed automatically.`
@@ -42932,7 +43353,7 @@ async function notifyOperatorHandoff(deps, projectSlug, task, runId, reason) {
   }
   try {
     await deps.client.createInboxItem(projectSlug, {
-      id: `II-${import_node_crypto4.default.randomUUID()}`,
+      id: `II-${import_node_crypto5.default.randomUUID()}`,
       kind: "handoff",
       taskId: task.id,
       body: `Execution run ${runId} for task ${task.id} (${task.title}) needs operator attention: ${reason}`
@@ -43021,7 +43442,7 @@ async function deployGateHandoff(deps, projectSlug, task, runId, reason, leaseId
   }).catch(() => {
   });
   await deps.client.createInboxItem(projectSlug, {
-    id: `II-${import_node_crypto4.default.randomUUID()}`,
+    id: `II-${import_node_crypto5.default.randomUUID()}`,
     kind: "handoff",
     taskId: task.id,
     body: `Deploy gate for run ${runId} (task ${task.id} \u2014 ${task.title}) needs operator attention: ${reason}`
@@ -43037,7 +43458,7 @@ function claimIntervalMs() {
 }
 
 // src/async-job-consumer.ts
-var import_node_crypto5 = __toESM(require("node:crypto"), 1);
+var import_node_crypto6 = __toESM(require("node:crypto"), 1);
 
 // src/async-tools/registry.ts
 var registry2 = /* @__PURE__ */ new Map();
@@ -43121,7 +43542,7 @@ async function driveAsyncJob(deps, projectSlug, jobId) {
   const delivery = descriptor2.onComplete(outcome, input);
   if (!delivery.suppressInbox) {
     await deps.client.createInboxItem(projectSlug, {
-      id: delivery.id ?? `II-${import_node_crypto5.default.randomUUID()}`,
+      id: delivery.id ?? `II-${import_node_crypto6.default.randomUUID()}`,
       kind: delivery.kind,
       body: delivery.body,
       ...delivery.taskId ? { taskId: delivery.taskId } : {}
@@ -43134,13 +43555,13 @@ async function deriveRequestedHash(client, toolName, input) {
   if (input.requestedHash) return input.requestedHash;
   if (toolName === "run_spec_consensus" && input.pageId) {
     const page = await client.getWikiPage(input.projectSlug, input.pageId);
-    return page.contentHash ?? import_node_crypto5.default.createHash("sha256").update(page.markdownBody).digest("hex");
+    return page.contentHash ?? import_node_crypto6.default.createHash("sha256").update(page.markdownBody).digest("hex");
   }
   if (toolName === "draft_task_spec" && input.taskId) {
     const task = await client.getTask(input.projectSlug, input.taskId);
-    return task.updatedAt ?? import_node_crypto5.default.createHash("sha256").update(JSON.stringify(task)).digest("hex");
+    return task.updatedAt ?? import_node_crypto6.default.createHash("sha256").update(JSON.stringify(task)).digest("hex");
   }
-  return import_node_crypto5.default.createHash("sha256").update(JSON.stringify(input)).digest("hex");
+  return import_node_crypto6.default.createHash("sha256").update(JSON.stringify(input)).digest("hex");
 }
 async function runAsyncBackstopSweep(deps, drive = (slug, jobId) => driveAsyncJob(deps, slug, jobId)) {
   const projects = await deps.client.listProjects();
@@ -43381,6 +43802,15 @@ async function runDeliverableGate(_target, deps) {
     rounds: result.rounds,
     contentHash: currentHash
   });
+  if (result.outcome === "CONSENSUS_BLOCKED") {
+    const accepted = result.history.at(-1)?.accepted ?? [];
+    const clarifications = accepted.filter((issue2) => issue2.category === "scope" || issue2.category === "ambiguity" || issue2.category === "correctness").map((issue2) => ({
+      question: issue2.text,
+      whyBlocking: `reviewer raised a ${issue2.category} issue`,
+      category: issue2.category
+    }));
+    return clarifications.length > 0 ? { outcome: "CONSENSUS_BLOCKED", rounds: result.rounds, clarifications } : { outcome: "CONSENSUS_BLOCKED", rounds: result.rounds };
+  }
   return { outcome: result.outcome, rounds: result.rounds };
 }
 
@@ -43629,7 +44059,7 @@ function chatTurnMaxMs() {
 }
 
 // src/worker-token.ts
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_node_fs9 = require("node:fs");
 var import_node_os6 = __toESM(require("node:os"), 1);
 var import_node_path13 = __toESM(require("node:path"), 1);
@@ -43660,7 +44090,7 @@ function readOrCreateWorkerToken() {
   if (existing) return existing;
   const dir = workerDir();
   (0, import_node_fs9.mkdirSync)(dir, { recursive: true, mode: 448 });
-  const token = (0, import_node_crypto6.randomBytes)(32).toString("hex");
+  const token = (0, import_node_crypto7.randomBytes)(32).toString("hex");
   (0, import_node_fs9.writeFileSync)(workerTokenPath(), `${token}
 `, { encoding: "utf8", mode: 384 });
   return token;
@@ -47241,9 +47671,9 @@ var DirectorRelay = class {
 
 // src/remote-phone-relay.ts
 function loadOrCreateAgentDeviceKey() {
-  const path18 = (0, import_node_path14.join)((0, import_node_os7.homedir)(), ".mrrlin", "agent-device-key");
+  const path19 = (0, import_node_path14.join)((0, import_node_os7.homedir)(), ".mrrlin", "agent-device-key");
   try {
-    const raw = JSON.parse((0, import_node_fs10.readFileSync)(path18, "utf8"));
+    const raw = JSON.parse((0, import_node_fs10.readFileSync)(path19, "utf8"));
     if (typeof raw.priv === "string" && typeof raw.pub === "string") {
       return { privateKey: fromBase64Url(raw.priv), publicKey: fromBase64Url(raw.pub) };
     }
@@ -47253,7 +47683,7 @@ function loadOrCreateAgentDeviceKey() {
   try {
     (0, import_node_fs10.mkdirSync)((0, import_node_path14.join)((0, import_node_os7.homedir)(), ".mrrlin"), { recursive: true });
     (0, import_node_fs10.writeFileSync)(
-      path18,
+      path19,
       JSON.stringify({ priv: toBase64Url(kp.privateKey), pub: toBase64Url(kp.publicKey) }),
       { mode: 384 }
     );
@@ -47476,9 +47906,9 @@ var CheckoutRegistry = class {
   get(slug) {
     return this.read()[slug] ?? null;
   }
-  confirm(slug, path18, now) {
+  confirm(slug, path19, now) {
     const all = this.read();
-    all[slug] = { path: path18, confirmedAt: now };
+    all[slug] = { path: path19, confirmedAt: now };
     (0, import_node_fs11.writeFileSync)(this.file, JSON.stringify(all, null, 2));
   }
 };
@@ -47807,6 +48237,362 @@ function createBridgeLogger(stateDir, env = process.env) {
   };
 }
 
+// src/external-agents-scrub.ts
+var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
+var REDACTION = "[REDACTED]";
+var SHORT_VALUE_THRESHOLD = 8;
+var KEYS_ENV_PATH = () => import_node_path17.default.join(import_node_os8.default.homedir(), ".local", "state", "external-agents", "keys.env");
+var keysEnvCache = null;
+function readKeysEnv() {
+  const filePath = KEYS_ENV_PATH();
+  let mtimeMs = 0;
+  try {
+    mtimeMs = import_node_fs13.default.statSync(filePath).mtimeMs;
+  } catch {
+    mtimeMs = 0;
+  }
+  if (keysEnvCache && keysEnvCache.mtimeMs === mtimeMs) {
+    return keysEnvCache.map;
+  }
+  const map2 = /* @__PURE__ */ new Map();
+  try {
+    const content = import_node_fs13.default.readFileSync(filePath, "utf8");
+    for (const rawLine of content.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (line === "" || line.startsWith("#")) continue;
+      const eq = line.indexOf("=");
+      if (eq === -1) continue;
+      const key = line.slice(0, eq).trim();
+      const value = line.slice(eq + 1);
+      if (key === "") continue;
+      map2.set(key, value);
+    }
+  } catch {
+  }
+  keysEnvCache = { mtimeMs, map: map2 };
+  return map2;
+}
+function buildScrubSet(opts) {
+  const result = /* @__PURE__ */ new Set();
+  const fileMap = readKeysEnv();
+  for (const name of opts.registryEnvNames) {
+    const fromFile = fileMap.get(name);
+    if (fromFile !== void 0 && fromFile !== "") {
+      result.add(fromFile);
+    }
+    const fromEnv = process.env[name];
+    if (fromEnv !== void 0 && fromEnv !== "") {
+      result.add(fromEnv);
+    }
+  }
+  for (const value of opts.inFlightValues ?? []) {
+    result.add(value);
+  }
+  return result;
+}
+function escapeRegExp(literal2) {
+  return literal2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function jsonEscapedVariant(value) {
+  const json2 = JSON.stringify(value);
+  return json2.slice(1, -1);
+}
+function percentEncodedVariant(value) {
+  try {
+    return encodeURIComponent(value);
+  } catch {
+    return null;
+  }
+}
+function collectVariants(scrubSet) {
+  const variants = /* @__PURE__ */ new Set();
+  for (const value of scrubSet) {
+    if (value === "") continue;
+    variants.add(value);
+    const jsonForm = jsonEscapedVariant(value);
+    if (jsonForm !== "") variants.add(jsonForm);
+    const percentForm = percentEncodedVariant(value);
+    if (percentForm !== null && percentForm !== "") variants.add(percentForm);
+  }
+  return [...variants];
+}
+function buildScrubRegex(scrubSet) {
+  const variants = collectVariants(scrubSet);
+  if (variants.length === 0) return null;
+  variants.sort((a, b) => b.length - a.length);
+  const alternatives = variants.map((variant) => {
+    const escaped = escapeRegExp(variant);
+    if (variant.length >= SHORT_VALUE_THRESHOLD) {
+      return escaped;
+    }
+    return `(?<![A-Za-z0-9_])${escaped}(?![A-Za-z0-9_])`;
+  });
+  return new RegExp(alternatives.join("|"), "g");
+}
+function scrubString(input, regex) {
+  return input.replace(regex, REDACTION);
+}
+function isPlainObject3(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function scrubValue(value, regex) {
+  if (typeof value === "string") {
+    return regex === null ? value : scrubString(value, regex);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => scrubValue(item, regex));
+  }
+  if (isPlainObject3(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = scrubValue(child, regex);
+    }
+    return out;
+  }
+  return value;
+}
+function scrubDeep(value, scrubSet) {
+  const regex = buildScrubRegex(scrubSet);
+  return scrubValue(value, regex);
+}
+
+// src/external-agents-handlers.ts
+var BUDGET_STATE_MS = 1e4;
+var BUDGET_PROBE_MS = 6e4;
+var BUDGET_AUDIT_MS = 18e4;
+var BUDGET_TOGGLE_MS = 1e4;
+var BUDGET_ADD_MODEL_MS = 1e4;
+var BUDGET_SET_CREDENTIAL_MS = 1e4;
+var BUDGET_DISPATCH_MS = 3e5;
+var ENV_NAME_RE = /^[A-Z0-9_]+$/;
+var MAX_PROMPT_LEN = 8192;
+var TOGGLE_MIN_VERSION = "0.34.0";
+function invalidInput(field, reason) {
+  return { ok: false, error: { code: "invalid_input", fields: { [field]: reason } } };
+}
+function tryParseJson(s) {
+  try {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
+}
+function classifyCliFailure(result) {
+  if (result.timedOut) return { code: "timeout" };
+  const stderrLc = result.stderr.toLowerCase();
+  const notFound = stderrLc.includes("command not found") || stderrLc.includes("enoent") || result.code === 1 && result.stdout === "" && result.stderr === "";
+  const error51 = notFound ? { code: "cli_not_found", triedPaths: [result.triedPath] } : { code: "cli_broken" };
+  if (result.stderr) error51.detail = result.stderr;
+  return error51;
+}
+function finalizeReply(reply, scrubSet) {
+  return scrubDeep(reply, scrubSet);
+}
+function defaultScrubSet(deps) {
+  return buildScrubSet({ registryEnvNames: deps.registryEnvNames });
+}
+function extractRegistryEnvNames(agents) {
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of agents) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const auth = entry["auth"];
+    if (typeof auth === "string" && auth.startsWith("env:")) {
+      names.add(auth.slice("env:".length));
+    }
+  }
+  return [...names];
+}
+async function handleAgentsState(deps, request) {
+  if (request.since !== void 0) {
+    if (Number.isNaN(new Date(request.since).getTime())) {
+      return finalizeReply(invalidInput("since", "not a valid ISO timestamp"), defaultScrubSet(deps));
+    }
+  }
+  const status = await deps.run(["status", "--json"], { budgetMs: BUDGET_STATE_MS });
+  if (status.code !== 0) {
+    return finalizeReply({ ok: false, error: classifyCliFailure(status) }, defaultScrubSet(deps));
+  }
+  const statusParsed = tryParseJson(status.stdout);
+  if (!statusParsed.ok || !Array.isArray(statusParsed.value)) {
+    return finalizeReply(
+      { ok: false, error: { code: "cli_broken", detail: status.stderr || void 0 } },
+      defaultScrubSet(deps)
+    );
+  }
+  const agents = statusParsed.value;
+  const stateScrubSet = buildScrubSet({
+    registryEnvNames: [...deps.registryEnvNames, ...extractRegistryEnvNames(agents)]
+  });
+  const statsArgs = ["stats", "--json", ...request.since ? ["--since", request.since] : []];
+  const stats = await deps.run(statsArgs, { budgetMs: BUDGET_STATE_MS });
+  let totals = null;
+  if (stats.code === 0) {
+    const statsParsed = tryParseJson(stats.stdout);
+    if (statsParsed.ok) totals = statsParsed.value;
+  }
+  return finalizeReply(
+    { ok: true, data: { agents, totals, cli: { path: null, version: null, source: status.source } } },
+    stateScrubSet
+  );
+}
+async function handleAgentsProbe(deps, request) {
+  const scrubSet = defaultScrubSet(deps);
+  if (deps.lastKnownState === null || !deps.lastKnownState.agentIds.includes(request.id)) {
+    return finalizeReply(invalidInput("id", "unknown agent id"), scrubSet);
+  }
+  const result = await deps.run(["probe", request.id], { budgetMs: BUDGET_PROBE_MS });
+  if (result.code !== 0) {
+    return finalizeReply({ ok: false, error: classifyCliFailure(result) }, scrubSet);
+  }
+  const parsed = tryParseJson(result.stdout);
+  if (!parsed.ok) {
+    return finalizeReply({ ok: false, error: { code: "cli_broken", detail: result.stderr || void 0 } }, scrubSet);
+  }
+  return finalizeReply({ ok: true, data: parsed.value }, scrubSet);
+}
+async function handleAgentsAudit(deps, request) {
+  const scrubSet = defaultScrubSet(deps);
+  if (deps.lastKnownState === null) {
+    return finalizeReply(invalidInput("provider", "call agents-state before agents-audit"), scrubSet);
+  }
+  if (request.provider !== void 0 && !deps.lastKnownState.providers.includes(request.provider)) {
+    return finalizeReply(invalidInput("provider", "unknown provider"), scrubSet);
+  }
+  const auditArgs = ["audit", "--json", ...request.provider ? ["--provider", request.provider] : []];
+  const result = await deps.run(auditArgs, { budgetMs: BUDGET_AUDIT_MS });
+  if (result.code !== 0) {
+    return finalizeReply({ ok: false, error: classifyCliFailure(result) }, scrubSet);
+  }
+  const parsed = tryParseJson(result.stdout);
+  if (!parsed.ok) {
+    return finalizeReply({ ok: false, error: { code: "cli_broken", detail: result.stderr || void 0 } }, scrubSet);
+  }
+  return finalizeReply({ ok: true, data: parsed.value }, scrubSet);
+}
+async function handleAgentsToggle(deps, request) {
+  const scrubSet = defaultScrubSet(deps);
+  if (deps.lastKnownState === null || !deps.lastKnownState.agentIds.includes(request.id)) {
+    return finalizeReply(invalidInput("id", "unknown agent id"), scrubSet);
+  }
+  const result = await deps.run(
+    ["toggle", request.id, request.enabled ? "--enabled" : "--disabled"],
+    { budgetMs: BUDGET_TOGGLE_MS }
+  );
+  if (result.code !== 0) {
+    const stderrLc = result.stderr.toLowerCase();
+    if (stderrLc.includes("unknown subcommand") || stderrLc.includes("unknown command")) {
+      return finalizeReply(
+        {
+          ok: false,
+          error: {
+            code: "cli_outdated",
+            detail: `the toggle control requires external-agents >= ${TOGGLE_MIN_VERSION}`
+          }
+        },
+        scrubSet
+      );
+    }
+    return finalizeReply({ ok: false, error: classifyCliFailure(result) }, scrubSet);
+  }
+  return finalizeReply({ ok: true, data: { id: request.id, enabled: request.enabled } }, scrubSet);
+}
+async function handleAgentsAddModel(deps, request) {
+  const scrubSet = defaultScrubSet(deps);
+  if (!ENV_NAME_RE.test(request.env)) {
+    return finalizeReply(invalidInput("env", "must match /^[A-Z0-9_]+$/"), scrubSet);
+  }
+  try {
+    new URL(request.url);
+  } catch {
+    return finalizeReply(invalidInput("url", "not a valid URL"), scrubSet);
+  }
+  if (deps.lastKnownState === null) {
+    return finalizeReply(invalidInput("id", "call agents-state before agents-add-model"), scrubSet);
+  }
+  if (deps.lastKnownState.agentIds.includes(request.id)) {
+    return finalizeReply(invalidInput("id", "an agent with this id already exists"), scrubSet);
+  }
+  const args = [
+    "add-model",
+    "--id",
+    request.id,
+    "--provider",
+    request.provider,
+    "--url",
+    request.url,
+    "--model",
+    request.model,
+    "--env",
+    request.env,
+    ...request.tier ? ["--tier", request.tier] : [],
+    ...request.tags?.length ? ["--tags", request.tags.join(",")] : []
+  ];
+  const result = await deps.run(args, { budgetMs: BUDGET_ADD_MODEL_MS });
+  if (result.code !== 0) {
+    return finalizeReply({ ok: false, error: classifyCliFailure(result) }, scrubSet);
+  }
+  return finalizeReply({ ok: true, data: { id: request.id } }, scrubSet);
+}
+async function handleAgentsSetCredential(deps, request) {
+  const scrubSet = buildScrubSet({
+    registryEnvNames: deps.registryEnvNames,
+    inFlightValues: [request.value]
+  });
+  if (deps.lastKnownState === null) {
+    return finalizeReply(invalidInput("env", "call agents-state before agents-set-credential"), scrubSet);
+  }
+  if (!ENV_NAME_RE.test(request.env)) {
+    return finalizeReply(invalidInput("env", "must match /^[A-Z0-9_]+$/"), scrubSet);
+  }
+  if (request.value === "") {
+    return finalizeReply(invalidInput("value", "must not be empty"), scrubSet);
+  }
+  const result = await deps.run(["set-credential", request.env, "-"], {
+    stdinValue: request.value,
+    budgetMs: BUDGET_SET_CREDENTIAL_MS
+  });
+  if (result.code !== 0) {
+    return finalizeReply({ ok: false, error: classifyCliFailure(result) }, scrubSet);
+  }
+  return finalizeReply({ ok: true, data: { env: request.env } }, scrubSet);
+}
+var DISPATCH_ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "prompt", "transport", "effort"]);
+async function handleAgentsDispatch(deps, request) {
+  const scrubSet = defaultScrubSet(deps);
+  for (const key of Object.keys(request)) {
+    if (!DISPATCH_ALLOWED_KEYS.has(key)) {
+      return finalizeReply(invalidInput(key, "unexpected field"), scrubSet);
+    }
+  }
+  if (deps.lastKnownState === null || !deps.lastKnownState.agentIds.includes(request.id)) {
+    return finalizeReply(invalidInput("id", "unknown agent id"), scrubSet);
+  }
+  if (request.prompt.length > MAX_PROMPT_LEN) {
+    return finalizeReply(invalidInput("prompt", `must be at most ${MAX_PROMPT_LEN} characters`), scrubSet);
+  }
+  const args = [
+    "dispatch",
+    request.id,
+    "--json",
+    ...request.transport ? ["--transport", request.transport] : [],
+    ...request.effort ? ["--effort", request.effort] : [],
+    request.prompt
+  ];
+  const result = await deps.run(args, { budgetMs: BUDGET_DISPATCH_MS });
+  if (result.code !== 0) {
+    return finalizeReply({ ok: false, error: classifyCliFailure(result) }, scrubSet);
+  }
+  const parsed = tryParseJson(result.stdout);
+  if (!parsed.ok) {
+    return finalizeReply({ ok: false, error: { code: "cli_broken", detail: result.stderr || void 0 } }, scrubSet);
+  }
+  return finalizeReply({ ok: true, data: parsed.value }, scrubSet);
+}
+
 // src/director-bridge.ts
 var JSON_GPT_MODEL_REF_RE = /"(?:slug|model)"\s*:\s*"(gpt-[a-z0-9.-]+)"/gi;
 var DEFAULT_DIRECTOR_BRIDGE_ALLOWED_ORIGINS = [
@@ -47864,7 +48650,7 @@ function addBridgeModel(target, model) {
 }
 function readTextIfExists(filePath) {
   try {
-    return import_node_fs13.default.readFileSync(filePath, "utf8");
+    return import_node_fs14.default.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -47875,9 +48661,9 @@ function readKnownGptSlugsFromTomlFile(filePath) {
   return Array.from(raw.matchAll(/^\s*model\s*=\s*"([^"]+)"/gm)).map((match) => match[1]?.trim() ?? "").filter(isSelectableModelSlug);
 }
 function readCodexFallbackModels() {
-  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path17.default.join(import_node_os8.default.homedir(), ".codex");
+  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path18.default.join(import_node_os9.default.homedir(), ".codex");
   const models = /* @__PURE__ */ new Map();
-  const cachePath = import_node_path17.default.join(codexHome, "models_cache.json");
+  const cachePath = import_node_path18.default.join(codexHome, "models_cache.json");
   const cacheRaw = readTextIfExists(cachePath);
   if (cacheRaw) {
     try {
@@ -47927,7 +48713,7 @@ function readCodexFallbackModels() {
       );
     }
   }
-  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path17.default.join(codexHome, "config.toml"))) {
+  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path18.default.join(codexHome, "config.toml"))) {
     addBridgeModel(
       models,
       mapBridgeModel({
@@ -47941,11 +48727,11 @@ function readCodexFallbackModels() {
       })
     );
   }
-  const automationsDir = import_node_path17.default.join(codexHome, "automations");
+  const automationsDir = import_node_path18.default.join(codexHome, "automations");
   try {
-    for (const entry of import_node_fs13.default.readdirSync(automationsDir, { withFileTypes: true })) {
+    for (const entry of import_node_fs14.default.readdirSync(automationsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path17.default.join(automationsDir, entry.name, "automation.toml"))) {
+      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path18.default.join(automationsDir, entry.name, "automation.toml"))) {
         addBridgeModel(
           models,
           mapBridgeModel({
@@ -47965,9 +48751,9 @@ function readCodexFallbackModels() {
   return [...models.values()];
 }
 function neutralCheckoutCwd(stateDir) {
-  const dir = import_node_path17.default.join(stateDir, "no-checkout");
+  const dir = import_node_path18.default.join(stateDir, "no-checkout");
   try {
-    import_node_fs13.default.mkdirSync(dir, { recursive: true });
+    import_node_fs14.default.mkdirSync(dir, { recursive: true });
   } catch {
   }
   return dir;
@@ -47986,6 +48772,27 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "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`.",
     "",
+    "Turn lifecycle \u2014 what you can and cannot do between turns:",
+    "- Your turn ends the moment you stop producing output. You CANNOT start a new turn yourself:",
+    "  no timer and no scheduler wakes you up. Only a new operator message starts the next turn.",
+    '- Therefore NEVER end a reply with a promise to keep working \u2014 no "continuing to the next one',
+    `  automatically", "I'll proceed now", "working on it", in ANY language. If you say it and then`,
+    "  stop, the work silently never happens and the operator waits forever for a reply that will",
+    "  never come.",
+    "- When the operator hands you a batch (several links, tasks, or pages), process EVERY item in",
+    "  the SAME turn: keep calling tools item by item, then report all results together at the end.",
+    "- A turn is bounded (~30 minutes of wall clock, and a finite reply size), so never open-endedly",
+    "  commit to a huge batch. If it holds more than ~8 items, or individual items need heavy",
+    "  fetching or analysis, split it UP FRONT: say how you are splitting it, do the first slice,",
+    "  then ask to continue. Splitting deliberately beats being cut off mid-batch and losing the work.",
+    "- Whenever you stop short of the full batch, stop at a clean boundary and END with an explicit",
+    '  request to continue, naming exactly where you stopped (e.g. "done 2 of 7 \u2014 say `continue`',
+    `  and I'll take 3-7"). An explicit ask is correct; a promise to self-continue is a bug.`,
+    "- Exception: when a tool's OWN instructions say its result will arrive in the inbox (e.g. spec",
+    "  consensus returning `queued`), ending the turn IS correct \u2014 a real asynchronous mechanism",
+    "  delivers that result later. This exception covers ONLY inbox-delivered results; it is never",
+    "  license to end a turn while work you must do yourself is still outstanding.",
+    "",
     "Task description quality contract \u2014 every task you create or update via create_task or update_task:",
     "- Title: short, actionable, human-readable. Describe what needs to happen, not internal jargon.",
     '  Good: "Audit crawled-not-indexed pages and fix 404 errors"',
@@ -48283,7 +49090,7 @@ async function runOrphanWorktreeSweep(client, opts) {
   const cutoff = Date.now() - worktreeRetentionMs();
   const isReapable = (worktreePath) => {
     try {
-      return import_node_fs13.default.statSync(worktreePath).mtimeMs < cutoff;
+      return import_node_fs14.default.statSync(worktreePath).mtimeMs < cutoff;
     } catch {
       return false;
     }
@@ -48321,8 +49128,8 @@ async function runOrphanWorktreeSweep(client, opts) {
   }
 }
 function readStateDir() {
-  if (process.env.CODEX_HOME) return import_node_path17.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
-  return import_node_path17.default.join(import_node_os8.default.homedir(), ".mrrlin", "director-bridge");
+  if (process.env.CODEX_HOME) return import_node_path18.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
+  return import_node_path18.default.join(import_node_os9.default.homedir(), ".mrrlin", "director-bridge");
 }
 function readAllowedOrigins() {
   const raw = (process.env.MRRLIN_DIRECTOR_BRIDGE_ALLOWED_ORIGINS ?? "").trim();
@@ -48397,7 +49204,7 @@ function createBridgeRequestListener(opts) {
         res.end(JSON.stringify({ ok: false, error: "Origin not allowed." }));
         return;
       }
-      const nonce = import_node_crypto7.default.randomBytes(16).toString("base64url");
+      const nonce = import_node_crypto8.default.randomBytes(16).toString("base64url");
       res.writeHead(200, { "content-type": "application/json" });
       res.end(JSON.stringify({ ok: true, wsUrl: `ws://${host}:${port}/ws`, token, nonce }));
       return;
@@ -48521,6 +49328,45 @@ function createBridgeMessageHandler(deps) {
       for (const id of boundSessions) deps.unbindSessionSink?.(id, send);
       boundSessions.clear();
     });
+    let externalAgentsRegistryEnvNames = [];
+    let externalAgentsLastKnownState = null;
+    function deriveLastKnownState(agents) {
+      const agentIds = [];
+      const providers = /* @__PURE__ */ new Set();
+      for (const entry of agents) {
+        if (typeof entry !== "object" || entry === null) continue;
+        const rec = entry;
+        if (typeof rec.id === "string") agentIds.push(rec.id);
+        if (typeof rec.provider === "string") providers.add(rec.provider);
+      }
+      return { agentIds, providers: [...providers] };
+    }
+    async function probeAgentsUsingEnvVar(handlerDeps, envVar) {
+      try {
+        const before = await handleAgentsState(handlerDeps, {});
+        if (!before.ok) return;
+        const matchingIds = before.data.agents.filter((entry) => typeof entry === "object" && entry !== null).filter((entry) => entry.auth === `env:${envVar}`).map((entry) => entry.id).filter((id) => typeof id === "string");
+        const lastKnownState = deriveLastKnownState(before.data.agents);
+        await Promise.all(
+          matchingIds.map((id) => handleAgentsProbe({ ...handlerDeps, lastKnownState }, { id }))
+        );
+      } catch {
+      }
+    }
+    async function withPoolStateReread(handlerDeps, reply) {
+      if (!reply.ok) return reply;
+      try {
+        const reRead = await handleAgentsState(handlerDeps, {});
+        if (reRead.ok) {
+          externalAgentsRegistryEnvNames = extractRegistryEnvNames(reRead.data.agents);
+          externalAgentsLastKnownState = deriveLastKnownState(reRead.data.agents);
+          return { ...reply, poolState: reRead.data };
+        }
+        return { ...reply, poolState: null };
+      } catch {
+        return { ...reply, poolState: null };
+      }
+    }
     function logResumeRejected(sessionId, reason) {
       logCtx?.logger.logOut({
         spanId: logCtx.span.id,
@@ -48635,7 +49481,7 @@ function createBridgeMessageHandler(deps) {
       }
     }
     socket.on("message", async (data) => {
-      const spanId = import_node_crypto7.default.randomUUID();
+      const spanId = import_node_crypto8.default.randomUUID();
       if (logCtx) {
         logCtx.span.id = spanId;
         logCtx.span.at = Date.now();
@@ -48672,7 +49518,10 @@ function createBridgeMessageHandler(deps) {
         spanId,
         sessionId: sid,
         type: typeof msg.type === "string" ? msg.type : "<unknown>",
-        payload: msg
+        // Structural credential removal: the set-credential message carries a raw secret in
+        // `value` that must never reach the structured log. Redact that one field for that one
+        // message type only; every other message's payload is logged unchanged.
+        payload: msg.type === "agents-set-credential" ? { ...msg, value: "[REDACTED]" } : msg
       });
       if (msg.type === "ping") {
         sendForSpan({ type: "pong" });
@@ -48683,6 +49532,142 @@ function createBridgeMessageHandler(deps) {
         sendForSpan({ type: "pairing-qr", ...result });
         return;
       }
+      if (msg.type === "agents-state") {
+        if (!deps.runExternalAgentsCli) {
+          sendForSpan({ type: "agents-state", ok: false, error: { code: "bridge_offline", detail: "external-agents is not configured on this bridge" } });
+          return;
+        }
+        const handlerDeps = {
+          run: deps.runExternalAgentsCli,
+          registryEnvNames: externalAgentsRegistryEnvNames,
+          lastKnownState: externalAgentsLastKnownState
+        };
+        const req = msg;
+        const reply = await handleAgentsState(handlerDeps, req.since !== void 0 ? { since: req.since } : {});
+        if (reply.ok) {
+          externalAgentsRegistryEnvNames = extractRegistryEnvNames(reply.data.agents);
+          externalAgentsLastKnownState = deriveLastKnownState(reply.data.agents);
+        }
+        sendForSpan({ type: "agents-state", ...reply });
+        return;
+      }
+      if (msg.type === "agents-probe") {
+        if (!deps.runExternalAgentsCli) {
+          sendForSpan({ type: "agents-probe", ok: false, error: { code: "bridge_offline", detail: "external-agents is not configured on this bridge" } });
+          return;
+        }
+        const handlerDeps = {
+          run: deps.runExternalAgentsCli,
+          registryEnvNames: externalAgentsRegistryEnvNames,
+          lastKnownState: externalAgentsLastKnownState
+        };
+        const req = msg;
+        const reply = await withPoolStateReread(handlerDeps, await handleAgentsProbe(handlerDeps, { id: req.id }));
+        sendForSpan({ type: "agents-probe", ...reply });
+        return;
+      }
+      if (msg.type === "agents-audit") {
+        if (!deps.runExternalAgentsCli) {
+          sendForSpan({ type: "agents-audit", ok: false, error: { code: "bridge_offline", detail: "external-agents is not configured on this bridge" } });
+          return;
+        }
+        const handlerDeps = {
+          run: deps.runExternalAgentsCli,
+          registryEnvNames: externalAgentsRegistryEnvNames,
+          lastKnownState: externalAgentsLastKnownState
+        };
+        const req = msg;
+        const reply = await withPoolStateReread(
+          handlerDeps,
+          await handleAgentsAudit(handlerDeps, req.provider !== void 0 ? { provider: req.provider } : {})
+        );
+        sendForSpan({ type: "agents-audit", ...reply });
+        return;
+      }
+      if (msg.type === "agents-toggle") {
+        if (!deps.runExternalAgentsCli) {
+          sendForSpan({ type: "agents-toggle", ok: false, error: { code: "bridge_offline", detail: "external-agents is not configured on this bridge" } });
+          return;
+        }
+        const handlerDeps = {
+          run: deps.runExternalAgentsCli,
+          registryEnvNames: externalAgentsRegistryEnvNames,
+          lastKnownState: externalAgentsLastKnownState
+        };
+        const req = msg;
+        const reply = await withPoolStateReread(
+          handlerDeps,
+          await handleAgentsToggle(handlerDeps, { id: req.id, enabled: req.enabled })
+        );
+        sendForSpan({ type: "agents-toggle", ...reply });
+        return;
+      }
+      if (msg.type === "agents-add-model") {
+        if (!deps.runExternalAgentsCli) {
+          sendForSpan({ type: "agents-add-model", ok: false, error: { code: "bridge_offline", detail: "external-agents is not configured on this bridge" } });
+          return;
+        }
+        const handlerDeps = {
+          run: deps.runExternalAgentsCli,
+          registryEnvNames: externalAgentsRegistryEnvNames,
+          lastKnownState: externalAgentsLastKnownState
+        };
+        const req = msg;
+        const reply = await withPoolStateReread(
+          handlerDeps,
+          await handleAgentsAddModel(handlerDeps, {
+            id: req.id,
+            provider: req.provider,
+            model: req.model,
+            url: req.url,
+            env: req.env,
+            ...req.tier !== void 0 ? { tier: req.tier } : {},
+            ...req.tags !== void 0 ? { tags: req.tags } : {}
+          })
+        );
+        sendForSpan({ type: "agents-add-model", ...reply });
+        return;
+      }
+      if (msg.type === "agents-set-credential") {
+        if (!deps.runExternalAgentsCli) {
+          sendForSpan({ type: "agents-set-credential", ok: false, error: { code: "bridge_offline", detail: "external-agents is not configured on this bridge" } });
+          return;
+        }
+        const handlerDeps = {
+          run: deps.runExternalAgentsCli,
+          registryEnvNames: externalAgentsRegistryEnvNames,
+          lastKnownState: externalAgentsLastKnownState
+        };
+        const req = msg;
+        const setCredResult = await handleAgentsSetCredential(handlerDeps, { env: req.env, value: req.value });
+        if (setCredResult.ok) await probeAgentsUsingEnvVar(handlerDeps, req.env);
+        const reply = await withPoolStateReread(handlerDeps, setCredResult);
+        sendForSpan({ type: "agents-set-credential", ...reply });
+        return;
+      }
+      if (msg.type === "agents-dispatch") {
+        if (!deps.runExternalAgentsCli) {
+          sendForSpan({ type: "agents-dispatch", ok: false, error: { code: "bridge_offline", detail: "external-agents is not configured on this bridge" } });
+          return;
+        }
+        const handlerDeps = {
+          run: deps.runExternalAgentsCli,
+          registryEnvNames: externalAgentsRegistryEnvNames,
+          lastKnownState: externalAgentsLastKnownState
+        };
+        const req = msg;
+        const reply = await withPoolStateReread(
+          handlerDeps,
+          await handleAgentsDispatch(handlerDeps, {
+            id: req.id,
+            prompt: req.prompt,
+            ...req.transport !== void 0 ? { transport: req.transport } : {},
+            ...req.effort !== void 0 ? { effort: req.effort } : {}
+          })
+        );
+        sendForSpan({ type: "agents-dispatch", ...reply });
+        return;
+      }
       if (msg.type === "bootstrap") {
         let models = null;
         let rateLimits = null;
@@ -48948,7 +49933,7 @@ function createBridgeMessageHandler(deps) {
       thread.inFlight = true;
       pendingTurnSessions.delete(directorSessionId);
       thread.replay = createReplayBuffer({
-        turnId: (0, import_node_crypto7.randomUUID)(),
+        turnId: (0, import_node_crypto8.randomUUID)(),
         spanId,
         ...deps.retentionMs !== void 0 ? { retentionMs: deps.retentionMs } : {},
         ...deps.ackLingerMs !== void 0 ? { ackLingerMs: deps.ackLingerMs } : {}
@@ -49353,8 +50338,8 @@ async function startDirectorBridge() {
     codexCwd: config2.codexCwd,
     codexExecutable: config2.codexExecutable,
     checkoutRegistry,
-    worktreeRoot: import_node_path17.default.join(config2.stateDir, "worktrees"),
-    locksDir: import_node_path17.default.join(config2.stateDir, "locks"),
+    worktreeRoot: import_node_path18.default.join(config2.stateDir, "worktrees"),
+    locksDir: import_node_path18.default.join(config2.stateDir, "locks"),
     // Wire the executor server for code-execution runs. Each run gets its own app-server
     // process at the run worktree, running UNRESTRICTED from the real ~/.codex (owner
     // no-sandbox decision — auth + mrrlin MCP come from the operator config).
@@ -49390,13 +50375,13 @@ async function startDirectorBridge() {
         // egressDomains is retained in the seam signature (verification-turn.ts still computes the
         // env host) but no longer constrains anything — the executor is unrestricted.
         startSandbox: async (_egressDomains) => {
-          const cwd = import_node_fs13.default.mkdtempSync(import_node_path17.default.join(import_node_os8.default.tmpdir(), "mrrlin-verify-"));
+          const cwd = import_node_fs14.default.mkdtempSync(import_node_path18.default.join(import_node_os9.default.tmpdir(), "mrrlin-verify-"));
           let handle;
           try {
             handle = await startExecutorServer({ worktree: cwd });
           } catch (error51) {
             try {
-              import_node_fs13.default.rmSync(cwd, { recursive: true, force: true });
+              import_node_fs14.default.rmSync(cwd, { recursive: true, force: true });
             } catch {
             }
             throw error51;
@@ -49407,7 +50392,7 @@ async function startDirectorBridge() {
             dispose: () => {
               handle.dispose();
               try {
-                import_node_fs13.default.rmSync(cwd, { recursive: true, force: true });
+                import_node_fs14.default.rmSync(cwd, { recursive: true, force: true });
               } catch {
               }
             }
@@ -49435,7 +50420,7 @@ async function startDirectorBridge() {
   };
   const sessionSinks = createSessionSinkRegistry();
   const tombstones = /* @__PURE__ */ new Map();
-  const bridgeInstanceId = (0, import_node_crypto7.randomUUID)();
+  const bridgeInstanceId = (0, import_node_crypto8.randomUUID)();
   const asyncConsumerDeps = {
     client,
     runExclusive: wrappedTurnLock.runExclusive,
@@ -49589,7 +50574,7 @@ async function startDirectorBridge() {
     fileUpdateInboxItem: async (projectSlug) => {
       const body = selfUpdateHandle.updateInboxBody();
       if (!body) return;
-      const id = `II-MCPUPD-${(0, import_node_crypto7.randomUUID)()}`;
+      const id = `II-MCPUPD-${(0, import_node_crypto8.randomUUID)()}`;
       try {
         const row = await client.createInboxItem(projectSlug, { id, kind: "question", body });
         process.stderr.write(
@@ -49610,12 +50595,15 @@ async function startDirectorBridge() {
 `
         );
       }
-    }
+    },
+    // External-agents control plane: the real spawn runner, with the EXTERNAL_AGENTS_CLI operator
+    // escape hatch bound here (the handlers stay spawn-free and this is the only production seam).
+    runExternalAgentsCli: (args, opts) => runExternalAgentsCli(args, { ...opts, envCliPath: process.env["EXTERNAL_AGENTS_CLI"] })
   };
   const bridgeLogger = createBridgeLogger(config2.stateDir, process.env);
   let bridgeBinShaShort = "unknown00000";
   try {
-    bridgeBinShaShort = import_node_crypto7.default.createHash("sha256").update(import_node_fs13.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
+    bridgeBinShaShort = import_node_crypto8.default.createHash("sha256").update(import_node_fs14.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
   } catch {
   }
   attachBridgeWss(server, {
@@ -49744,8 +50732,8 @@ async function startDirectorBridge() {
       enqueueRun(
         () => runOrphanWorktreeSweep(client, {
           checkoutRegistry,
-          worktreeRoot: import_node_path17.default.join(config2.stateDir, "worktrees"),
-          locksDir: import_node_path17.default.join(config2.stateDir, "locks")
+          worktreeRoot: import_node_path18.default.join(config2.stateDir, "worktrees"),
+          locksDir: import_node_path18.default.join(config2.stateDir, "locks")
         })
       );
       enqueueRun(async () => {
@@ -49985,7 +50973,7 @@ function timingSafeTokenEqual(provided, expected) {
   const a = Buffer.from(provided);
   const b = Buffer.from(expected);
   if (a.length !== b.length) return false;
-  return import_node_crypto7.default.timingSafeEqual(a, b);
+  return import_node_crypto8.default.timingSafeEqual(a, b);
 }
 function readDispatchBody(req) {
   return new Promise((resolve, reject) => {
@@ -50007,15 +50995,15 @@ function readDispatchBody(req) {
 function readOrCreateBridgeToken(stateDir) {
   const explicit = (process.env.MRRLIN_DIRECTOR_BRIDGE_TOKEN ?? "").trim();
   if (explicit) return explicit;
-  const tokenPath = import_node_path17.default.join(stateDir, "token.txt");
+  const tokenPath = import_node_path18.default.join(stateDir, "token.txt");
   try {
-    const existing = import_node_fs13.default.readFileSync(tokenPath, "utf8").trim();
+    const existing = import_node_fs14.default.readFileSync(tokenPath, "utf8").trim();
     if (existing) return existing;
   } catch {
   }
-  import_node_fs13.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
-  const token = import_node_crypto7.default.randomBytes(32).toString("base64url");
-  import_node_fs13.default.writeFileSync(tokenPath, `${token}
+  import_node_fs14.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
+  const token = import_node_crypto8.default.randomBytes(32).toString("base64url");
+  import_node_fs14.default.writeFileSync(tokenPath, `${token}
 `, { mode: 384 });
   return token;
 }
@@ -52588,7 +53576,7 @@ var Protocol = class {
     };
   }
 };
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function mergeCapabilities(base, additional) {
@@ -52599,7 +53587,7 @@ function mergeCapabilities(base, additional) {
     if (addValue === void 0)
       continue;
     const baseValue = result[k];
-    if (isPlainObject3(baseValue) && isPlainObject3(addValue)) {
+    if (isPlainObject4(baseValue) && isPlainObject4(addValue)) {
       result[k] = { ...baseValue, ...addValue };
     } else {
       result[k] = addValue;
@@ -53397,19 +54385,19 @@ var StdioServerTransport = class {
 };
 
 // src/tools.ts
-var import_node_crypto10 = require("node:crypto");
+var import_node_crypto11 = require("node:crypto");
 var import_promises3 = require("node:fs/promises");
-var import_node_fs14 = require("node:fs");
-var import_node_path19 = __toESM(require("node:path"), 1);
-var import_node_os9 = __toESM(require("node:os"), 1);
+var import_node_fs15 = require("node:fs");
+var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_os10 = __toESM(require("node:os"), 1);
 var import_node_child_process12 = require("node:child_process");
 
 // ../../packages/wiki/dist/index.js
 var import_promises2 = __toESM(require("node:fs/promises"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_path19 = __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_path18.default.sep).join("/");
+  return input.split(import_node_path19.default.sep).join("/");
 }
 function slugifyWikiSegment(input) {
   return input.trim().toLowerCase().replace(/`/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -53423,12 +54411,12 @@ async function pathExists2(input) {
   }
 }
 async function findWorkspaceRoot(start = process.cwd()) {
-  let current = import_node_path18.default.resolve(start);
+  let current = import_node_path19.default.resolve(start);
   while (true) {
-    if (await pathExists2(import_node_path18.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path18.default.join(current, "docs"))) {
+    if (await pathExists2(import_node_path19.default.join(current, "pnpm-workspace.yaml")) && await pathExists2(import_node_path19.default.join(current, "docs"))) {
       return current;
     }
-    const parent = import_node_path18.default.dirname(current);
+    const parent = import_node_path19.default.dirname(current);
     if (parent === current) {
       throw new Error(`Unable to find Mrrlin workspace root from ${start}`);
     }
@@ -53437,28 +54425,28 @@ async function findWorkspaceRoot(start = process.cwd()) {
 }
 async function resolveDocsRoot(input) {
   if (input) {
-    return import_node_path18.default.resolve(input);
+    return import_node_path19.default.resolve(input);
   }
   if (process.env.MRRLIN_DOCS_ROOT) {
-    return import_node_path18.default.resolve(process.env.MRRLIN_DOCS_ROOT);
+    return import_node_path19.default.resolve(process.env.MRRLIN_DOCS_ROOT);
   }
-  return import_node_path18.default.join(await findWorkspaceRoot(), "docs");
+  return import_node_path19.default.join(await findWorkspaceRoot(), "docs");
 }
 async function resolveIndexPath(input) {
   if (input) {
-    return import_node_path18.default.resolve(input);
+    return import_node_path19.default.resolve(input);
   }
   if (process.env.MRRLIN_WIKI_INDEX_PATH) {
-    return import_node_path18.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
+    return import_node_path19.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
   }
   const workspaceRoot = await findWorkspaceRoot();
-  return import_node_path18.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
+  return import_node_path19.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_path18.default.join(dir, entry.name);
+    const absolute = import_node_path19.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkMarkdownFiles(root, absolute));
       continue;
@@ -53477,7 +54465,7 @@ function parseTitle(markdown, sourcePath) {
   return title;
 }
 function documentFromFile(docsRoot, absolutePath, markdown) {
-  const relativePath = toPosixPath(import_node_path18.default.relative(docsRoot, absolutePath));
+  const relativePath = toPosixPath(import_node_path19.default.relative(docsRoot, absolutePath));
   const [section, fileName] = relativePath.split("/");
   if (!section || !fileName || !INCLUDED_DOC_FOLDERS.has(section)) {
     return null;
@@ -54112,7 +55100,7 @@ async function resolveActiveRunHead(input, deps) {
 }
 
 // src/async-tools/consensus.ts
-var import_node_crypto8 = require("node:crypto");
+var import_node_crypto9 = require("node:crypto");
 function normalizeClarificationQuestion(question) {
   return question.replace(/\s+/g, " ").trim().replace(/[?.!]+$/, "").trim();
 }
@@ -54289,9 +55277,9 @@ async function run(ctx, input) {
       }
       if (taskId) {
         const scopeId = taskId;
-        const groupId = clarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto8.createHash)("sha256").update(clarifications.map((c) => c.question).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+        const groupId = clarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(clarifications.map((c) => c.question).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
         for (const clarification of clarifications) {
-          const id = `II-${scopeId}-gate-${(0, import_node_crypto8.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
+          const id = `II-${scopeId}-gate-${(0, import_node_crypto9.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
           try {
             const questionOptions = buildGateQuestionOptions(clarification.question, clarification.category);
             await ctx.client.createInboxItem(input.projectSlug, {
@@ -54309,9 +55297,9 @@ async function run(ctx, input) {
         filedQuestionCount = clarifications.length;
       } else if (planId) {
         const scopeId = planId;
-        const groupId = clarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto8.createHash)("sha256").update(clarifications.map((c) => c.question).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+        const groupId = clarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(clarifications.map((c) => c.question).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
         for (const clarification of clarifications) {
-          const id = `II-${scopeId}-gate-${(0, import_node_crypto8.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
+          const id = `II-${scopeId}-gate-${(0, import_node_crypto9.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
           try {
             const questionOptions = buildGateQuestionOptions(clarification.question, clarification.category);
             await ctx.client.createInboxItem(input.projectSlug, {
@@ -54440,33 +55428,32 @@ async function run2(ctx, input) {
     { projectSlug: input.projectSlug, deliverablePageId: input.pageId },
     deps
   );
-  switch (result.outcome) {
-    case "CONVERGED":
-    case "SKIPPED":
-      return { kind: "done", resultJson: JSON.stringify(result), finalReviewedHash: null };
-    case "CONSENSUS_UNAVAILABLE":
-      return { kind: "retry", failureReason: "provider_unavailable", error: "Deliverable consensus unavailable (provider/quota)." };
-    case "DELIVERABLE_CHANGED_DURING_REVIEW":
-      return { kind: "retry", failureReason: "spec_changed", error: "Deliverable changed during review." };
-    case "MISSING_ACCEPTANCE_CRITERIA":
-      return {
-        kind: "failed",
-        failureReason: "consensus_blocked",
-        error: "Deliverable cannot be gated: the linked spec has no `## Acceptance criteria` checklist."
-      };
-    case "CONSENSUS_BLOCKED":
-      return {
-        kind: "failed",
-        failureReason: "consensus_blocked",
-        error: "Deliverable consensus blocked: reviewers did not converge against the acceptance criteria."
-      };
-    default:
-      return {
-        kind: "failed",
-        failureReason: "provider_unavailable",
-        error: `Unexpected deliverable consensus outcome: ${String(result.outcome)}`
-      };
+  if (result.outcome === "CONVERGED" || result.outcome === "SKIPPED") {
+    return { kind: "done", resultJson: JSON.stringify(result), finalReviewedHash: null };
   }
+  const mapped = mapDeliverableGateResult(result);
+  if (mapped.action === "retry") {
+    return {
+      kind: "retry",
+      failureReason: result.outcome === "CONSENSUS_UNAVAILABLE" ? "provider_unavailable" : "spec_changed",
+      error: mapped.reason
+    };
+  }
+  let filedQuestionCount = 0;
+  if (mapped.action === "questions") {
+    const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+    const taskId = page?.taskId ?? null;
+    if (taskId) {
+      filedQuestionCount = await fileDeliverableGateQuestions(ctx.client, input.projectSlug, taskId, mapped.clarifications);
+    }
+  }
+  const error51 = filedQuestionCount > 0 ? `Consensus blocked on ${filedQuestionCount} clarification(s); filed as operator question(s).` : mapped.reason;
+  return {
+    kind: "failed",
+    failureReason: "consensus_blocked",
+    error: error51,
+    filedQuestionCount
+  };
 }
 function onComplete3(outcome, input) {
   if (outcome.kind === "done") {
@@ -54486,6 +55473,14 @@ function onComplete3(outcome, input) {
       body: `Deliverable consensus CONVERGED for Deliverables/${input.pageId}; it meets the acceptance criteria.`
     };
   }
+  if (outcome.kind === "failed" && (outcome.filedQuestionCount ?? 0) > 0) {
+    const n = outcome.filedQuestionCount ?? 0;
+    return {
+      kind: "info",
+      suppressInbox: true,
+      body: `Deliverable consensus blocked on Deliverables/${input.pageId}; filed ${n} clarifying question${n === 1 ? "" : "s"} \u2014 answer to unblock the run.`
+    };
+  }
   return {
     kind: "handoff",
     body: `Deliverable consensus could not complete for Deliverables/${input.pageId}: ${outcome.error} Needs operator attention.`
@@ -54501,7 +55496,7 @@ var deliverableConsensusDescriptor = {
 };
 
 // src/async-tools/enqueue.ts
-var import_node_crypto9 = __toESM(require("node:crypto"), 1);
+var import_node_crypto10 = __toESM(require("node:crypto"), 1);
 async function enqueueAsyncTool(client, descriptor2, input) {
   if (descriptor2.cachedResult) {
     const cached2 = await descriptor2.cachedResult(client, input);
@@ -54514,7 +55509,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_crypto9.default.randomUUID()}`;
+  const jobId = `AJ-${import_node_crypto10.default.randomUUID()}`;
   try {
     await client.createAsyncJob(input.projectSlug, {
       id: jobId,
@@ -54602,6 +55597,7 @@ var mcpToolNames = {
   searchKnowledge: "search_knowledge",
   updateExecutionRun: "update_execution_run",
   upsertProjectSchedulerPolicy: "upsert_project_scheduler_policy",
+  recordDeployWorkflow: "record_deploy_workflow",
   updatePlan: "update_plan",
   updateTask: "update_task",
   resetDirectorThread: "reset_director_thread",
@@ -55179,6 +56175,13 @@ var appendExecutionArtifactInputSchema = runScopedSchema.merge(mrrlinExecutionAr
 var recordProducedUrlInputSchema = runScopedSchema.merge(mrrlinProducedUrlPayloadSchema);
 var getProjectSchedulerPolicyInputSchema = projectScopedSchema;
 var upsertProjectSchedulerPolicyInputSchema = projectScopedSchema.merge(mrrlinProjectSchedulerPolicyUpsertSchema);
+var recordDeployWorkflowInputSchema = projectScopedSchema.extend({
+  env: mrrlinDeployWorkflowEnvSchema,
+  workflowId: external_exports.number().int().positive().nullable(),
+  workflowPath: external_exports.string().nullable().optional(),
+  reason: external_exports.string().nullable().optional(),
+  state: mrrlinDeployWorkflowStateSchema.optional()
+});
 var getSchedulerPendingTasksInputSchema = projectScopedSchema;
 var wakeDirectorInputSchema = projectScopedSchema.merge(wakeDirectorRequestSchema.partial());
 var uploadArtifactInputSchema = projectScopedSchema.merge(
@@ -55261,6 +56264,7 @@ var mcpToolInputSchemas = {
   [mcpToolNames.searchKnowledge]: searchKnowledgeInputSchema,
   [mcpToolNames.updateExecutionRun]: updateExecutionRunInputSchema,
   [mcpToolNames.upsertProjectSchedulerPolicy]: upsertProjectSchedulerPolicyInputSchema,
+  [mcpToolNames.recordDeployWorkflow]: recordDeployWorkflowInputSchema,
   [mcpToolNames.updatePlan]: updatePlanInputSchema,
   [mcpToolNames.updateTask]: updateTaskInputSchema,
   [mcpToolNames.resetDirectorThread]: resetDirectorThreadInputSchema,
@@ -55323,6 +56327,7 @@ var mcpToolOperationIds = {
   [mcpToolNames.searchKnowledge]: openApiOperationIds.searchKnowledge,
   [mcpToolNames.updateExecutionRun]: openApiOperationIds.updateExecutionRun,
   [mcpToolNames.upsertProjectSchedulerPolicy]: openApiOperationIds.upsertProjectSchedulerPolicy,
+  [mcpToolNames.recordDeployWorkflow]: openApiOperationIds.upsertProjectDeployWorkflow,
   [mcpToolNames.updatePlan]: openApiOperationIds.updatePlan,
   [mcpToolNames.updateTask]: openApiOperationIds.updateTask,
   [mcpToolNames.resetDirectorThread]: openApiOperationIds.resetDirectorThread,
@@ -55386,6 +56391,7 @@ var mcpToolDescriptions = {
   [mcpToolNames.updateExecutionRun]: "Update an execution run (status, branch, SHA, PR url, dev/prod workflow ids, checkpoint cursor). Transitioning to handoff_queued requires an approved handoff_judgement artifact.",
   [mcpToolNames.getProjectSchedulerPolicy]: "Fetch the project scheduler policy: cadence floor, eligible autonomy levels, and optional wake_floor. Returns defaults if unset.",
   [mcpToolNames.upsertProjectSchedulerPolicy]: "Upsert the project scheduler policy. Partial: only provided fields overwrite existing values.",
+  [mcpToolNames.recordDeployWorkflow]: "Record which GitHub Actions workflow deploys this project for one environment (dev or prod), after confirming it via list_github_workflows + reading its file for a workflow_dispatch trigger. Call this AT MOST ONCE per environment per project, only when the deploy gate has parked on a missing/stale workflow id \u2014 this choice becomes durable project state, not a per-run decision. Pass workflowId=null and state='ambiguous' when zero or more than one candidate is confirmed dispatchable; otherwise pass the single confirmed workflowId with state='resolved' (the default). `source` is derived from your identity server-side \u2014 you cannot set it, and this call is always recorded as 'agent'.",
   [mcpToolNames.getSchedulerPendingTasks]: "Return tasks the scheduler should wake now: ones with follow_up_at or verification_due_at passed, or the policy wake_floor reached, filtered by eligible autonomy levels.",
   [mcpToolNames.wakeDirector]: "Wake Director once for a project: optionally dry-run scheduler evaluation or enqueue execution runs best-effort.",
   [mcpToolNames.listInboxItems]: "List operator-inbox items for a project. Optional filters: kind, status.",
@@ -55965,7 +56971,7 @@ function createMrrlinTools(options) {
       "PRODUCED_URL_RECORD_FAILED",
       "Unable to record produced URL.",
       async (c, { projectSlug, runId, url: url2, label }) => {
-        const id = `EA-pu-${(0, import_node_crypto10.randomBytes)(4).toString("hex")}`;
+        const id = `EA-pu-${(0, import_node_crypto11.randomBytes)(4).toString("hex")}`;
         const payload = label ? { url: url2, label } : { url: url2 };
         return await c.appendExecutionArtifact(projectSlug, runId, {
           id,
@@ -55988,6 +56994,13 @@ function createMrrlinTools(options) {
       "Unable to upsert project scheduler policy.",
       async (c, { projectSlug, ...input }) => await c.upsertProjectSchedulerPolicy(projectSlug, input)
     ),
+    [mcpToolNames.recordDeployWorkflow]: makeTool(
+      client,
+      mcpToolNames.recordDeployWorkflow,
+      "DEPLOY_WORKFLOW_RECORD_FAILED",
+      "Unable to record the project's deploy workflow choice.",
+      async (c, { projectSlug, env, ...input }) => await c.upsertProjectDeployWorkflow(projectSlug, env, input)
+    ),
     [mcpToolNames.getSchedulerPendingTasks]: makeTool(
       client,
       mcpToolNames.getSchedulerPendingTasks,
@@ -56032,7 +57045,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_path19.default.extname(filePath).toLowerCase();
+        const extension2 = import_node_path20.default.extname(filePath).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -56060,7 +57073,7 @@ function createMrrlinTools(options) {
             "Artifact exceeds 5MB; split or summarize instead."
           );
         }
-        const filename = import_node_path19.default.basename(filePath);
+        const filename = import_node_path20.default.basename(filePath);
         const created = await c.createArtifactFile(projectSlug, {
           class: artifactClass,
           contentType,
@@ -56143,7 +57156,7 @@ function createMrrlinTools(options) {
       "Unable to register local checkout.",
       async (_c, { projectSlug, path: checkoutPath, repo }) => {
         const trimmedPath = checkoutPath.trim();
-        if (!import_node_path19.default.isAbsolute(trimmedPath)) {
+        if (!import_node_path20.default.isAbsolute(trimmedPath)) {
           throw new McpToolCodedError(
             "LOCAL_CHECKOUT_PATH_NOT_ABSOLUTE",
             `Path must be absolute, got: ${trimmedPath}`
@@ -56151,7 +57164,7 @@ function createMrrlinTools(options) {
         }
         let resolvedPath;
         try {
-          resolvedPath = (0, import_node_fs14.realpathSync)(trimmedPath);
+          resolvedPath = (0, import_node_fs15.realpathSync)(trimmedPath);
         } catch {
           throw new McpToolCodedError(
             "LOCAL_CHECKOUT_PATH_NOT_FOUND",
@@ -56178,7 +57191,7 @@ function createMrrlinTools(options) {
             `Origin remote ${remoteUrl} does not match repo ${repo}.`
           );
         }
-        const stateDir = process.env.CODEX_HOME ? import_node_path19.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path19.default.join(import_node_os9.default.homedir(), ".mrrlin", "director-bridge");
+        const stateDir = process.env.CODEX_HOME ? import_node_path20.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path20.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);
@@ -56400,8 +57413,8 @@ function runSetCredential(args) {
 }
 
 // src/install-service.ts
-var import_node_os10 = __toESM(require("node:os"), 1);
-var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_os11 = __toESM(require("node:os"), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
 function installService(deps) {
   if (!deps.hasSecret()) {
     deps.log("No agent credential found. Issue one in Settings, then run: mrrlin-mcp set-credential '<secret>'.");
@@ -56412,7 +57425,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.");
@@ -56423,7 +57436,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_path20.default.dirname(b)))).join(":");
+  const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path21.default.dirname(b)))).join(":");
   const text = renderEcosystemConfig({
     cwd: resolved.cwd,
     home,
@@ -56432,7 +57445,7 @@ function installService(deps) {
     staging: deps.env.MRRLIN_STAGING === "1",
     apiBaseUrl: deps.env.MRRLIN_API_BASE_URL?.trim() || void 0
   });
-  const ecoPath = import_node_path20.default.join(home, ".mrrlin", "ecosystem.config.cjs");
+  const ecoPath = import_node_path21.default.join(home, ".mrrlin", "ecosystem.config.cjs");
   deps.writeFile(ecoPath, text);
   const start = deps.runPm2(["startOrReload", ecoPath]);
   if (start.code !== 0) {
@@ -56463,13 +57476,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_path21 = __toESM(require("node:path"), 1);
+var import_node_os12 = __toESM(require("node:os"), 1);
+var import_node_path22 = __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_path21.default.join(options.homeDir ?? import_node_os11.default.homedir(), ".codex");
+  return import_node_path22.default.join(options.homeDir ?? import_node_os12.default.homedir(), ".codex");
 }
 async function pathExists3(target) {
   try {
@@ -56482,7 +57495,7 @@ async function pathExists3(target) {
 var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.(?:mrrlin(?:-browser)?|external-agents)(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
 async function uninstallCodex(options = {}) {
   const codexHome = resolveCodexHome2(options);
-  const configPath = import_node_path21.default.join(codexHome, "config.toml");
+  const configPath = import_node_path22.default.join(codexHome, "config.toml");
   const removePrompts = async () => uninstallPrompts(codexHome, options.promptNames ?? []);
   if (!await pathExists3(configPath)) {
     return { action: "missing", configPath, prompts: await removePrompts() };
@@ -56510,10 +57523,10 @@ async function uninstallCodex(options = {}) {
 }
 async function uninstallPrompts(codexHome, names) {
   if (names.length === 0) return [];
-  const promptsDir = import_node_path21.default.join(codexHome, "prompts");
+  const promptsDir = import_node_path22.default.join(codexHome, "prompts");
   const out = [];
   for (const name of names) {
-    const promptPath = import_node_path21.default.join(promptsDir, `${name}.md`);
+    const promptPath = import_node_path22.default.join(promptsDir, `${name}.md`);
     try {
       await import_promises4.default.unlink(promptPath);
       out.push({ name, action: "removed", promptPath });
@@ -56766,8 +57779,8 @@ async function main() {
         }
       }
       try {
-        const codexHome = process.env.CODEX_HOME ?? import_node_path23.default.join(process.env.HOME ?? (0, import_node_os12.homedir)(), ".codex");
-        (0, import_node_fs15.rmSync)(import_node_path23.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
+        const codexHome = process.env.CODEX_HOME ?? import_node_path24.default.join(process.env.HOME ?? (0, import_node_os13.homedir)(), ".codex");
+        (0, import_node_fs16.rmSync)(import_node_path24.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
       } catch {
       }
       return;
@@ -56797,8 +57810,8 @@ async function main() {
         env: process.env,
         cwd: process.cwd(),
         writeFile: (p, c) => {
-          (0, import_node_fs15.mkdirSync)(import_node_path23.default.dirname(p), { recursive: true, mode: 448 });
-          (0, import_node_fs15.writeFileSync)(p, c, { mode: 384 });
+          (0, import_node_fs16.mkdirSync)(import_node_path24.default.dirname(p), { recursive: true, mode: 448 });
+          (0, import_node_fs16.writeFileSync)(p, c, { mode: 384 });
         },
         runPm2: pm2Runner,
         which: whichBin,
@@ -56815,35 +57828,35 @@ async function main() {
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs15.rmSync)(p, { force: true });
+            (0, import_node_fs16.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: purge,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path23.default.join(process.env.HOME ?? (0, import_node_os12.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path24.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({
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs15.rmSync)(p, { force: true });
+            (0, import_node_fs16.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: true,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path23.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path24.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
         log
       });
       let codexOk = true;
@@ -56863,7 +57876,7 @@ async function main() {
         log(`codex config NOT modified: ${error51 instanceof Error ? error51.message : String(error51)}`);
       }
       try {
-        (0, import_node_fs15.rmSync)(import_node_path23.default.join(home, ".mrrlin"), { recursive: true, force: true });
+        (0, import_node_fs16.rmSync)(import_node_path24.default.join(home, ".mrrlin"), { recursive: true, force: true });
       } catch {
       }
       log("removed ~/.mrrlin");
@@ -56904,7 +57917,7 @@ ${HELP_TEXT}`);
   }
 }
 function resolveSelfBinPath() {
-  return import_node_path22.default.resolve(process.argv[1] ?? process.execPath);
+  return import_node_path23.default.resolve(process.argv[1] ?? process.execPath);
 }
 main().catch((error51) => {
   process.stderr.write(`mrrlin-mcp fatal error: ${error51 instanceof Error ? error51.message : String(error51)}