@mrrlin-dev/mcp 0.3.52 → 0.3.55

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,12 +36499,15 @@ var openApiOperationIds = {
   deleteTaskDependency: "deleteTaskDependency",
   getExecutionRun: "getExecutionRun",
   getProjectSchedulerPolicy: "getProjectSchedulerPolicy",
+  getProjectDeployWorkflow: "getProjectDeployWorkflow",
   getSchedulerPendingTasks: "getSchedulerPendingTasks",
   wakeDirector: "wakeDirector",
   getGithubInstallationRepositories: "getGithubInstallationRepositories",
   getProject: "getProject",
   getProjectSnapshot: "getProjectSnapshot",
   getTask: "getTask",
+  archiveTask: "archiveTask",
+  unarchiveTask: "unarchiveTask",
   getWikiPage: "getWikiPage",
   handleGithubInstallCallback: "handleGithubInstallCallback",
   listExecutionArtifacts: "listExecutionArtifacts",
@@ -36530,6 +36533,7 @@ var openApiOperationIds = {
   searchKnowledge: "searchKnowledge",
   updateExecutionRun: "updateExecutionRun",
   upsertProjectSchedulerPolicy: "upsertProjectSchedulerPolicy",
+  upsertProjectDeployWorkflow: "upsertProjectDeployWorkflow",
   updatePlan: "updatePlan",
   updateTask: "updateTask",
   updateWikiPage: "updateWikiPage",
@@ -36554,6 +36558,7 @@ var openApiOperationIds = {
   listArtifactFiles: "listArtifactFiles",
   getOperatorSettings: "getOperatorSettings",
   updateOperatorSettings: "updateOperatorSettings",
+  recordOperatorPresence: "recordOperatorPresence",
   getAgentPool: "getAgentPool",
   putAgentPool: "putAgentPool",
   getConsensusConfig: "getConsensusConfig",
@@ -36598,6 +36603,8 @@ var mrrlinOperatorSettingsSchema = external_exports.object({
   // to it (the web active-project selection is otherwise only a browser cookie). Null = not
   // selected yet.
   activeProjectSlug: external_exports.string().min(1).nullable(),
+  // The last time an authenticated BROWSER operator session was observed. Null means never seen.
+  lastPresenceAt: external_exports.string().datetime().nullable(),
   createdAt: external_exports.string().datetime(),
   updatedAt: external_exports.string().datetime()
 });
@@ -36609,6 +36616,7 @@ var mrrlinOperatorSettingsUpdateSchema = external_exports.object({
   message: "OperatorSettingsUpdate requires at least one field"
 });
 var operatorSettingsResponseSchema = external_exports.object({ data: mrrlinOperatorSettingsSchema });
+var operatorPresenceResponseSchema = external_exports.object({ data: external_exports.object({ lastPresenceAt: external_exports.string().datetime() }) });
 var mrrlinConsensusConfigSchema = external_exports.object({ consensusEnabled: external_exports.boolean() });
 var consensusConfigResponseSchema = external_exports.object({ data: mrrlinConsensusConfigSchema });
 var agentPoolSnapshotSchema = external_exports.object({
@@ -36746,7 +36754,13 @@ var mrrlinTaskDomainSchema = external_exports.enum(["code", "seo", "marketing",
 var mrrlinSpecApprovedSchema = external_exports.enum(["pending", "approved", "skipped", "skipped_legacy"]);
 var mrrlinTaskSourceSchema = external_exports.enum(["fixture-import", "api"]);
 var mrrlinPlanStatusSchema = external_exports.enum(["active", "paused", "done", "archived"]);
-var mrrlinTaskEventTypeSchema = external_exports.enum(["autonomy_set", "director_thread_reset", "note"]);
+var mrrlinTaskEventTypeSchema = external_exports.enum([
+  "autonomy_set",
+  "director_thread_reset",
+  "note",
+  "archived",
+  "restored"
+]);
 var mrrlinTaskEventCreateKindSchema = external_exports.enum(["note"]);
 var githubRepositorySelectionSchema = external_exports.enum(["all", "selected"]);
 var mrrlinTaskIdSchema = external_exports.string().regex(/^GT-\d+$/);
@@ -36807,7 +36821,8 @@ var mrrlinExecutionRunStatusSchema = external_exports.enum([
   "done",
   "failed",
   "handoff_requested",
-  "handoff_queued"
+  "handoff_queued",
+  "cancelled"
 ]);
 var mrrlinExecutionArtifactKindSchema = external_exports.enum([
   "plan",
@@ -36859,6 +36874,9 @@ var taxonomyCategorySchema = external_exports.string().min(1).regex(/^[a-z][a-z0
 var taxonomySubcategorySchema = external_exports.string().min(1).regex(/^[a-z][a-z0-9-]*$/);
 var mrrlinTaskAssigneeSchema = external_exports.union([external_exports.string().regex(/^@/), external_exports.string().email()]).nullable();
 var mrrlinTaskSchema = external_exports.object({
+  // Output-optional (not defaulted-required) so existing task fixtures/mocks across the
+  // codebase need no churn; DB rows always resolve it to `string | null` via taskRowToTask.
+  archivedAt: external_exports.string().datetime().nullable().optional(),
   assignee: mrrlinTaskAssigneeSchema,
   autoDeploy: mrrlinAutoDeploySchema,
   // ADR 0020. OUTPUT-optional (not defaulted-required) so hardcoded task fixtures/mocks across the
@@ -37045,7 +37063,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(),
@@ -37102,6 +37124,7 @@ var mrrlinTaskUpdateSchema = external_exports.object({
   }
 });
 var mrrlinTaskListFiltersSchema = external_exports.object({
+  archived: external_exports.enum(["true", "false", "all"]).optional(),
   assignee: external_exports.string().startsWith("@").optional(),
   autoDeploy: mrrlinAutoDeploySchema.optional(),
   autonomyLevel: mrrlinAutonomyLevelSchema.optional(),
@@ -37639,6 +37662,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 +37681,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 +37693,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",
@@ -37785,7 +37845,11 @@ var schedulerPendingTasksResponseSchema = external_exports.object({
     // disclosure that some exist, so a misconfigured `github.operator` (e.g. it doesn't match the
     // person actually running the project) is visible as a large number instead of the autopilot
     // silently doing nothing.
-    excludedByOwnershipCount: external_exports.number().int().min(0)
+    excludedByOwnershipCount: external_exports.number().int().min(0),
+    // Additive: true when the operator-web-presence gate is the reason nothing new is starting
+    // (autonomyPaused takes precedence when both apply). Computed by the same shared helper the
+    // tick uses, so this page can never claim a task is starting when the tick would decline it.
+    presenceGated: external_exports.boolean()
   })
 });
 var wakeDirectorRequestSchema = external_exports.object({
@@ -38055,18 +38119,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 +38150,7 @@ function createMrrlinClient(config2) {
       throw new MrrlinApiError({
         code,
         method,
-        path: path18,
+        path: path19,
         responseBody: body,
         status: response.status,
         violations,
@@ -38341,7 +38405,8 @@ function createMrrlinClient(config2) {
       return taskEventListResponseSchema.parse(body).data;
     },
     async listTasks(projectSlug, filters = {}) {
-      const path18 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
+      const path19 = appendQuery(`${projectPath(projectSlug)}/tasks`, {
+        archived: filters.archived,
         assignee: filters.assignee,
         autonomyLevel: filters.autonomyLevel,
         blockedBy: filters.blockedBy,
@@ -38353,7 +38418,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 +38426,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) {
@@ -38399,6 +38464,18 @@ function createMrrlinClient(config2) {
       const body = await request(`${projectPath(projectSlug)}/tasks/${encodeURIComponent(taskId)}/director-thread/reset`, { method: "POST" });
       return taskResponseSchema.parse(body).data;
     },
+    async archiveTask(projectSlug, taskId) {
+      const body = await request(`${projectPath(projectSlug)}/tasks/${encodeURIComponent(taskId)}/archive`, {
+        method: "POST"
+      });
+      return taskResponseSchema.parse(body).data;
+    },
+    async unarchiveTask(projectSlug, taskId) {
+      const body = await request(`${projectPath(projectSlug)}/tasks/${encodeURIComponent(taskId)}/unarchive`, {
+        method: "POST"
+      });
+      return taskResponseSchema.parse(body).data;
+    },
     async updateWikiPage(projectSlug, pageId, patch) {
       const body = await request(`${projectPath(projectSlug)}/wiki/${encodeURIComponent(pageId)}`, {
         body: JSON.stringify(patch),
@@ -38721,6 +38798,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;
@@ -38745,6 +38841,10 @@ function createMrrlinClient(config2) {
       });
       return operatorSettingsResponseSchema.parse(body).data;
     },
+    async recordOperatorPresence() {
+      const body = await request(`/operator/presence`, { method: "POST" });
+      return operatorPresenceResponseSchema.parse(body).data;
+    },
     async getOperatorAgentPool() {
       const body = await request(`/operator/agent-pool`);
       return agentPoolResponseSchema.parse(body).data;
@@ -39259,7 +39359,7 @@ function startCodexProbe(deps = {}) {
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.3.52";
+var PKG_VERSION = "0.3.55";
 
 // src/api-base-url-migrate.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
@@ -39789,9 +39889,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 +40001,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 +40017,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 +40161,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 +41036,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 +41423,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 +41548,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 +41626,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 +41686,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 +41707,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 +41756,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 +41793,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 +41803,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 +41870,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 +42053,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 +42197,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 +42235,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 +42274,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 +42301,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 +42378,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 +42422,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 +42440,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 +42524,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 +42673,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 +42722,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 +42731,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 +42754,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 +42845,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 +42879,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 +42891,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 +43214,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 +43228,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 +43289,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 +43355,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 +43390,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 +43479,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 +43495,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 +43579,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 +43592,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 +43839,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 +44096,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 +44127,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 +47708,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 +47720,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 +47943,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 +48274,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 +48687,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 +48698,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 +48750,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 +48764,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 +48788,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 +48809,21 @@ 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`.",
     "",
+    "Tool-use contract \u2014 typed MCP tools are the ONLY channel for Mrrlin data:",
+    "- Every read or write of Mrrlin data \u2014 tasks, plans, wiki pages, inbox items, execution runs,",
+    "  projects \u2014 must go through the corresponding typed MCP tool. Never use `commandExecution`,",
+    "  `curl`, `python`, or any direct HTTP call to the Mrrlin API.",
+    "- A single `create_task` call creates a task completely; it accepts `title`, `notes`, `category`,",
+    "  `subcategory`, `impact`, `autonomyLevel`, `planId`, `parentTaskId`, and more in one call.",
+    "  Do not create then patch, and do not re-read the task afterwards unless the operator asked",
+    "  for confirmation.",
+    "- `commandExecution` is for the operator's own machine and repositories \u2014 running builds, tests,",
+    "  `git`, inspecting local files \u2014 and for public third-party web checks. It is not a transport",
+    "  for this product's API.",
+    "- If no typed tool exists for a needed operation, state that to the operator instead of reaching",
+    "  for the API by hand.",
+    "- Do not spend turns re-reading state you just wrote.",
+    "",
     "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.",
@@ -48059,9 +48897,10 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     '  Never answer "nothing found" from plans alone.',
     '- Only report "nothing found" after the q-variants AND a full-list scan are empty, and then',
     "  state exactly what you searched.",
-    "- For public HTTP/HTML verification through `commandExecution`, prefer built-in tooling such",
-    "  as `curl`, `python3` stdlib `urllib.request`, and `html.parser`; do not assume third-party",
-    "  Python packages such as `requests` or `bs4` are installed.",
+    "- For public/third-party HTTP/HTML verification through `commandExecution`, prefer built-in",
+    "  tooling such as `curl`, `python3` stdlib `urllib.request`, and `html.parser`; do not assume",
+    "  third-party Python packages such as `requests` or `bs4` are installed. This permission covers",
+    "  third-party sites ONLY \u2014 never call the Mrrlin API from `commandExecution`.",
     "",
     "Handoff contract \u2014 durable operator action MUST NOT live only in chat:",
     "- If you conclude that a specific task needs human input, account access, manual evidence,",
@@ -48304,7 +49143,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;
     }
@@ -48342,8 +49181,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();
@@ -48418,7 +49257,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;
@@ -48542,6 +49381,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,
@@ -48656,7 +49534,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();
@@ -48693,7 +49571,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" });
@@ -48704,6 +49585,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;
@@ -48969,7 +49986,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 } : {}
@@ -49374,8 +50391,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).
@@ -49411,13 +50428,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;
@@ -49428,7 +50445,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 {
               }
             }
@@ -49456,7 +50473,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,
@@ -49610,7 +50627,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(
@@ -49631,12 +50648,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, {
@@ -49765,8 +50785,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 () => {
@@ -50006,7 +51026,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) => {
@@ -50028,15 +51048,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;
 }
@@ -52609,7 +53629,7 @@ var Protocol = class {
     };
   }
 };
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function mergeCapabilities(base, additional) {
@@ -52620,7 +53640,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;
@@ -53418,19 +54438,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, "");
@@ -53444,12 +54464,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}`);
     }
@@ -53458,28 +54478,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;
@@ -53498,7 +54518,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;
@@ -53682,15 +54702,35 @@ function firstTaskIdToken(text) {
 }
 
 // src/consensus/spec-gate.ts
+function mapAcceptedIssueToClarification(issue2) {
+  const text = issue2.text.toLowerCase();
+  let kind;
+  if (issue2.category === "scope") {
+    const directionCues = ["only", "or also", "narrower", "broader", "include", "exclude", "versus", "vs"];
+    kind = directionCues.some((cue) => text.includes(cue)) ? "scope_direction" : "missing_requirement";
+  } else {
+    const acceptanceCues = ["acceptance", "done", "success", "criteria", "satisfy"];
+    kind = acceptanceCues.some((cue) => text.includes(cue)) ? "acceptance_criteria_detail" : "default_choice";
+  }
+  return {
+    kind,
+    diagnostic: false,
+    rawQuestion: issue2.text,
+    whyBlocking: `reviewer raised a ${issue2.category} issue`,
+    category: issue2.category
+  };
+}
 async function runSpecGate(_target, deps, opts) {
   if (!await deps.consensusEnabled()) return { outcome: "SKIPPED" };
   const intent = await deps.readIntent();
   if (intent.taskId !== null && (intent.seed === null || intent.seed.trim() === "")) {
     return {
       outcome: "CONSENSUS_BLOCKED",
-      clarifications: [
+      operatorClarifications: [
         {
-          question: "What are the requirements for this task? There is no operator request on record, so the spec cannot be validated against your intent \u2014 please state what this task must do.",
+          kind: "missing_requirement",
+          diagnostic: false,
+          rawQuestion: "What are the requirements for this task? There is no operator request on record, so the spec cannot be validated against your intent \u2014 please state what this task must do.",
           whyBlocking: "operator_seed_request is empty",
           category: "scope"
         }
@@ -53704,9 +54744,11 @@ async function runSpecGate(_target, deps, opts) {
   if (normalizeDomain(intent.domain) !== "code" && parseAcceptanceCriteria(spec.markdownBody) === null) {
     return {
       outcome: "CONSENSUS_BLOCKED",
-      clarifications: [
+      operatorClarifications: [
         {
-          question: "This spec has no machine-usable acceptance criteria. Add an `## Acceptance criteria` section written as a markdown checklist (`- [ ] \u2026` items) describing exactly what the finished deliverable must satisfy \u2014 the review of the produced work is scored against it.",
+          kind: "acceptance_criteria_detail",
+          diagnostic: false,
+          rawQuestion: "This spec has no machine-usable acceptance criteria. Add an `## Acceptance criteria` section written as a markdown checklist (`- [ ] \u2026` items) describing exactly what the finished deliverable must satisfy \u2014 the review of the produced work is scored against it.",
           whyBlocking: "non-code spec is missing a parseable `## Acceptance criteria` checklist",
           category: "scope"
         }
@@ -53756,9 +54798,11 @@ async function runSpecGate(_target, deps, opts) {
     );
     return {
       outcome: "CONSENSUS_BLOCKED",
-      clarifications: [
+      diagnostics: [
         {
-          question: `SPEC_IDENTITY_MISMATCH: this spec page gates ${intent.taskId}, but its heading identifies a different task \u2014 rewrite the spec heading and content for ${intent.taskId}, or re-link the task.`,
+          kind: "spec_identity_mismatch",
+          diagnostic: true,
+          rawQuestion: `SPEC_IDENTITY_MISMATCH: this spec page gates ${intent.taskId}, but its heading identifies a different task \u2014 rewrite the spec heading and content for ${intent.taskId}, or re-link the task.`,
           whyBlocking: "converged spec content belongs to a different task than the one it gates",
           category: "scope"
         }
@@ -53778,12 +54822,8 @@ async function runSpecGate(_target, deps, opts) {
   }
   if (result.outcome === "CONSENSUS_BLOCKED") {
     const accepted = result.history.at(-1)?.accepted ?? [];
-    const clarifications = accepted.filter((issue2) => issue2.category === "ambiguity" || issue2.category === "scope").map((issue2) => ({
-      question: issue2.text,
-      whyBlocking: `reviewer raised a ${issue2.category} issue`,
-      category: issue2.category
-    }));
-    return clarifications.length > 0 ? { outcome: "CONSENSUS_BLOCKED", clarifications } : { outcome: "CONSENSUS_BLOCKED" };
+    const operatorClarifications = accepted.filter((issue2) => issue2.category === "ambiguity" || issue2.category === "scope").map((issue2) => mapAcceptedIssueToClarification(issue2));
+    return operatorClarifications.length > 0 ? { outcome: "CONSENSUS_BLOCKED", operatorClarifications } : { outcome: "CONSENSUS_BLOCKED" };
   }
   return { outcome: result.outcome };
 }
@@ -54133,7 +55173,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();
 }
@@ -54208,6 +55248,22 @@ function buildGateQuestionOptions(question, category) {
     }
   ];
 }
+var HUMANIZE_TEMPLATE_BY_KIND = {
+  scope_direction: "The spec can be read in two different ways. Which direction should it follow?",
+  default_choice: "One important detail is still ambiguous. Which interpretation should the spec use?",
+  missing_requirement: "A required part of the task is still missing from the spec. What should it say?",
+  acceptance_criteria_detail: "The direction is clear, but the spec still needs a sharper success check. What should count as done?"
+};
+var HUMANIZE_CONTEXT_CAP = 200;
+function humanizeClarificationBody(clarification) {
+  const prefix = HUMANIZE_TEMPLATE_BY_KIND[clarification.kind];
+  let context = clarification.rawQuestion.replace(/\b(?:parseable|SPEC_IDENTITY_MISMATCH|machine-usable)\b/gi, "").replace(/\s+/g, " ").trim();
+  if (context.length > HUMANIZE_CONTEXT_CAP) {
+    const cutIdx = context.lastIndexOf(" ", HUMANIZE_CONTEXT_CAP);
+    context = context.slice(0, cutIdx > 0 ? cutIdx : HUMANIZE_CONTEXT_CAP).trim() + "\u2026";
+  }
+  return context ? `${prefix} ${context}` : prefix;
+}
 var defaultNativeSpecGateBuilders = { buildSpecGateDeps, runSpecGate };
 async function runNativeSpecGate(ctx, input, builders = defaultNativeSpecGateBuilders) {
   const deps = builders.buildSpecGateDeps({
@@ -54248,6 +55304,100 @@ async function cachedResult(client, input) {
   }
   return null;
 }
+async function handleConsensusBlocked(result, ctx, input, resolvedTaskId) {
+  const operatorClarifications = result.operatorClarifications ?? [];
+  const diagnostics = result.diagnostics ?? [];
+  if (operatorClarifications.length > 0) {
+    try {
+      const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+      if (page) {
+        const domain2 = await resolveSpecDomain(ctx.client, input.projectSlug, {
+          id: page.id,
+          taskId: page.taskId ?? null
+        });
+        await ctx.client.recordSpecConsensusReview(input.projectSlug, input.pageId, {
+          contentHash: domainScopedReviewHash(page.contentHash, domain2),
+          outcome: "CONSENSUS_BLOCKED_CLARIFICATION",
+          rounds: 0
+        });
+      }
+    } catch (error52) {
+      process.stderr.write(
+        `[mrrlin-mcp consensus] clarification verdict write failed for ${input.projectSlug}/${input.pageId}: ${error52 instanceof Error ? error52.message : String(error52)}
+`
+      );
+    }
+  }
+  let filedQuestionCount = 0;
+  if (operatorClarifications.length > 0) {
+    const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
+    const taskId = page?.taskId ?? null;
+    if (!resolvedTaskId && taskId) resolvedTaskId = taskId;
+    let planId = null;
+    if (!taskId) {
+      const plans = await ctx.client.listPlans(input.projectSlug);
+      planId = plans.find((p) => p.specWikiPageId === input.pageId)?.id ?? null;
+    }
+    if (taskId) {
+      const scopeId = taskId;
+      const groupId = operatorClarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(operatorClarifications.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+      for (const clarification of operatorClarifications) {
+        const id = `II-${scopeId}-gate-${(0, import_node_crypto9.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
+        try {
+          const questionOptions = buildGateQuestionOptions(clarification.rawQuestion, clarification.category);
+          await ctx.client.createInboxItem(input.projectSlug, {
+            id,
+            kind: "question",
+            taskId: scopeId,
+            body: humanizeClarificationBody(clarification),
+            origin: "gate",
+            questionOptions,
+            ...groupId ? { groupId } : {}
+          });
+        } catch {
+        }
+      }
+      filedQuestionCount = operatorClarifications.length;
+    } else if (planId) {
+      const scopeId = planId;
+      const groupId = operatorClarifications.length > 1 ? `II-${scopeId}-gate-group-${(0, import_node_crypto9.createHash)("sha256").update(operatorClarifications.map((c) => c.rawQuestion).sort().join("\n")).digest("hex").slice(0, 10)}` : void 0;
+      for (const clarification of operatorClarifications) {
+        const id = `II-${scopeId}-gate-${(0, import_node_crypto9.createHash)("sha256").update(clarification.rawQuestion).digest("hex").slice(0, 10)}`;
+        try {
+          const questionOptions = buildGateQuestionOptions(clarification.rawQuestion, clarification.category);
+          await ctx.client.createInboxItem(input.projectSlug, {
+            id,
+            kind: "question",
+            planId: scopeId,
+            body: humanizeClarificationBody(clarification),
+            origin: "gate",
+            questionOptions,
+            ...groupId ? { groupId } : {}
+          });
+        } catch {
+        }
+      }
+      filedQuestionCount = operatorClarifications.length;
+    }
+  }
+  let error51;
+  if (filedQuestionCount > 0) {
+    error51 = `Consensus blocked on ${filedQuestionCount} clarification(s); filed as operator question(s).`;
+  } else if (diagnostics.length > 0 && operatorClarifications.length === 0) {
+    error51 = "Consensus blocked: the spec content does not match its linked task. This requires fixing the spec/task relationship directly, not an inbox answer.";
+  } else if (operatorClarifications.length > 0) {
+    error51 = `Consensus blocked on ${operatorClarifications.length} clarification(s), but the spec page is not linked to a task or plan, so none could be filed as questions.`;
+  } else {
+    error51 = "Consensus blocked: reviewers did not converge within budget.";
+  }
+  return {
+    kind: "failed",
+    failureReason: "consensus_blocked",
+    error: error51,
+    filedQuestionCount,
+    ...resolvedTaskId ? { taskId: resolvedTaskId } : {}
+  };
+}
 async function run(ctx, input) {
   const result = await runNativeSpecGate(ctx, input);
   if (process.env[SHADOW_ENV_FLAG]) {
@@ -54276,95 +55426,7 @@ async function run(ctx, input) {
   } catch {
   }
   if (result.outcome === "CONSENSUS_BLOCKED") {
-    const clarifications = result.clarifications ?? [];
-    if (clarifications.length > 0) {
-      try {
-        const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
-        if (page) {
-          const domain2 = await resolveSpecDomain(ctx.client, input.projectSlug, {
-            id: page.id,
-            taskId: page.taskId ?? null
-          });
-          await ctx.client.recordSpecConsensusReview(input.projectSlug, input.pageId, {
-            contentHash: domainScopedReviewHash(page.contentHash, domain2),
-            outcome: "CONSENSUS_BLOCKED_CLARIFICATION",
-            rounds: 0
-          });
-        }
-      } catch (error52) {
-        process.stderr.write(
-          `[mrrlin-mcp consensus] clarification verdict write failed for ${input.projectSlug}/${input.pageId}: ${error52 instanceof Error ? error52.message : String(error52)}
-`
-        );
-      }
-    }
-    let filedQuestionCount = 0;
-    if (clarifications.length > 0) {
-      const page = await ctx.client.getWikiPage(input.projectSlug, input.pageId);
-      const taskId = page?.taskId ?? null;
-      if (!resolvedTaskId && taskId) resolvedTaskId = taskId;
-      let planId = null;
-      if (!taskId) {
-        const plans = await ctx.client.listPlans(input.projectSlug);
-        planId = plans.find((p) => p.specWikiPageId === input.pageId)?.id ?? null;
-      }
-      if (taskId) {
-        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;
-        for (const clarification of clarifications) {
-          const id = `II-${scopeId}-gate-${(0, import_node_crypto8.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
-          try {
-            const questionOptions = buildGateQuestionOptions(clarification.question, clarification.category);
-            await ctx.client.createInboxItem(input.projectSlug, {
-              id,
-              kind: "question",
-              taskId: scopeId,
-              body: clarification.question,
-              origin: "gate",
-              questionOptions,
-              ...groupId ? { groupId } : {}
-            });
-          } catch {
-          }
-        }
-        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;
-        for (const clarification of clarifications) {
-          const id = `II-${scopeId}-gate-${(0, import_node_crypto8.createHash)("sha256").update(clarification.question).digest("hex").slice(0, 10)}`;
-          try {
-            const questionOptions = buildGateQuestionOptions(clarification.question, clarification.category);
-            await ctx.client.createInboxItem(input.projectSlug, {
-              id,
-              kind: "question",
-              planId: scopeId,
-              body: clarification.question,
-              origin: "gate",
-              questionOptions,
-              ...groupId ? { groupId } : {}
-            });
-          } catch {
-          }
-        }
-        filedQuestionCount = clarifications.length;
-      }
-    }
-    let error51;
-    if (filedQuestionCount > 0) {
-      error51 = `Consensus blocked on ${filedQuestionCount} clarification(s); filed as operator question(s).`;
-    } else if (clarifications.length > 0) {
-      error51 = `Consensus blocked on ${clarifications.length} clarification(s), but the spec page is not linked to a task or plan, so none could be filed as questions.`;
-    } else {
-      error51 = "Consensus blocked: reviewers did not converge within budget.";
-    }
-    return {
-      kind: "failed",
-      failureReason: "consensus_blocked",
-      error: error51,
-      filedQuestionCount,
-      ...resolvedTaskId ? { taskId: resolvedTaskId } : {}
-    };
+    return handleConsensusBlocked(result, ctx, input, resolvedTaskId);
   }
   switch (result.outcome) {
     case "CONVERGED":
@@ -54461,33 +55523,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") {
@@ -54507,6 +55568,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.`
@@ -54522,7 +55591,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);
@@ -54535,7 +55604,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,
@@ -54623,9 +55692,12 @@ 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",
+  archiveTask: "archive_task",
+  unarchiveTask: "unarchive_task",
   updateWikiPage: "update_wiki_page",
   markSpecReady: "mark_spec_ready",
   runSpecConsensus: "run_spec_consensus",
@@ -55141,6 +56213,8 @@ var getTaskInputSchema = taskScopedSchema;
 var createTaskInputSchema = projectScopedSchema.merge(mrrlinTaskCreateSchema);
 var updateTaskInputSchema = taskScopedSchema.merge(mrrlinTaskUpdateSchema);
 var resetDirectorThreadInputSchema = taskScopedSchema;
+var archiveTaskInputSchema = taskScopedSchema;
+var unarchiveTaskInputSchema = taskScopedSchema;
 var listPlansInputSchema = projectScopedSchema;
 var createPlanInputSchema = projectScopedSchema.merge(mrrlinPlanCreateSchema);
 var updatePlanInputSchema = planScopedSchema.merge(mrrlinPlanUpdateSchema);
@@ -55200,6 +56274,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(
@@ -55282,9 +56363,12 @@ var mcpToolInputSchemas = {
   [mcpToolNames.searchKnowledge]: searchKnowledgeInputSchema,
   [mcpToolNames.updateExecutionRun]: updateExecutionRunInputSchema,
   [mcpToolNames.upsertProjectSchedulerPolicy]: upsertProjectSchedulerPolicyInputSchema,
+  [mcpToolNames.recordDeployWorkflow]: recordDeployWorkflowInputSchema,
   [mcpToolNames.updatePlan]: updatePlanInputSchema,
   [mcpToolNames.updateTask]: updateTaskInputSchema,
   [mcpToolNames.resetDirectorThread]: resetDirectorThreadInputSchema,
+  [mcpToolNames.archiveTask]: archiveTaskInputSchema,
+  [mcpToolNames.unarchiveTask]: unarchiveTaskInputSchema,
   [mcpToolNames.updateWikiPage]: updateWikiPageInputSchema,
   [mcpToolNames.markSpecReady]: markSpecReadyInputSchema,
   [mcpToolNames.runSpecConsensus]: runSpecConsensusInputSchema,
@@ -55344,9 +56428,12 @@ 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,
+  [mcpToolNames.archiveTask]: openApiOperationIds.archiveTask,
+  [mcpToolNames.unarchiveTask]: openApiOperationIds.unarchiveTask,
   [mcpToolNames.updateWikiPage]: openApiOperationIds.updateWikiPage,
   [mcpToolNames.markSpecReady]: openApiOperationIds.markSpecReady,
   [mcpToolNames.listInboxItems]: openApiOperationIds.listInboxItems,
@@ -55394,6 +56481,8 @@ var mcpToolDescriptions = {
   [mcpToolNames.updatePlan]: "Update a plan/epic.",
   [mcpToolNames.updateTask]: "Update a task. Honors DB invariants: closed_no_result requires linked Evidence wiki pages. Set directorThreadId here to persist the worker's resumable provider thread handle.",
   [mcpToolNames.resetDirectorThread]: "Clear a task's persisted Director execution thread handle so the next execution run starts a fresh provider thread. Records a director_thread_reset task event.",
+  [mcpToolNames.archiveTask]: "Archive a task: hides it from default reads, removes it from plan progress and scheduler consideration, cancels its non-terminal execution runs, and closes its open inbox items. Reversible \u2014 the project owner can restore it with unarchive_task. Records an 'archived' task event.",
+  [mcpToolNames.unarchiveTask]: "Restore an archived task to its original status and visibility. Owner-only \u2014 refused with NOT_PROJECT_OWNER for any other caller. Does not resurrect the execution runs or inbox items that were cancelled/closed when the task was archived. Records a 'restored' task event.",
   [mcpToolNames.updateWikiPage]: "Update a markdown Wiki page.",
   [mcpToolNames.markSpecReady]: "Mark a wiki page (folder=Specs) as ready (or not) for execution-run gating. The Director sets this true after validating the spec; any edit to the page's markdown auto-resets it to false.",
   [mcpToolNames.runSpecConsensus]: 'Enqueue the consensus review gate over a Specs/{id} page. Returns IMMEDIATELY with one of: already_converged (a CONVERGED review already exists for the current content \u2014 proceed straight to create_execution_run, do NOT call mark_spec_ready, it is already set), already_reviewed (a terminal CONSENSUS_BLOCKED for this content), already_running (a consensus job is in flight), or queued (a new job was launched). The review runs in the background; its result/blocker arrives in the inbox (info on CONVERGED, handoff on failure) and is surfaced into the open chat. Do NOT call again for the same spec and do NOT poll. On queued/already_running, tell the user it was launched and end the turn. Pass extraHeads: ["researcher"] for specs referencing external libraries/APIs, or ["debugger"] for root-cause/investigation specs to add opt-in specialist reviewers on top of the fixed four. For a NON-code task (domain seo/marketing/content, ADR 0020): the low-risk lanes `seo`, `marketing`, and `content` proceed to `create_execution_run` after consensus, using the same flow as code tasks. Report the spec\'s review outcome to the operator.',
@@ -55407,6 +56496,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.",
@@ -55823,6 +56913,20 @@ function createMrrlinTools(options) {
       "Unable to reset director thread.",
       async (c, { projectSlug, taskId }) => await c.resetDirectorThread(projectSlug, taskId)
     ),
+    [mcpToolNames.archiveTask]: makeTool(
+      client,
+      mcpToolNames.archiveTask,
+      "TASK_ARCHIVE_FAILED",
+      "Unable to archive task.",
+      async (c, { projectSlug, taskId }) => await c.archiveTask(projectSlug, taskId)
+    ),
+    [mcpToolNames.unarchiveTask]: makeTool(
+      client,
+      mcpToolNames.unarchiveTask,
+      "TASK_UNARCHIVE_FAILED",
+      "Unable to unarchive task.",
+      async (c, { projectSlug, taskId }) => await c.unarchiveTask(projectSlug, taskId)
+    ),
     [mcpToolNames.updateWikiPage]: makeTool(
       client,
       mcpToolNames.updateWikiPage,
@@ -55986,7 +57090,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,
@@ -56009,6 +57113,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,
@@ -56053,7 +57164,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(
@@ -56081,7 +57192,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,
@@ -56164,7 +57275,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}`
@@ -56172,7 +57283,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",
@@ -56199,7 +57310,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);
@@ -56421,8 +57532,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>'.");
@@ -56433,7 +57544,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.");
@@ -56444,7 +57555,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,
@@ -56453,7 +57564,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) {
@@ -56484,13 +57595,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 {
@@ -56503,7 +57614,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() };
@@ -56531,10 +57642,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 });
@@ -56787,8 +57898,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;
@@ -56818,8 +57929,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,
@@ -56836,35 +57947,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;
@@ -56884,7 +57995,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");
@@ -56925,7 +58036,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)}